必赢网址-必赢437-www437com

热门关键词: 必赢网址,必赢437,www437com

Linux设备驱动,自造请求

块设备驱动注册与注销

块设备驱动中的第1个工作通常是注册它们自己到内核,完成这个任务的函数是 register_blkdev(),其原型为:
int register_blkdev(unsigned int major, const char *name);

major 参数是块设备要使用的主设备号,name为设备名,它会在/proc/devices中被显示。 如果major为0,内核会自动分配一个新的主设备号register_blkdev()函数的返回值就是这个主设备号。如果返回1个负值,表明发生了一个错误。

与register_blkdev()对应的注销函数是unregister_blkdev(),其原型为:
int unregister_blkdev(unsigned int major, const char *name); 这里,传递给register_blkdev()的参数必须与传递给register_blkdev()的参数匹配,否则这个函数返回-EINVAL。

1.块设备概念
块设备是指只能以块(512Byte)为单位进行访问的设备,块大小一般是512个字节的整数倍。常见的块设备包括硬件,SD卡,光盘等。

 

块设备的请求队列操作

标准的请求处理程序能排序请求,并合并相邻的请求,如果一个块设备希望使用标准的请求处理程序,那它必须调用函数blk_init_queue来初始化请求队列。当处理在队列上的请求时,必须持有队列自旋锁。初始化请求队列
request_queue_t *blk_init_queue(request_fn_proc *rfn, spinlock_t *lock);

该函数的第1个参数是请求处理函数的指针,第2个参数是控制访问队列权限的自旋锁,这个函数会发生内存分配的行为,故它可能会失败,函数调用成
功时,它返回指向初始化请求队列的指针,否则,返回NULL。这个函数一般在块设备驱动的模块加载函数中调用。清除请求队列
void blk_cleanup_queue(request_queue_t * q);

这个函数完成将请求队列返回给系统的任务,一般在块设备驱动模块卸载函数中调用。

 

提取请求
struct request *elv_next_request(request_queue_t *queue); 
上述函数用于返回下一个要处理的请求(由 I/O 调度器决定),如果没有请求则返回NULL。

去除请求
void blkdev_dequeue_request(struct request *req); 
上述函数从队列中去除1个请求。如果驱动中同时从同一个队列中操作了多个请求,它必须以这样的方式将它们从队列中去除。

 

分配“请求队列”
request_queue_t *blk_alloc_queue(int gfp_mask);
对于FLASH、RAM盘等完全随机访问的非机械设备,并不需要进行复杂的I/O调度,这个时候,应该使用上述函数分配1个“请求队列”,并使用如下函数来绑定“请求队列”和“制造请求”函数。 void blk_queue_make_request(request_queue_t * q, 
make_request_fn * mfn);

void blk_queue_hardsect_size(request_queue_t *queue, 
unsigned short max); 
该函数用于告知内核块设备硬件扇区的大小,所有由内核产生的请求都是这个大小的倍数并且被正确对界。但是,内核块设备层和驱动之间的通信还是以512字节扇区为单位进行。

 

步骤:

在块设备驱动的模块加载函数中通常需要完成如下工作:
① 分配、初始化请求队列,绑定请求队列和请求函数。
② 分配、初始化gendisk,给gendisk的major、fops、queue等成
员赋值,最后添加gendisk。
③ 注册块设备驱动。
在块设备驱动的模块卸载函数中通常需要与模块加载函数相反的工作:
① 清除请求队列。
② 删除gendisk和对gendisk的引用。
③ 删除对块设备的引用,注销块设备驱动。

总结:

块设备的I/O操作方式与字符设备存在较大的不同,因而引入了
request_queue、request、bio等一系列数据结构。在整个块设备的I/O操作中,贯穿于始终的就是“请求”,字符设备的I/O操作则是直接进行不绕弯,
块设备的I/O操作会排队和整合。

