Linux块设备驱动详解

struct bio_vec {
       struct page      *bv_page;  // 段所在的物理页面结构，即bh->b_page
       unsigned int    bv_len;    // 段的字节数，即bh->b_size
       unsigned int    bv_offset;  // 段在bv_page页面中的偏移，即bh->b_data
};

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 索引 */

 /* 执行物理地址合并后 sgement 的数目 */
 unsigned short bi_phys_segments;

 unsigned int bi_size;

 /* 为了明了最大的 segment 尺寸，我们考虑这个 bio 中第一个和最后一个
 可合并的 segment 的尺寸 */
 unsigned int bi_hw_front_size;
 unsigned int bi_hw_back_size;

 unsigned int bi_max_vecs; /* 我们能持有的最大 bvl_vecs 数 */
 unsigned int bi_comp_cpu; /* completion CPU */

 struct bio_vec *bi_io_vec; /* 实际的 vec 列表 */

 bio_end_io_t *bi_end_io;
 atomic_t bi_cnt;

 void *bi_private;
 #if defined(CONFIG_BLK_DEV_INTEGRITY)
 struct bio_integrity_payload *bi_integrity; /* 数据完整性 */
 #endif

 bio_destructor_t *bi_destructor; /* 析构 */
 };

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

struct buffer_head { 
    unsigned long b_state;                    /* buffer state bitmap (see above) */
    struct buffer_head *b_this_page;      /* circular list of page's buffers */
    struct page *b_page;                       /* the page this bh is mapped to */
 
    sector_t b_blocknr;                          /* start block number */
    size_t b_size;                                   /* size of mapping */
    char *b_data;                                  /* pointer to data within the page */
 
   struct block_device *b_bdev;
   bh_end_io_t *b_end_io;                   /* I/O completion */
  void *b_private;                              /* reserved for b_end_io */
  struct list_head b_assoc_buffers;     /* associated with another mapping */
  struct address_space *b_assoc_map;    /* mapping this buffer is
                                                             associated with */
   atomic_t b_count;                          /* users using this buffer_head */
};

void ll_rw_block(int rw, int nr, struct buffer_head *bhs[])
{
    int i;
 
    for (i = 0; i < nr; i ) {
        struct buffer_head *bh = bhs[i];
 
        if (!trylock_buffer(bh))
            continue;
        if (rw == WRITE) {
            if (test_clear_buffer_dirty(bh)) {
                bh->b_end_io = end_buffer_write_sync;
                get_bh(bh);
                submit_bh(WRITE, bh);
                continue;
            }
        } else {
            if (!buffer_uptodate(bh)) {
                bh->b_end_io = end_buffer_read_sync;
                get_bh(bh);
                submit_bh(rw, bh);
                continue;
            }
        }
        unlock_buffer(bh);
    }
}

int submit_bh(int rw, struct buffer_head * bh)
{
    struct bio *bio;
    int ret = 0;
 
    BUG_ON(!buffer_locked(bh));
    BUG_ON(!buffer_mapped(bh));
    BUG_ON(!bh->b_end_io);
    BUG_ON(buffer_delay(bh));
    BUG_ON(buffer_unwritten(bh));
 
    /*
     * Only clear out a write error when rewriting
     */
    if (test_set_buffer_req(bh) && (rw & WRITE))
        clear_buffer_write_io_error(bh);
 
    /*
     * from here on down, it's all bio -- do the initial mapping,
     * submit_bio -> generic_make_request may further map this bio around
     */
    bio = bio_alloc(GFP_NOIO, 1);
 
    bio->bi_sector = bh->b_blocknr * (bh->b_size >> 9);
    bio->bi_bdev = bh->b_bdev;
    bio->bi_io_vec[0].bv_page = bh->b_page;
    bio->bi_io_vec[0].bv_len = bh->b_size;
    bio->bi_io_vec[0].bv_offset = bh_offset(bh);
 
    bio->bi_vcnt = 1;
    bio->bi_idx = 0;
    bio->bi_size = bh->b_size;
 
    bio->bi_end_io = end_bio_bh_io_sync;
    bio->bi_private = bh;
 
    bio_get(bio);
    submit_bio(rw, bio);
 
    if (bio_flagged(bio, BIO_EOPNOTSUPP))
        ret = -EOPNOTSUPP;
 
    bio_put(bio);
    return ret;
}

