block设备 发送一个bio的过程 2.6.36

sync_request 这个是不一定的，可以call别的函数

    submit_bio

 

//这个的bio 和 bio_vec是local变量

static int sync_request(struct page *page, struct block_device *bdev, int rw)
{
    struct bio bio;
    struct bio_vec bio_vec;
    struct completion complete;

    bio_init(&bio);
    bio.bi_io_vec = &bio_vec;
    bio_vec.bv_page = page;  //传送整个page
    bio_vec.bv_len = PAGE_SIZE;
    bio_vec.bv_offset = 0;
    bio.bi_vcnt = 1;          //就一个bio_vec
    bio.bi_idx = 0;           //当前为0
    bio.bi_size = PAGE_SIZE;
    bio.bi_bdev = bdev;
    bio.bi_sector = page->index * (PAGE_SIZE >> 9);// 这个咋算出来的？
    init_completion(&complete);
    bio.bi_private = &complete;
    bio.bi_end_io = request_complete;

    submit_bio(rw, &bio);   //submit
    generic_unplug_device(bdev_get_queue(bdev));
    wait_for_completion(&complete); // 这里等待完成
    return test_bit(BIO_UPTODATE, &bio.bi_flags) ? 0 : -EIO;
}

 

 

void submit_bio(int rw, struct bio *bio)
{
    int count = bio_sectors(bio); // 转换成了sector数，以512B为单位

    ...

    ...

    generic_make_request(bio);
}

 

/*
 * We only want one ->make_request_fn to be active at a time,
 * else stack usage with stacked devices could be a problem.
 * So use current->bio_list to keep a list of requests
 * submited by a make_request_fn function.
 * current->bio_list is also used as a flag to say if
 * generic_make_request is currently active in this task or not.
 * If it is NULL, then no make_request is active.  If it is non-NULL,
 * then a make_request is active, and new requests should be added
 * at the tail
 */
void generic_make_request(struct bio *bio)
{
    struct bio_list bio_list_on_stack;

    if (current->bio_list) {
        /* make_request is active */
        bio_list_add(current->bio_list, bio);
        return;
    }
    /* following loop may be a bit non-obvious, and so deserves some
     * explanation.
     * Before entering the loop, bio->bi_next is NULL (as all callers
     * ensure that) so we have a list with a single bio.
     * We pretend that we have just taken it off a longer list, so
     * we assign bio_list to a pointer to the bio_list_on_stack,
     * thus initialising the bio_list of new bios to be
     * added.  __generic_make_request may indeed add some more bios
     * through a recursive call to generic_make_request.  If it
     * did, we find a non-NULL value in bio_list and re-enter the loop
     * from the top.  In this case we really did just take the bio
     * of the top of the list (no pretending) and so remove it from
     * bio_list, and call into __generic_make_request again.
     *
     * The loop was structured like this to make only one call to
     * __generic_make_request (which is important as it is large and
     * inlined) and to keep the structure simple.
     */
    BUG_ON(bio->bi_next);
    bio_list_init(&bio_list_on_stack);
    current->bio_list = &bio_list_on_stack;
    do {
        __generic_make_request(bio);
        bio = bio_list_pop(current->bio_list);
    } while (bio);
    current->bio_list = NULL; /* deactivate */
}

 

static inline void __generic_make_request(struct bio *bio)
{
    struct request_queue *q;
    sector_t old_sector;
    int ret, nr_sectors = bio_sectors(bio);
    dev_t old_dev;
    int err = -EIO;

    might_sleep();

    if (bio_check_eod(bio, nr_sectors))
        goto end_io;

    /*
     * Resolve the mapping until finished. (drivers are
     * still free to implement/resolve their own stacking
     * by explicitly returning 0)
     *
     * NOTE: we don't repeat the blk_size check for each new device.
     * Stacking drivers are expected to know what they are doing.
     */
    old_sector = -1;
    old_dev = 0;
    do {
        char b[BDEVNAME_SIZE];

        q = bdev_get_queue(bio->bi_bdev);
        if (unlikely(!q)) {
            printk(KERN_ERR
                   "generic_make_request: Trying to access "
                "nonexistent block-device %s (%Lu)/n",
                bdevname(bio->bi_bdev, b),
                (long long) bio->bi_sector);
            goto end_io;
        }

        if (unlikely(!(bio->bi_rw & REQ_DISCARD) &&
                 nr_sectors > queue_max_hw_sectors(q))) {
            printk(KERN_ERR "bio too big device %s (%u > %u)/n",
                   bdevname(bio->bi_bdev, b),
                   bio_sectors(bio),
                   queue_max_hw_sectors(q));
            goto end_io;
        }

        if (unlikely(test_bit(QUEUE_FLAG_DEAD, &q->queue_flags)))
            goto end_io;

        if (should_fail_request(bio))
            goto end_io;

        /*
         * If this device has partitions, remap block n
         * of partition p to block n+start(p) of the disk.
         */
        blk_partition_remap(bio);

        if (bio_integrity_enabled(bio) && bio_integrity_prep(bio))
            goto end_io;

        if (old_sector != -1)
            trace_block_remap(q, bio, old_dev, old_sector);

        old_sector = bio->bi_sector;
        old_dev = bio->bi_bdev->bd_dev;

        if (bio_check_eod(bio, nr_sectors))
            goto end_io;

        if ((bio->bi_rw & REQ_DISCARD) &&
            (!blk_queue_discard(q) ||
             ((bio->bi_rw & REQ_SECURE) &&
              !blk_queue_secdiscard(q)))) {
            err = -EOPNOTSUPP;
            goto end_io;
        }

        trace_block_bio_queue(q, bio);

        ret = q->make_request_fn(q, bio); //  这个应该就是注册进去的request函数
    } while (ret);

    return;

end_io:
    bio_endio(bio, err);
}