嵌入式Linux之我行——RamDisk块设备驱动实例开发讲解[转]

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;
.
.
.
};

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; /*偏移位置*/
};

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;          /*私有数据*/
.
.
.
};

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;
}

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/errno.h>
#include <linux/blkdev.h>
#include <linux/bio.h>

#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");

/*绑定请求制造函数。注意：第一个参数仍然是请求队列，但在这里实际不包含任何请求。
所以这里要处理的重点对象的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;
}