块设备驱动系统架构和简单设计

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

2.快速体验
  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

3.块设备驱动系统架构 

VFS是对各种具体文件系统的一种封装 ，为用户程序访问文件提供统一的接口。
4.系统架构-Cache
当用户发起文件访问请求的时候，首先会到Disk Cache中寻找文件是否被缓存了，如果在cache中，则直接从cache中读取。
如果数据不在缓存中，就必须要到具体的文件系统中读取数据了。

5.Mapping Layer（映射层、FS文件系统）
1. 首先确定文件系统的block size,然后计算所请求的数据包含多少个block。
2. 调用具体文件系统的函数来访问文件的inode结构，确定所请求的数据在磁盘上的地址。
6. Generic Block Layer
Linux内核把把块设备看作是由若干个扇区组成的数据空间。上层的读写请求在通用块层被构造成一个或多个bio结构。
7. I/O Scheduler Layer
I/O调度层负责采用某种算法(如：电梯调度算法)将I/O操作进行排序。

8. I/O Scheduler Layer
电梯调度算法的基本原则：如果电梯现在朝上运动，如果当前楼层的上方和下方都有请求，则先响应所有上方的请求，然后才向下响应下方的请求；如果电梯向下运动，则刚好相反。

9.块设备驱动
在块系统架构的最底层，由块设备驱动根据排序好的请求，对硬件进行数据访问。