void generic_make_request(struct bio *bio)
{
    struct bio_list bio_list_on_stack;
 
    if (!generic_make_request_checks(bio))
        return;
 
 
    if (current->bio_list) {
        bio_list_add(current->bio_list, bio);
        return;
    }
 
    BUG_ON(bio->bi_next);
    bio_list_init(&bio_list_on_stack);
    current->bio_list = &bio_list_on_stack;
    do {
        struct request_queue *q = bdev_get_queue(bio->bi_bdev);
 
        q->make_request_fn(q, bio);
 
        bio = bio_list_pop(current->bio_list);
    } while (bio);
    current->bio_list = NULL; /* deactivate */
}

struct request {
 struct list_head queuelist;
 struct call_single_data csd;
 int cpu;

 struct request_queue *q;

 unsigned int cmd_flags;
enum rq_cmd_type_bits cmd_type;
 unsigned long atomic_flags;

 /* 维护 I/O submission 的 BIO 遍历状态
 * hard_开头的成员仅用于块层内部，驱动不应该改变它们
 */

 sector_t sector; /* 要提交的下一个 sector */
 sector_t hard_sector; /* 要完成的下一个 sector */
 unsigned long nr_sectors; /* 剩余需要提交的 sector 数 */
 unsigned long hard_nr_sectors; /*剩余需要完成的 sector 数*/
 /* 在当前 segment 中剩余的需提交的 sector 数 */
 unsigned int current_nr_sectors;

 /*在当前 segment 中剩余的需完成的 sector 数 */
 unsigned int hard_cur_sectors;

 struct bio *bio;
 struct bio *biotail;

 struct hlist_node hash;
 union {
 struct rb_node rb_node; /* sort/lookup */
 void *completion_data;
 };

 /*
 * I/O 调度器可获得的两个指针，如果需要更多，请动态分配*/

 void *elevator_private;
 void *elevator_private2;

 struct gendisk *rq_disk;
 unsigned long start_time;

 /* scatter-gather DMA 方式下 addr+len 对的数量(执行物理地址合并后)
 */
 unsigned short nr_phys_segments;

 unsigned short ioprio;

 void *special;
 char *buffer;

 int tag;
 int errors;

 int ref_count;

 unsigned short cmd_len;
 unsigned char __cmd[BLK_MAX_CDB];
 unsigned char *cmd;

 unsigned int data_len;
 unsigned int extra_len;
 unsigned int sense_len;
 void *data;
 void *sense;

 unsigned long deadline;
 struct list_head timeout_list;
 unsigned int timeout;
 int retries;

 /*
 * 完成回调函数
 */
 rq_end_io_fn *end_io;
 void *end_io_data;

 struct request *next_rq;
 };
 return 0;
 out_queue: unregister_blkdev(XXX_MAJOR, "xxx");
 out: put_disk(xxx_disks);
 blk_cleanup_queue(xxx_queue);

 return -ENOMEM;
 }

void blk_queue_make_request(struct request_queue *q,make_request_fn *mfn);

static int __make_request(struct request_queue *q,struct bio *bio);

static int Virtual_blkdev_make_request(struct requset_queue *q,structb bio *bio)
{
   //因为不使用I/O调度算法，直接在该函数中完成数据在内存和硬盘之间的数据传输，该函数
   //代替了request_fn_proc()函数的功能
   ............
}
Virtual_blkdev_queue = blk_alloc_queue(GFP_KERNEL)
if(!Virtual_blkdev_queue)
{
   ret=-ENOMEN;
   goto err_alloc_queue;
}
blk_queue_make_request(Virtual_blkdev_queue,Virtual_blkdev_make_request);

struct request_queue* blk_inti_queue(request_fn_proc *rfn,spinlock_t *lock)