驱动的任务是处理请求,对请求的排队和整合由I/O调度算法解决,因此,块设备驱动的核心就是请求处理函数或“制造请求”函数。

尽管在块设备驱动中仍然存在block_device_operations结构体及其成员函数,但其不再包含读写一类的成员函数,而只是包含打开、释放及I/O控制等
与具体读写无关的函数。块设备驱动的结构相当复杂的,但幸运的是,块设备不像字符设备那么包罗万象,它通常就是存储设备,而且驱动的主体已经
由Linux内核提供,针对一个特定的硬件系统,驱动工程师所涉及到的工作往往只是编写少量的与硬件直接交互的代码。

[cpp] view plain copy

 

 print?

  1. #include <linux/init.h>    
  2. #include <linux/module.h>    
  3. #include <linux/kernel.h>    
  4. #include <linux/fs.h>  
  5. #include <asm/uaccess.h>  
  6. #include <linux/spinlock.h>  
  7. #include <linux/sched.h>  
  8. #include <linux/types.h>  
  9. #include <linux/fcntl.h>  
  10. #include <linux/hdreg.h>  
  11. #include <linux/genhd.h>  
  12. #include <linux/blkdev.h>  
  13.   
  14. #define MAXBUF 1024   
  15.   
  16.   
  17. #define BLK_MAJOR 253  
  18.   
  19. char blk_dev_name[]="blk_dev";  
  20. static char flash[1024*16];  
  21.   
  22.   
  23. int major;  
  24. spinlock_t lock;  
  25. struct gendisk *gd;  
  26.   
  27.   
  28.   
  29. /*块设备数据传输*/  
  30. static void blk_transfer(unsigned long sector, unsigned long nsect, char *buffer, int write)  
  31. {  
  32.     int read = !write;  
  33.     if(read)  
  34.     {  
  35.         memcpy(buffer, flash+sector*512, nsect*512);  
  36.     }  
  37.     else  
  38.     {  
  39.         memcpy(flash+sector*512, buffer, nsect*512);  
  40.     }  
  41. }  
  42.   
  43. /*块设备请求处理函数*/  
  44. static void blk_request_func(struct request_queue *q)  
  45. {  
  46.     struct request *req;  
  47.     while((req = elv_next_request(q)) != NULL)    
  48.     {  
  49.         if(!blk_fs_request(req))  
  50.         {  
  51.             end_request(req, 0);  
  52.             continue;  
  53.         }  
  54.           
  55.         blk_transfer(req->sector, req->current_nr_sectors, req->buffer, rq_data_dir(req));  
  56.         /*rq_data_dir从request获得数据传送的方向*/  
  57.         /*req->current_nr_sectors 在当前段中将完成的扇区数*/  
  58.         /*req->sector 将提交的下一个扇区*/  
  59.         end_request(req, 1);  
  60.     }  
  61. }  
  62.   
  63. /*strcut block_device_operations*/  
  64. static  int blk_ioctl(struct block_device *dev, fmode_t no, unsigned cmd, unsigned long arg)  
  65. {  
  66.        return -ENOTTY;  
  67. }  
  68.   
  69. static int blk_open (struct block_device *dev , fmode_t no)  
  70. {  
  71.     printk("blk mount succeedn");  
  72.     return 0;  
  73. }  
  74. static int blk_release(struct gendisk *gd , fmode_t no)  
  75. {  
  76.     printk("blk umount succeedn");  
  77.     return 0;  
  78. }  
  79. struct block_device_operations blk_ops=  
  80. {  
  81.     .owner = THIS_MODULE,  
  82.     .open = blk_open,  
  83.     .release = blk_release,  
  84.     .ioctl = blk_ioctl,  
  85. };  
  86.   
  87. //-----------------------------------------------  
  88.   
  89. static int __init block_module_init(void)  
  90. {  
  91.       
  92.       
  93.     if(!register_blkdev(BLK_MAJOR, blk_dev_name)) //注册一个块设备  
  94.     {  
  95.         major = BLK_MAJOR;    
  96.         printk("regiser blk dev succeedn");  
  97.     }  
  98.     else  
  99.     {  
  100.         return -EBUSY;  
  101.     }  
  102.     gd = alloc_disk(1);  //分配一个gendisk,分区是一个  
  103.     spin_lock_init(&lock); //初始化一个自旋锁  
  104.     gd->major = major;  
  105.     gd->first_minor = 0;   //第一个次设备号  
  106.     gd->fops = &blk_ops;   //关联操作函数  
  107.   
  108.     gd->queue = blk_init_queue(blk_request_func, &lock); //初始化请求队列并关联到gendisk  
  109.   
  110.     snprintf(gd->disk_name, 32, "blk%c", 'a');    
  111.     blk_queue_hardsect_size(gd->queue, 512);  //设置扇区大小512字节  
  112.     set_capacity(gd, 32);  //设置块设备大小 512*32=16K  
  113.     add_disk(gd);  
  114.     printk("gendisk init success!n");  
  115.     return 0;  
  116. }  
  117. static void __exit block_module_exit(void)  
  118. {  
  119.     blk_cleanup_queue(gd->queue);  
  120.     del_gendisk(gd);   
  121.     unregister_blkdev(BLK_MAJOR, blk_dev_name);  
  122.     printk("block module exit succeed!n");  
  123. }  
  124.   
  125. module_init(block_module_init);  
  126. module_exit(block_module_exit);  
  127.   
  128. MODULE_LICENSE("GPL");  
  129. MODULE_AUTHOR("gec");  
  130. //------------------------------------------------------------------------------    

