转：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;

}