LDD3块设备代码分析

整个块设备抽象的数据结构

struct sbull_dev {

        int size;                       /* Device size in sectors */

        u8 *data;                       /* The data array */

        short users;                    /* How many users */

        short media_change;             /* Flag a media change? */

        spinlock_t lock;                /* For mutual exclusion */

        struct request_queue *queue;    /* The device request queue */请求队列

        struct gendisk *gd;             /* The gendisk structure */              /块设备数据结构

        struct timer_list timer;        /* For simulated media changes */

};

//模块初始化函数

static int __init sbull_init(void)

{

int i;

/*

* Get registered.

*/

sbull_major = register_blkdev(sbull_major, "sbull");//自动分配主设备号

if (sbull_major <= 0) {

printk(KERN_WARNING "sbull: unable to get major number/n");

return -EBUSY;

}

/*

* Allocate the device array, and initialize each one.

*/

Devices = kmalloc(ndevices*sizeof (struct sbull_dev), GFP_KERNEL);//分配每个块设备的数据结构

if (Devices == NULL)

goto out_unregister;

for (i = 0; i < ndevices; i++) 

setup_device(Devices + i, i);

 

return 0;

 

  out_unregister:

unregister_blkdev(sbull_major, "sbd");

return -ENOMEM;

}

 

static void setup_device(struct sbull_dev *dev, int which)

{

/*

* Get some memory.

*/

memset (dev, 0, sizeof (struct sbull_dev));

dev->size = nsectors*hardsect_size;

dev->data = vmalloc(dev->size);

if (dev->data == NULL) {

printk (KERN_NOTICE "vmalloc failure./n");

return;

}

spin_lock_init(&dev->lock);

 

/*

* The timer which "invalidates" the device.

*/

init_timer(&dev->timer);

dev->timer.data = (unsigned long) dev;

dev->timer.function = sbull_invalidate;//初始化超时定时器

 

/*

* The I/O queue, depending on whether we are using our own

* make_request function or not.

*/

switch (request_mode) {

   case RM_NOQUEUE:

dev->queue = blk_alloc_queue(GFP_KERNEL);

if (dev->queue == NULL)

goto out_vfree;

blk_queue_make_request(dev->queue, sbull_make_request);

break;

 

   case RM_FULL:

dev->queue = blk_init_queue(sbull_full_request, &dev->lock);

if (dev->queue == NULL)

goto out_vfree;

break;

 

   default:

printk(KERN_NOTICE "Bad request mode %d, using simple/n", request_mode);

         /* fall into.. */

 

   case RM_SIMPLE:

dev->queue = blk_init_queue(sbull_request, &dev->lock);//向系统动态申请请求队列

if (dev->queue == NULL)                                                    //sbull_request为个人实习的请求队列处理函数

goto out_vfree;

break;

}

blk_queue_hardsect_size(dev->queue, hardsect_size);

dev->queue->queuedata = dev;

/*

* And the gendisk structure.

*/

dev->gd = alloc_disk(SBULL_MINORS);//申请块设备数据结构

if (! dev->gd) {

printk (KERN_NOTICE "alloc_disk failure/n");

goto out_vfree;

}

dev->gd->major = sbull_major;

dev->gd->first_minor = which*SBULL_MINORS;

dev->gd->fops = &sbull_ops;

dev->gd->queue = dev->queue;//将请求队列与块设备绑定

dev->gd->private_data = dev;

snprintf (dev->gd->disk_name, 32, "sbull%c", which + 'a');

set_capacity(dev->gd, nsectors*(hardsect_size/KERNEL_SECTOR_SIZE));

add_disk(dev->gd);//最后添加到系统

return;

 

  out_vfree:

if (dev->data)

vfree(dev->data);

}

 

 

static void sbull_exit(void)

{

int i;

 

for (i = 0; i < ndevices; i++) {

struct sbull_dev *dev = Devices + i;

 

del_timer_sync(&dev->timer);

if (dev->gd) {

del_gendisk(dev->gd);

put_disk(dev->gd);

}

if (dev->queue) {

if (request_mode == RM_NOQUEUE)

blk_put_queue(dev->queue);

else

blk_cleanup_queue(dev->queue);//返回请求队列

}

if (dev->data)

vfree(dev->data);

}

unregister_blkdev(sbull_major, "sbull");//返回设备号

kfree(Devices);

}

最简单的处理请求队列模型

static void sbull_request(request_queue_t *q)

{

struct request *req;

 

while ((req = elv_next_request(q)) != NULL) {//elv_next_request获得请求队列中的下一个请求

struct sbull_dev *dev = req->rq_disk->private_data;

if (! blk_fs_request(req)) {

printk (KERN_NOTICE "Skip non-fs request/n");

end_request(req, 0);

continue;

}

    //     printk (KERN_NOTICE "Req dev %d dir %ld sec %ld, nr %d f %lx/n",

    //     dev - Devices, rq_data_dir(req),

    //     req->sector, req->current_nr_sectors,

    //     req->flags);

    //req->sector 要传输的下一个缓冲区

    //req->current_nr_sectors 当前要传输的扇区数目

    //req->buffer 数据应当从这个缓冲区来或者去

    //rq_data_dir 可获得这个请求的数据传送方向

sbull_transfer(dev, req->sector, req->current_nr_sectors,

req->buffer, rq_data_dir(req));

end_request(req, 1);

}

}

//传输数据

static void sbull_transfer(struct sbull_dev *dev, unsigned long sector,

unsigned long nsect, char *buffer, int write)          

{

                          //此次传输的偏移量

unsigned long offset = sector*KERNEL_SECTOR_SIZE;     //req->sector 要传输的下一个扇区

unsigned long nbytes = nsect*KERNEL_SECTOR_SIZE;//nsect = req->current_nr_sectors 当前要传输的扇区数目

                       //nbytes 此次要传输的字节数目

 

if ((offset + nbytes) > dev->size) {

printk (KERN_NOTICE "Beyond-end write (%ld %ld)/n", offset, nbytes);

return;

}

if (write)

memcpy(dev->data + offset, buffer, nbytes);

else

memcpy(buffer, dev->data + offset, nbytes);

}

 

每一个块设备的IO请求数据都是通过bio结构体表示，每个请求包含一个或者多个块（即是struct bio 中的数组）

块设备IO请求由结构体 struct request表示，因为一个请求可能包含多个连续磁盘块，所以可能包含多个struct bio结构体。

多个struct request 再链接成 struct request_queue。request_queue再与每个磁盘的gendisk捆绑在一起。

 

struct bio{

struct bio_vec *bi_io_vec;//指向数组的首地址

unsigned short bi_idx;//数组的标号

unsigned short bi_vcnt;//总共的片段数量

.......

}

struct bio_vec{//一个数据结构代表一个缓存片段

struct page *bv_page;//被缓存的内存页

unsigned int bv_len;//数据长度

unsigned int bv_offset;//页内偏移

}