2.快速体验

前面, 我们已经讨论了内核所作的在队列中优化请求顺序的工作; 这个工作包括排列请求和, 或许, 甚至延迟队列来允许一个预期的请求到达. 这些技术在处理一个真正的旋转的磁盘驱动器时有助于系统的性能. 但是, 许多面向块的设备, 例如闪存阵列, 用于数字相机的存储卡的读取器、u盘等, 并且 RAM 盘真正地有随机存取的性能, 包含从高级的请求队列逻辑中获益. 其他设备, 例如软件 RAID 阵列或者被逻辑卷管理者创建的虚拟磁盘, 没有这个块层的请求队列被优化的性能特征. 对于这类设备, 它最好直接从块层接收请求, 并且根本不去烦请求队列.

  1. insmod simple-blk.ko

  2. ls /dev/simp_blkdev0

  3. mkfs.ext3 /dev/simp_blk0
  4. mkdir –p /mnt/blk
  5. mount /dev/simp_blk0 /mnt/blk
  6. cp /etc/init.d/* /mnt/blk
  7. ls /mnt/blk
  8. umount /mnt/blk
  9. ls /mnt/blk

这时候我们就不用内核提供的IO调度器来优化排列和合并请求,不用内核的__make_request 帮我们处理bio,而是我们自己处理bio

3.块设备驱动系统架构 
图片 1
VFS是对各种具体文件系统的一种封装 ,为用户程序访问文件提供统一的接口。

数据流程

当我们初始化一个请求队列

[cpp] view plain copy

 

 print?

  1. struct request_queue *blk_init_queue(request_fn_proc *rfn, spinlock_t *lock)  
  2. {  
  3.     return blk_init_queue_node(rfn, lock, -1);  
  4. }  

把请求队列和这个内核已经实现好的函数绑定起来,__make_request就是负责制造请求request 的

[cpp] view plain copy

 

 print?

  1. blk_init_queue_node(request_fn_proc *rfn, spinlock_t *lock, int node_id)  
  2. {  
  3.     struct request_queue *q = blk_alloc_queue_node(GFP_KERNEL, node_id);  
  4.     ......  
  5.     blk_queue_make_request(q, __make_request);  
  6.     ......  
  7. }  

 

[cpp] view plain copy

 

 print?

  1. static int __make_request(struct request_queue *q, struct bio *bio)  

这个bio就是最基本的读写不同扇区的请求,经过__make_request处理后,经过优化返回request

但是,在这里已经不需要了,我们要直接处理bio,来一个处理一个。

分配“请求队列” request_queue_t *blk_alloc_queue(int gfp_mask);
对于FLASH、RAM盘等完全随机访问的非机械设备,并不需要进行复杂的I/O调度,这个时候,应该使用上述函数分配1个“请求队列”,并使用如下函数来绑定“请求队列”和“制造请求”函数。
void blk_queue_make_request(request_queue_t * q, make_request_fn * mfn);

void blk_queue_hardsect_size(request_queue_t *queue, unsigned short max); 
该函数用于告知内核块设备硬件扇区的大小,所有由内核产生的请求都是这个大小的倍数并且被正确对界。但是,内核块设备层和驱动之间的通信还是以512字节扇区为单位进行。

绑定请求队列和“制造请求”函数

void blk_queue_make_request(struct request_queue *q, make_request_fn *mfn)

一个"制造请求"函数来处理bio, make_request 函数有这个原型:

[cpp] view plain copy

 

 print?

  1. typedef int (make_request_fn) (request_queue_t *q, struct bio *bio);   

参考代码:

[cpp] view plain copy

 

 print?

  1. #include <linux/init.h>  
  2. #include <linux/module.h>  
  3. #include <linux/kernel.h>  
  4. #include <linux/fs.h>  
  5. #include <linux/errno.h>  
  6. #include <linux/types.h>  
  7. #include <linux/fcntl.h>  
  8. #include <linux/vmalloc.h>  
  9. #include <linux/hdreg.h>  
  10. #include <linux/blkdev.h>  
  11. #include <linux/blkpg.h>  
  12. #include <asm/uaccess.h>  
  13.   
  14. #define BLK_NAME "ram_blk"  
  15. #define BLK_MAJOR 222  
  16. #define DISK_SECTOR_SIZE 512 //每扇区大小  
  17. #define DISK_SECTOR 1024  //总扇区数,  
  18. #define DISK_SIZE (DISK_SECTOR_SIZE*DISK_SECTOR)//总大小,共0.5M  
  19.   
  20. typedef struct//设备结构体  
  21. {  
  22.        unsigned char          *data;  
  23.        struct request_queue   *queue;  
  24.        struct gendisk         *gd;  
  25. } disk_dev;  
  26.   
  27. disk_dev device;//定义设备结构体  
  28.   
  29. //--------------------------------------------------------------------------  
  30. //在硬盘等带柱面扇区等的设备上使用request,可以整理队列。但是ramdisk等可以  
  31. //使用make_request  
  32. static int disk_make_request(struct request_queue *q,struct bio *bio)  
  33. {  
  34.        int i;  
  35.        char *mem_pbuf;  
  36.        char *disk_pbuf;  
  37.        disk_dev *pdevice;  
  38.        struct bio_vec *pbvec;  
  39.        /*在遍历段之前先判断要传输数据的总长度大小是否超过范围*/  
  40.        i=bio->bi_sector*DISK_SECTOR_SIZE+bio->bi_size;  
  41.        if(i>DISK_SIZE)//判断是否超出范围  
  42.               goto fail;  
  43.          
  44.        pdevice=(disk_dev*)bio->bi_bdev->bd_disk->private_data;//得到设备结构体  
  45.        disk_pbuf=pdevice->data+bio->bi_sector*DISK_SECTOR_SIZE;//得到要读写的起始位置  
  46.          
  47.        /*开始遍历这个bio中的每个bio_vec*/  
  48.        bio_for_each_segment(pbvec,bio,i)//循环分散的内存segment  
  49.        {  
  50.               mem_pbuf=kmap(pbvec->bv_page)+pbvec->bv_offset;//获得实际内存地址  
  51.               switch(bio_data_dir(bio))  
  52.               {//读写  
  53.                      case READA:  
  54.                      case READ:  
  55.                             memcpy(mem_pbuf,disk_pbuf,pbvec->bv_len);  
  56.                             break;  
  57.                      case WRITE:  
  58.                             memcpy(disk_pbuf,mem_pbuf,pbvec->bv_len);  
  59.                             break;  
  60.                      default:  
  61.                             kunmap(pbvec->bv_page);  
  62.                             goto fail;  
  63.               }  
  64.               kunmap(pbvec->bv_page);//清除映射  
  65.               disk_pbuf+=pbvec->bv_len;  
  66.        }  
  67.        bio_endio(bio,0);//这个函数2.6.25和2.6.4是不一样的,  
  68.        return 0;  
  69. fail:  
  70.        bio_io_error(bio);//这个函数2.6.25和2.6.4是不一样的,  
  71.        return 0;  
  72. }  
  73.   
  74. int blk_open(struct block_device *dev, fmode_t no)   
  75. {  
  76.        return 0;  
  77. }  
  78.   
  79. int blk_release(struct gendisk *gd, fmode_t no)  
  80. {  
  81.        return 0;  
  82. }  
  83.   
  84. int blk_ioctl(struct block_device *dev, fmode_t no, unsigned cmd, unsigned long arg)  
  85. {  
  86.        return -ENOTTY;  
  87. }  
  88.   
  89. static struct block_device_operations blk_fops=  
  90. {  
  91.        .owner=THIS_MODULE,  
  92.        .open=blk_open,//  
  93.        .release=blk_release,//  
  94.        .ioctl=blk_ioctl,//   
  95. };  
  96.   
  97. int disk_init(void)  
  98. {  
  99.         if(!register_blkdev(BLK_MAJOR,BLK_NAME));//注册驱动  
  100.     {  
  101.          printk("register blk_dev succeedn");  
  102.     }  
  103.       
  104.        device.data=vmalloc(DISK_SIZE);  
  105.        device.queue=blk_alloc_queue(GFP_KERNEL);//生成队列  
  106.        blk_queue_make_request(device.queue,disk_make_request);/*注册make_request  绑定请求制造函数*/  
  107.   
  108.     printk("make_request succeedn");  
  109.   
  110.        device.gd=alloc_disk(1);//生成gendisk  
  111.        device.gd->major=BLK_MAJOR;//主设备号  
  112.        device.gd->first_minor=0;//此设备号  
  113.        device.gd->fops=&blk_fops;//块文件结构体变量  
  114.        device.gd->queue=device.queue;//请求队列  
  115.        device.gd->private_data=&device;  
  116.        sprintf(device.gd->disk_name,"disk%c",'a');//名字  
  117.        set_capacity(device.gd,DISK_SECTOR);//设置大小  
  118.        add_disk(device.gd);//注册块设备信息  
  119.     printk("gendisk succeedn");      
  120.        return 0;  
  121. }  
  122.   
  123. void disk_exit(void)  
  124. {  
  125.       
  126.        del_gendisk(device.gd);  
  127.        put_disk(device.gd);  
  128.        unregister_blkdev(BLK_MAJOR,BLK_NAME);  
  129.        vfree(device.data);  
  130.         printk("free succeedn");  
  131.       
  132. }  
  133.   
  134. module_init(disk_init);  
  135. module_exit(disk_exit);  
  136.   
  137. MODULE_LICENSE("Dual BSD/GPL");     

4.系统架构-Cache

当用户发起文件访问请求的时候,首先会到Disk Cache中寻找文件是否被缓存了,如果在cache中,则直接从cache中读取。

如果数据不在缓存中,就必须要到具体的文件系统中读取数据了。

本文由必赢网址发布于机械设备,转载请注明出处:Linux设备驱动,自造请求

您可能还会对下面的文章感兴趣: