Linux3.10.0块IO子系统流程（1）-- 上层提交请求

Linux通用块层提供给上层的接口函数是submit_bio。上层在构造好bio之后，调用submit_bio提交给通用块层处理。

 

submit_bio函数如下：

 

void submit_bio(int rw, struct bio *bio)
{
    bio->bi_rw |= rw;    //记录读写方式
    /*
     * 执行有数据传输的读写或屏障请求统计，暂不关心
     */
    if (bio_has_data(bio)) {
        unsigned int count;
        if (unlikely(rw & REQ_WRITE_SAME))
            count = bdev_logical_block_size(bio->bi_bdev) >> 9;
        else
            count = bio_sectors(bio);
        if (rw & WRITE) {
            count_vm_events(PGPGOUT, count);
        } else {
            task_io_account_read(bio->bi_size);
            count_vm_events(PGPGIN, count);
        }
        if (unlikely(block_dump)) {
            char b[BDEVNAME_SIZE];
            printk(KERN_DEBUG "%s(%d): %s block %Lu on %s (%u sectors)
",
            current->comm, task_pid_nr(current),
                (rw & WRITE) ? "WRITE" : "READ",
                (unsigned long long)bio->bi_sector,
                bdevname(bio->bi_bdev, b),
                count);
        }
    }
    //执行真实的IO处理
    generic_make_request(bio);
}

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);    //获取bio对应的请求队列
        q->make_request_fn(q, bio);                                //调用请求队列的回调函数来处理IO
        bio = bio_list_pop(current->bio_list);
    } while (bio);
    current->bio_list = NULL; /* deactivate */
}

在调用make_request_fn处理bio的时候，可能会产生新的bio，即make_request_fn会递归调用generic_make_request 最直观的例子就是“栈式块设备”。为了防止栈式块设备执行请求可能出现问题，在一个时刻只允许进程有一个generic_make_request被调用。为此，在进程结构中定义了一个bio等待处理链表：bio_list。同时区分“活动”和“非活动”状态。活动状态表示进程已经在调用generic_make_request。这时，所有后续产生的bio都链入bio_list链表，在当前bio完成的情况下，逐个处理。

 

generic_make_request的执行过程：

1. generic_make_request_checks
2. 判断make_request是否处于活动状态。如果current->bio_list不为NULL，则表明当前进程已经有generic_make_request在执行，这时候传进来的bio都将链接到当前进程等待处理的bio链表尾部
3. 设置current->bio_list表明当前的generic_make_request为活动状态，让后来的bio有机会插入等待链表
4. 处理bio。这里的bio可能是传入的bio，也可能是当前进程待处理bio链表中的bio。如果是前者，上层保证了其bi_next必然为NULL；如果是后者，则在将bio从链表中脱离的时候，已经设置了bi_next为NULL
5. 调用make_request_fn回调处理bio
6. 检查当前进程的等待链表中是否还有bio，如果有，跳到第三步
7. 至此，generic_make_request的“本轮执行周期”已经完毕，清零current->bio_list，使得generic_make_request处于“非活动”状态

这里再看下generic_make_request_checks

 

static noinline_for_stack bool
generic_make_request_checks(struct bio *bio)
{
    struct request_queue *q;
    int nr_sectors = bio_sectors(bio);
    int err = -EIO;
    char b[BDEVNAME_SIZE];
    struct hd_struct *part;

    might_sleep();

    // 检查bio的扇区有没有超过块设备的扇区数
    if (bio_check_eod(bio, nr_sectors))
        goto end_io;

    // 检测块设备的请求队列是否为空
    q = bdev_get_queue(bio->bi_bdev);
    if (unlikely(!q)) {
        printk(KERN_ERR
               "generic_make_request: Trying to access "
            "nonexistent block-device %s (%Lu)
",
            bdevname(bio->bi_bdev, b),
            (long long) bio->bi_sector);
        goto end_io;
    }
    
    // 检测请求的扇区长度是否超过物理限制
    if (likely(bio_is_rw(bio) &&
           nr_sectors > queue_max_hw_sectors(q))) {
        printk(KERN_ERR "bio too big device %s (%u > %u)
",
               bdevname(bio->bi_bdev, b),
               bio_sectors(bio),
               queue_max_hw_sectors(q));
        goto end_io;
    }

    part = bio->bi_bdev->bd_part;
    if (should_fail_request(part, bio->bi_size) ||
        should_fail_request(&part_to_disk(part)->part0,
                bio->bi_size))
        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_check_eod(bio, nr_sectors))
        goto end_io;

    /*
     * Filter flush bio's early so that make_request based
     * drivers without flush support don't have to worry
     * about them.
     */
    if ((bio->bi_rw & (REQ_FLUSH | REQ_FUA)) && !q->flush_flags) {
        bio->bi_rw &= ~(REQ_FLUSH | REQ_FUA);
        if (!nr_sectors) {
            err = 0;
            goto end_io;
        }
    }

     // 检查设备对DISCARD命令的支持
    if ((bio->bi_rw & REQ_DISCARD) &&
        (!blk_queue_discard(q) ||
         ((bio->bi_rw & REQ_SECURE) && !blk_queue_secdiscard(q)))) {
        err = -EOPNOTSUPP;
        goto end_io;
    }

    if (bio->bi_rw & REQ_WRITE_SAME && !bdev_write_same(bio->bi_bdev)) {
        err = -EOPNOTSUPP;
        goto end_io;
    }

    /*
     * Various block parts want %current->io_context and lazy ioc
     * allocation ends up trading a lot of pain for a small amount of
     * memory.  Just allocate it upfront.  This may fail and block
     * layer knows how to live with it.
     */
    create_io_context(GFP_ATOMIC, q->node);

    if (blk_throtl_bio(q, bio))
        return false;    /* throttled, will be resubmitted later */

    trace_block_bio_queue(q, bio);
    return true;

end_io:
    bio_endio(bio, err);
    return false;
}