10.块设备驱动实例分析

  1. #include <linux/module.h>
  2. #include <linux/moduleparam.h>
  3. #include <linux/init.h>

  5. #include <linux/sched.h>
  6. #include <linux/kernel.h> /* printk() */
  7. #include <linux/slab.h> /* kmalloc() */
  8. #include <linux/fs.h> /* everything... */
  9. #include <linux/errno.h> /* error codes */
  10. #include <linux/timer.h>
  11. #include <linux/types.h> /* size_t */
  12. #include <linux/fcntl.h> /* O_ACCMODE */
  13. #include <linux/hdreg.h> /* HDIO_GETGEO */
  14. #include <linux/kdev_t.h>
  15. #include <linux/vmalloc.h>
  16. #include <linux/genhd.h>
  17. #include <linux/blkdev.h>
  18. #include <linux/buffer_head.h> /* invalidate_bdev */
  19. #include <linux/bio.h>

  21. MODULE_LICENSE("Dual BSD/GPL");

  23. static int major = 0;

  25. static int sect_size = 512;

  27. static int nsectors = 1024;

  29. /*
  30. * The internal representation of our device.
  31. */
  32. struct blk_dev{
  33.          int size; /* Device size in sectors */
  34.          u8 *data; /* The data array */
  35.          struct request_queue *queue; /* The device request queue */
  36.          struct gendisk *gd; /* The gendisk structure */
  37. };

  39. struct blk_dev *dev;


  42. /*
  43. * Handle an I/O request, in sectors.
  44. */
  45. static void blk_transfer(struct blk_dev *dev, unsigned long sector,
  46.    unsigned long nsect, char *buffer, int write)                                                                                    //扇区访问函数
  47. {
  48. unsigned long offset = sector*sect_size;
  49. unsigned long nbytes = nsect*sect_size;

  51. if ((offset + nbytes) > dev->size) {
  52.    printk (KERN_NOTICE "Beyond-end write (%ld %ld) ", offset, nbytes);
  53.    return;
  54. }
  55. if (write)
  56.    memcpy(dev->data + offset, buffer, nbytes);                                                                                       //对内存读写
  57. else
  58.    memcpy(buffer, dev->data + offset, nbytes);
  59. }

  61. /*
  62. * The simple form of the request function.
  63. */
  64. static void blk_request(struct request_queue *q)                                                                                      //实现读写请求处理函数
  65. {
  66. struct request *req;

  68. req = blk_fetch_request(q);                                                                                                           //从队列中取出一个请求
  69. while (req != NULL) {
  70.    struct blk_dev *dev = req->rq_disk->private_data;

  72.    blk_transfer(dev, blk_rq_pos(req), blk_rq_cur_sectors(req), req->buffer, rq_data_dir(req));
  73.    
  74.    if(!__blk_end_request_cur(req, 0))                                                                                                 //判断请求队列是否为空
  75.    {
  76.     req = blk_fetch_request(q);                                                                                                       //嵌套处理
  77.    }
  78. }
  79. }

  81. /*
  82. * The device operations structure.
  83. */
  84. static struct block_device_operations blk_ops = {
  85. .owner = THIS_MODULE,
  86. };


  89. /*
  90. * Set up our internal device.
  91. */
  92. static void setup_device()
  93. {
  94. /*
  95. * Get some memory.
  96. */
  97. dev->size = nsectors*sect_size;                                                                                  //获取设备大小
  98. dev->data = vmalloc(dev->size);                                                                                  //获取数据指针
  99. if (dev->data == NULL) {
  100.    printk (KERN_NOTICE "vmalloc failure. ");
  101.    return;
  102. }

  104.    dev->queue = blk_init_queue(blk_request, NULL);                                                               //请求队列初始化，blk_request是处理上层传下来的请求的
  105.    if (dev->queue == NULL)
  106.     goto out_vfree;

  108. blk_queue_logical_block_size(dev->queue, sect_size);                                                             //指明扇区大小
  109. dev->queue->queuedata = dev;
  110. /*
  111. * And the gendisk structure.
  112. */
  113. dev->gd = alloc_disk(1);                                                                                         //为块设备分配gendisk结构，并初始化
  114. if (! dev->gd) {
  115.    printk (KERN_NOTICE "alloc_disk failure ");
  116.    goto out_vfree;
  117. }
  118. dev->gd->major = major;
  119. dev->gd->first_minor = 0;
  120. dev->gd->fops = &blk_ops;
  121. dev->gd->queue = dev->queue;
  122. dev->gd->private_data = dev;
  123. sprintf (dev->gd->disk_name, "simp_blk%d", 0);
  124. set_capacity(dev->gd, nsectors*(sect_size/sect_size));
  125. add_disk(dev->gd);                                                                                               //注册块设备
  126. return;

  128. out_vfree:
  129. if (dev->data)
  130.    vfree(dev->data);
  131. }

  133. static int __init blk_init(void)
  134. {
  135. /*
  136. * Get registered.
  137. */
  138. major = register_blkdev(major, "blk");                                                                  //注册块设备驱动，major若为0会自动分配
  139. if (major <= 0) {
  140.    printk(KERN_WARNING "blk: unable to get major number ");
  141.    return -EBUSY;
  142. }

  144. dev = kmalloc(sizeof(struct blk_dev), GFP_KERNEL);                                                      //分配一个blk_dev空间
  145. if (dev == NULL)
  146.    goto out_unregister;

  148.    setup_device();                                                                                      //调用函数
  149.      
  150. return 0;

  152. out_unregister:
  153. unregister_blkdev(major, "sbd");
  154. return -ENOMEM;
  155. }

  157. static void blk_exit(void)
  158. {

  160.    if (dev->gd) {
  161.     del_gendisk(dev->gd);
  162.     put_disk(dev->gd);
  163.    }
  164.    if (dev->queue)
  165.     blk_cleanup_queue(dev->queue);
  166.    if (dev->data)
  167.     vfree(dev->data);

  169.    unregister_blkdev(major, "blk");
  170. kfree(dev);
  171. }

  173. module_init(blk_init);
  174. module_exit(blk_exit);


