zoukankan      html  css  js  c++  java

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

    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就坑爹了，第一次遇到找了好久

    无欲速，无见小利。欲速，则不达；见小利，则大事不成。
  • 相关阅读:
    每日英语：AntiJapan Protests Flare in China
    opencv CvMat矩阵学习
    warning C4018有符号无符号不匹配
    每日英语：Relationship Repair: 10 Tips for Thinking Like a Therapist
    结构体数组定义和引用
    每日英语：China's Conflicted Consumers
    一个托盘程序, 简化notifyicon的使用.
    nunit notes from TDD in .net
    一款能拖拉的winform树形控件
    vss 2005 internet visit
  • 原文地址：https://www.cnblogs.com/ch122633/p/7363297.html
Copyright © 2011-2022 走看看