具体介绍RamDisk块的设备驱动

一、开发环境

主  机：VMWare–Fedora 9

开发板：Mini2440–64MB Nand, Kernel:2.6.30.4

编译器：arm–linux-gcc-4.3.2

二、块设备基本概念

扇区(Sectors)：任何块设备硬件对数据处理的基本单位。一般，1个扇区的巨细为512byte。

块(Blocks)：由Linux拟定对内核或文件体系等数据处理的基本单位。一般，1个块由1个或多个扇区组成。

段(Segments)：由若干个相邻的块组成。是Linux内存办理机制中一个内存页或许内存页的一部分。

页、段、块、扇区之间的联系图如下：

综合上描绘：块设备驱动是根据扇区(sector)来拜访底层物理磁盘，根据块(block)来拜访上层文件体系。扇区一般是2的n次方巨细，典型为512B，内核也要求块是2的n次方巨细，且块巨细一般为扇区巨细的整数倍，而且块巨细要小于页面巨细，典型巨细为512B、1K或4K。 

三、块设备在Linux中的结构

首要咱们来看一下，块设备在整个Linux中运用的全体结构，如图：

块设备驱动层(Block Device Driver)在全体结构中扮演的人物。

  从上图能够看出，块设备的运用在Linux中是一个完好的子体系。

  首要，咱们先看一下，块设备驱动是以何种方法对块设备进行拜访的。在Linux中，驱动对块设备的输入或输出(I/O)操作，都会向块设备宣布一个恳求，在驱动顶用request结构体描绘。但关于一些磁盘设备而言恳求的速度很慢，这时候内核就供给一种行列的机制把这些I/O恳求增加到行列中(即：恳求行列)，在驱动顶用request_queue结构体描绘。在向块设备提交这些恳求前内核会先履行恳求的兼并和排序预操作，以进步拜访的功率，然后再由内核中的I/O调度程序子体系(即：上图中的I/O调度层)来担任提交I/O恳求，I/O调度程序将磁盘资源分配给体系中一切挂起的块I/O恳求，其作业是办理块设备的恳求行列，决议行列中的恳求的摆放次序以及什么时候派发恳求到设备，关于更多详细的I/O调度常识这儿就不深加研讨了。

  其次，块设备驱动又是怎样保持一个I/O恳求在上层文件体系与底层物理磁盘之间的联系呢？这便是上图中通用块层(Generic Block Layer)要做的工作了。在通用块层中，一般用一个bio结构体来对应一个I/O恳求，它代表了正在活动的以段(Segment)链表方法安排的块IO操作，关于它所需求的一切段又用bio_vec结构体表明。

  再次，块设备驱动又是怎样对底层物理磁盘进行反诘的呢？上面讲的都是对上层的拜访对上层的联系。Linux供给了一个gendisk数据结构体，用他来表明一个独立的磁盘设备或分区。在gendisk中有一个相似字符设备中file_operations的硬件操作结构指针，他便是block_device_operaTIons结构体，他的效果信任咱们现已很清楚了。
 

详细描绘上面中讲到的保持各层联系的数据结构体(这儿只列出了较常用的一些成员)

request与request_queue结构体，界说在/include/linux/blkdev.h中：

struct request
{
    struct list_head queuelist;     /*链表结构*/
    struct request_queue *q;        /*恳求行列*/
    sector_t sector;                /*要传送的下一个扇区*/
    sector_t hard_sector;           /*要完结的下一个扇区*/
    unsigned long nr_sectors;       /*要传送的扇区数目*/
    unsigned long hard_nr_sectors;  /*要完结的扇区数目*/
    unsigned int current_nr_sectors;/*当时要传送的扇区数目*/
    unsigned int hard_cur_sectors;  /*当时要完结的扇区数目*/
    struct bio *bio;                /*恳求的bio结构体的链表*/
    struct bio *biotail;            /*恳求的bio结构体的链表尾*/
    void *elevator_private;
    void *elevator_private2;
    struct gendisk *rq_disk;
    unsigned long start_TIme;
    unsigned short nr_phys_segments;/*恳求在物理内存中占有不接连段的数目*/
    unsigned short ioprio;
    char *buffer;                   /*传送的缓冲区*/
    int tag;
    int errors;
    int ref_count;                  /*引证计数*/
    .
    .
    .
};

struct request_queue
{
    .
    .
    .
    struct list_head queue_head;
    unsigned long nr_requests;       /*最大的恳求数目*/
    unsigned int nr_congesTIon_on;
    unsigned int nr_congesTIon_off;
    unsigned int nr_batching;
    unsigned int max_sectors;        /*最大的扇区数目*/
    unsigned int max_hw_sectors;
    unsigned short max_phys_segments;/*最大的段数目*/
    unsigned short max_hw_segments;
    unsigned short hardsect_size;    /*扇区尺度巨细*/
    unsigned int max_segment_size;   /*最大的段尺度巨细*/
    unsigned long seg_boundary_mask; /*段鸿沟掩码*/
    void *dma_drain_buffer;
    unsigned int dma_drain_size;
    unsigned int dma_pad_mask;
    unsigned int dma_alignment;      /*DMA传输内存对齐*/
    struct blk_queue_tag *queue_tags;
    struct list_head tag_busy_list;
    unsigned int nr_sorted;
    unsigned int in_flight;
    unsigned int rq_timeout;
    struct timer_list timeout;
    struct list_head timeout_list;
    .
    .
    .
};

bio与bio_vec结构体，界说在/include/linux/bio.h中：

struct bio
{
    sector_t bi_sector;            /*要传送的第一个扇区*/
    struct bio *bi_next;           /*下一个bio*/
    struct block_device *bi_bdev;
    unsigned long bi_flags;        /*状况、指令等*/
    unsigned long bi_rw;           /*低位表明READ/WRITE，高位表明优先级*/
    unsigned short bi_vcnt;        /*bio_vec的数量*/
    unsigned short bi_idx;         /*当时bvl_vec的索引*/
    unsigned int bi_phys_segments; /*不相邻物理段的数目*/
    unsigned int bi_size;          /*以字节为单位所需传送的数据巨细*/
    unsigned int bi_seg_front_size;/*为了清晰硬件尺度，需求考虑bio中第一个和最终一个虚拟的可兼并段的尺度巨细*/
    unsigned int bi_seg_back_size;
    unsigned int bi_max_vecs;      /*支撑最大bvl_vecs的数量*/
    struct bio_vec *bi_io_vec;     /*vec列表*/
    .
    .
    .
};

struct bio_vec
{
    struct page *bv_page;   /*页指针*/
    unsigned int bv_len;    /*传输的字节数*/
    unsigned int bv_offset; /*偏移方位*/
};

上面的这些结构体都是对上层的支撑，那么对硬件底层的支撑比较重要的结构体是gendisk，界说在/include/linux/genhd.h中：

struct gendisk
{
    int major;            /*主设备号*/
    int first_minor;      /*第一个次设备号*/
    int minors;           /*最大的次设备号，假如不能分区则为1*/
    char disk_name[DISK_NAME_LEN];  /*设备称号*/
    struct disk_part_tbl *part_tbl; /*磁盘上的分区表信息*/
    struct hd_struct part0;
    struct block_device_operations *fops;/*块设备对底层硬件的操作结构体指针*/
    struct request_queue *queue; /*恳求行列*/
    void *private_data;          /*私有数据*/
    .
    .
    .
};

那么这些结构体之间的联系图如下：

块设备驱动的I/O恳求处理的两种方法:

块设备驱动的I/O恳求处理有两种方法，分别是运用恳求行列和不运用恳求行列。那么这两种方法有什么不同呢？在第2点中已讲到运用恳求行列有助于进步体系的功能，但关于一些彻底可随机拜访的块设备(如：Ram盘等)运用恳求行列并不能取得多大的好处，这时候，通用块层供给了一种无行列的操作形式，运用这种形式，驱动有必要供给一个制作恳求函数。咱们仍是用代码来差异它们吧。

运用恳求行列：

static int __int ramdisk_init(void)
{
    /*块设备驱动注册*/
    register_blkdev(RAMDISK_MAJOR, RAMDISK_NAME);

    /*运用恳求行列的方法*/
    ramdisk_queue = blk_init_queue(ramdisk_do_request, NULL);

    /*分配gendisk*/

………
    /*初始化gendisk*/

………
    /*增加gendisk到体系中*/

………
}

/*恳求处理函数，恳求行列的处理流程如下：
 *首要：从恳求行列中拿出一条恳求
 *其次：判别这一条恳求的方向，是向设备写仍是读，然后将数据装入缓冲区
 *最终：告知恳求完结*/
static void ramdisk_do_request(struct request_queue_t *queue)
{
    struct request *req;

    /*运用循环一条恳求一条恳求的来处理，elv_next_request函数是遍历行列中的每一条恳求*/
    while(req = elv_next_request(queue) != NULL)
    {
        /*判别要传输数据的总长度巨细是否超越规模*/
        if ((req->sector + req->current_nr_sectors) << 9 > RAMDISK_SIZE)
        {
            /*假如超越规模就直接陈述恳求失利*/
            end_request(req, 0);
            continue;
        }

        /*判别恳求处理的方向*/
        switch (rq_data_dir(req))
        {
            case READ:
                memcpy(req->buffer, disk_data + (req->sector << 9), req->current_nr_sectors << 9);
                end_request(req, 1);/*陈述恳求处理成功*/
                break;

            case WRITE:
                memcpy(disk_data + (req->sector << 9), req->buffer, req->current_nr_sectors << 9);
                end_request(req, 1);/*陈述恳求处理成功*/
                break;

            default:
                break;
        }
    }
}

不运用恳求行列，制作恳求函数：

static int __int ramdisk_init(void)
{
    /*块设备驱动注册*/
    ramdisk_major = register_blkdev(RAMDISK_MAJOR, RAMDISK_NAME);

    /*运用制作恳求的方法,先分配ramdisk_queue*/
    ramdisk_queue = blk_alloc_queue(GFP_KERNEL);

    /*再绑定恳求制作函数*/
    blk_queue_make_request(ramdisk_queue, &ramdisk_make_request);

    /*分配gendisk*/
    ………

    /*初始化gendisk*/
    ………

    /*增加gendisk到体系中*/
    ………
}

/*绑定恳求制作函数。留意：第一个参数仍然是恳求行列，但在这儿实践不包括任何恳求。
所以这儿要处理的重点对象的bio中的每个bio_vec，他表明一个或多个要传送的缓冲区。*/
static int ramdisk_make_request(struct request_queue_t *queue, struct bio *bio)
{
    int i;
    struct bio_vec *bvec;
    void *disk_mem;
    void *bvec_mem;

    /*在遍历段之前先判别要传输数据的总长度巨细是否超越规模*/
    if((bio->bi_sector << 9) + bio->bi_size > RAMDISK_SIZE)
    {
        /*假如超出规模就告知这个bio处理失利*/
        bio_endio(bio, 0, -EIO);

        return 0;
    }

    /*取得这个bio恳求在块设备内存中的开端方位*/
    disk_mem = disk_data + (bio->bi_sector << 9);     /*开端遍历这个bio中的每个bio_vec*/
    bio_for_each_segment(bvec, bio, i)
    {
        /*因bio_vec中的内存地址是运用page *描绘的，故在高端内存中需求用kmap进行映射后才干拜访，
        再加上在bio_vec中的偏移方位，才是在高端物理内存中的实践方位*/
        bvec_mem = kmap(bvec->bv_page) + bvec->bv_offset;

        /*判别bio恳求处理的方向*/
        switch(bio_data_dir(bio))
        {
            case READ:
            case READA:
                memcpy(bvec_mem, disk_mem, bvec-> bv_len);
                break;

            case WRITE :
                memcpy(disk_mem, bvec_mem, bvec-> bv_len);
                break;

            default :
                kunmap(bvec->bv_page);
        }

        /*处理完每一个bio_vec都应把kmap映射的地址取消掉*/
        kunmap(bvec->bv_page);

        /*累加当时bio_vec中的内存长度，以确认下一个bio_vec在块设备内存中的方位*/
        disk_mem += bvec->bv_len;
    }

    /*bio中一切的bio_vec处理完后陈述处理完毕*/
    bio_endio(bio, bio->bi_size, 0);

    return 0;
}

四、块设备驱动(RamDisk)完成过程详解

其实从上面的结构体联系图就能够看出这便是块设备驱动程序的全体的结构了，当然这仅仅较简略的块设备驱动了，现在咱们就行将要做的便是完成一个简略的RamDisk块设备驱动了。其实告知咱们我这儿为什么只完成一个简略的块设备驱动，由于我是要为今后的MMC/SD卡驱动、Nand flash驱动等做一些条件预备的。好了，仍是先了解一下什么是RamDisk吧。

RamDisk是将Ram中的一部分内存空间模仿成一个磁盘设备，以块设备的拜访方法来拜访这一片内存，到达数据存取的意图。RamDisk设备在Linux设备文件体系中对应的设备文件节点一般为：/dev/ram%d。

树立驱动代码文件my2440_ramdisk.c，完成驱动模块的加载和卸载，过程如下：

加载部分：分配恳求行列及绑定恳求制作函数 -> 分配及初始化gendisk -> 增加gendisk -> 注册块设备驱动。
卸载部分：铲除恳求行列 -> 删去gendisk -> 刊出块设备驱动。

#include #include #include #include #include #include

#define RAMDISK_MAJOR    0        /*主设备号设置0让内核动态发生一个主设备号*/
#define RAMDISK_NAME    “my2440_ramdisk”    /*设备称号*/
#define RAMDISK_SIZE    (4 * 1024 * 1024)   /*虚拟磁盘的巨细,共4M*/

static int ramdisk_major = RAMDISK_MAJOR;   /*用来保存动态分配的主设备号*/
static struct class *ramdisk_class;         /*界说一个设备类,好在/dev下动态生成设备节点*/

static struct gendisk *my2440_ramdiak;      /*界说一个gendisk结构体用来表明一个磁盘设备*/
static struct request_queue *ramdisk_queue; /*界说磁盘设备的恳求行列*/

unsigned char *disk_data;/*界说一个指针来表明ramdisk块设备在内存中的域*/

/*块设备驱动操作结构体，其实不需求做什么操作，这儿就设置为空*/
static struct block_device_operations ramdisk_fops =
{
    .owner    = THIS_MODULE,
};

static int __init ramdisk_init(void)
{
    int ret;

    /*块设备驱动注册, 留意这个块设备驱动的注册在2.6内核中是可选的，
    该函数由内核供给。这儿运用是为了取得一个动态生成的主设备号*/
    ramdisk_major = register_blkdev(RAMDISK_MAJOR, RAMDISK_NAME);
    if(ramdisk_major <= 0)
    {
        return ramdisk_major;
    }

    /*动态创立一个设备节点，跟字符型设备相同*/
    ramdisk_class = class_create(THIS_MODULE, RAMDISK_NAME);
    if(IS_ERR(ramdisk_class))
    {
        ret = -1;
        goto err_class;
    }
    device_create(ramdisk_class, NULL, MKDEV(ramdisk_major, 0), NULL, RAMDISK_NAME);

    /*RamDisk属真实随机拜访的设备，因而不运用恳求行列的处理方法，而运用制作恳求的方法*/
    ramdisk_queue = blk_alloc_queue(GFP_KERNEL);/*分配ramdisk_queue*/

    if(!ramdisk_queue)
    {
        ret = -ENOMEM;
        goto err_queue;
    }
    blk_queue_make_request(ramdisk_queue, &ramdisk_make_request);/*绑定恳求制作函数*/

    /*分配gendisk，该函数由内核供给，参数为磁盘设备的次设备号数量(或许磁盘的分区数量)
    留意一个分区就代表一个次设备，这儿指定数量后今后就不能被修改了*/
    my2440_ramdiak = alloc_disk(1);

    if(!my2440_ramdiak)
    {
        ret = -ENOMEM;
        goto err_alloc;
    }

    /*初始化gendisk*/
    my2440_ramdiak->major = ramdisk_major;    /*这儿指定的主设备号便是在上面动态获取的主设备号*/
    my2440_ramdiak->first_minor    = 0;       /*指定第一个次设备号为0*/
    my2440_ramdiak->fops = &ramdisk_fops;     /*指定块设备驱动对底层硬件操作的结构体指针，界说在后面来讲*/
    my2440_ramdiak->queue = ramdisk_queue;    /*指定初始化好的恳求行列*/
    sprintf(my2440_ramdiak->disk_name, RAMDISK_NAME);/*指定磁盘设备的称号*/

    /*设置磁盘设备的容量巨细,该函数由内核供给。
    留意该函数是以512字节为1个扇区单位进行处理的，由于内核要求如此*/
    set_capacity(my2440_ramdiak, RAMDISK_SIZE >> 9);/*右移9位便是除以512*/

    /*增加gendisk到体系中, 该函数由内核供给*/
    add_disk(my2440_ramdiak);

    return 0;

/*错误处理*/
err_class:
    unregister_blkdev(ramdisk_major, RAMDISK_NAME);
err_queue:
    device_destroy(ramdisk_class, MKDEV(ramdisk_major, 0));
    class_destroy(ramdisk_class);
err_alloc:
    blk_cleanup_queue(ramdisk_queue);

    return ret;
}

static void __exit ramdisk_exit(void)
{    
    /*删去磁盘设备*/
    del_gendisk(my2440_ramdiak);
    put_disk(my2440_ramdiak);

    /*铲除恳求行列*/
    blk_cleanup_queue(ramdisk_queue);

    /*铲除设备类*/
    device_destroy(ramdisk_class, MKDEV(ramdisk_major, 0));
    class_destroy(ramdisk_class);

    /*刊出块设备*/
    unregister_blkdev(ramdisk_major, RAMDISK_NAME);
}

module_init(ramdisk_init);
module_exit(ramdisk_exit);

MODULE_LICENSE(“GPL”);
MODULE_AUTHOR(“Huang Gang”);
MODULE_DESCRIPTION(“My2440 RamDisk Driver”);

RamDisk属真实随机拜访的设备，因而没有运用恳求行列的处理方法，而是运用制作恳求的方法。制作恳求处理函数完成如下：

/*绑定恳求制作函数。留意：第一个参数仍然是恳求行列，但在这儿实践不包括任何恳求。
所以这儿要处理的重点对象的bio中的每个bio_vec，他表明一个或多个要传送的缓冲区。*/
static int ramdisk_make_request(struct request_queue_t *queue, struct bio *bio)
{
    int i;
    struct bio_vec *bvec;
    void *disk_mem;
    void *bvec_mem;

    /*在遍历段之前先判别要传输数据的总长度巨细是否超越规模*/
    if((bio->bi_sector << 9) + bio->bi_size > RAMDISK_SIZE)
    {
        /*假如超出规模就告知这个bio处理失利*/
        bio_io_error(bio);

        return 0;
    }

    /*取得这个bio恳求在块设备内存中的开端方位*/
    disk_mem = disk_data + (bio->bi_sector << 9);     /*开端遍历这个bio中的每个bio_vec*/
    bio_for_each_segment(bvec, bio, i)
    {
        /*因bio_vec中的内存地址是运用page *描绘的，故在高端内存中需求用kmap进行映射后才干拜访，
        再加上在bio_vec中的偏移方位，才是在高端物理内存中的实践方位*/
        bvec_mem = kmap(bvec->bv_page) + bvec->bv_offset;

        /*判别bio恳求处理的方向*/
        switch(bio_data_dir(bio))
        {
            case READ:
            case READA:
                memcpy(bvec_mem, disk_mem, bvec->bv_len);
                break;

            case WRITE :
                memcpy(disk_mem, bvec_mem, bvec->bv_len);
                break;

            default :
                kunmap(bvec->bv_page);
        }

        /*处理完每一个bio_vec都应把kmap映射的地址取消掉*/
        kunmap(bvec->bv_page);

        /*累加当时bio_vec中的内存长度，以确认下一个bio_vec在块设备内存中的方位*/
        disk_mem += bvec->bv_len;
    }

    /*bio中一切的bio_vec处理完后陈述处理完毕*/
    bio_endio(bio, 0);

    return 0;
}