11、简单块设备驱动设计

  1. #include <linux/module.h>
  2. #include <linux/init.h>
  3. #include <linux/errno.h>
  4. #include <linux/blkdev.h>
  5. #include <linux/bio.h>
  6. #include <linux/string.h>
  7. #include <asm/uaccess.h>
  8. #include <linux/kernel.h>
  9. #include <linux/types.h>
  10. #include <linux/genhd.h>

  12. MODULE_LICENSE("GPL");

  14. static int major = 0;

  16. static int sect_size = 512;
  17. static int nsectors = 1024;

  19. struct blk_dev {
  20.     int size;
  21.     u8 *data;
  22.     struct request_queue *queue;
  23.     struct gendisk *gd;
  24. };

  26. struct blk_dev *dev;

  28. static void blk_transfer(struct blk_dev *dev, unsigned long sector, unsigned long nsect,char *buffer, int write)
  29. {
  30.     unsigned long offset = sector * sect_size;
  31.     unsigned long nbyte = nsect * sect_size;
  32.     
  33.     if((offset + nbyte) > dev->size)
  34.     {
  35.         printk(KERN_NOTICE"Beyond-end write (%ld %ld) ", offset, nbyte);
  36.     return;
  37.     }

  39.     if(write)
  40.     {
  41.         memcpy(dev->data + offset, buffer, nbyte);
  42.     }
  43.     else
  44.     {
  45.         memcpy(buffer, dev->data + offset, nbyte);
  46.     }
  47. }

  49. void blk_request(struct request_queue *q)
  50. {
  51.     struct request *req;
  52.     req = blk_fetch_request(q);

  54.     while(req != NULL)
  55.     {
  56.         struct blk_dev *dev = req->rq_disk->private_data;
  57.         //处理该请求
  58.     blk_transfer(dev, blk_rq_pos(req), blk_rq_cur_sectors(req), req->buffer, rq_data_dir(req));
  59.     
  60.     if(!__blk_end_request_cur(req, 0))
  61.      req = blk_fetch_request(q);
  62.     }

  64. }

  66. static struct block_device_operations blk_ops = {
  67.     .owner = THIS_MODULE,
  68. };

  70. static void setup_device(void)
  71. {
  72.     dev->size = nsectors * sect_size;
  73.     dev->data = vmalloc(dev->size);
  74.     if(dev->data == NULL) {
  75.         printk(KERN_NOTICE "vmalloc failure. ");
  76.     return;
  77.     }
  78.     
  79.     dev->queue = blk_init_queue(blk_request, NULL);
  80.     if(dev->queue == NULL)
  81.     {
  82.         goto out_vfree;
  83.     }
  84.     
  85.     blk_queue_logical_block_size(dev->queue, sect_size);
  86.     dev->queue->queuedata = dev;

  88.     dev->gd = alloc_disk(1);
  89.     if(!dev->gd)
  90.     {
  91.         printk(KERN_NOTICE "alloc_disk failure ");
  92.     goto out_vfree;
  93.     }

  95.     dev->gd->major = major;
  96.     dev->gd->first_minor = 0;
  97.     dev->gd->fops = &blk_ops;
  98.     dev->gd->queue = dev->queue;
  99.     dev->gd->private_data = dev;
  100.     sprintf(dev->gd->disk_name, "simp_blk%d", 0);

  102.     set_capacity(dev->gd, nsectors);
  103.     add_disk(dev->gd);
  104.     return;

  106. out_vfree:
  107.     if(dev->data)
  108.         vfree(dev->data);
  109. }

  111. static int __init blk_init(void)
  112. {
  113.     major = register_blkdev(0, "blk");
  114.     if(major <= 0)
  115.     {
  116.         printk(KERN_WARNING "register blk dev fail! ");
  117.     return -EBUSY;
  118.     }

  120.     dev = kmalloc(sizeof(struct blk_dev), GFP_KERNEL);
  121.     if(dev == NULL)
  122.         goto out_unregister;

  124.     setup_device();

  126.     return 0;
  127. out_unregister:
  128.     unregister_blkdev(major, "sbd");
  129.     return -ENOMEM;
  130. }

  132. static void blk_exit(void)
  133. {
  134.     del_gendisk(dev->gd);
  135.     blk_cleanup_queue(dev->queue);
  136.     vfree(dev->data);
  137.     unregister_blkdev(major, "blk");
  138.     kfree(dev);
  139. }

  141. module_init(blk_init);
  142. module_exit(blk_exit);

错误总结：一开始写的时候，编译完加载进内核。直接死机，因为代码有点长。就从逻辑处一点一点注释掉来分析，果然有好多错误。
第一次遇到的问题，内核中常用goto跳转处理错误情况。如果跳转处前面没有return就坑爹了，第一次遇到找了好久

无欲速，无见小利。欲速，则不达；见小利，则大事不成。
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/ch122633/p/7363297.html