struct disk_stats:存储每个块设备的IO统计数据。diskstats里统计相关的除了inFlight都在这里。
后面就用这个结构来描述,请自行对应到diskstats里的列。

struct disk_stats {
    unsigned long sectors[2];   /* READs and WRITEs */
    unsigned long ios[2];
    unsigned long merges[2];
    unsigned long ticks[2];
    unsigned long io_ticks;
    unsigned long time_in_queue;
};

struct hd_struct:分区结构体。一个物理盘会有多个分区,每个分区由一个hd_struct。包括物理盘自身也对应一个hd_struct。
struct hd_struct {
    sector_t start_sect;
    sector_t nr_sects;
    struct device __dev;
    struct kobject *holder_dir;
    int policy, partno;     //partno为分区编号,磁盘自身该值为0
    ...
    unsigned long stamp;    //一个时间戳,统计ioticks时用到
    int in_flight;          //该分区当前有多少个请求正在处理。对应diskstats里的inFlight
#ifdef  CONFIG_SMP
    struct disk_stats *dkstats; //包含一个disk_stats存储统计信息
#else
    struct disk_stats dkstats;
#endif
    struct rcu_head rcu_head;
};

static int __make_request(struct request_queue *q, struct bio *bio)
{
    struct request *req;
get_rq:
    ...
    req = get_request_wait(q, rw_flags, bio);  //根据bio创建request
    ...
    init_request_from_bio(req, bio);        //初始化request
    ...
    add_request(q, req);                //将request add进queue
    ...
end_io:
    bio_endio(bio, err);
    return 0;
}

void init_request_from_bio(struct request *req, struct bio *bio)
{
    ....
    req->errors = 0;
    req->hard_sector = req->sector = bio->bi_sector;
    req->ioprio = bio_prio(bio);
    req->start_time = jiffies;      //这个请求push进queue时的jiffies
    blk_rq_bio_prep(req->q, req, bio);
}

static inline void add_request(struct request_queue *q, struct request *req)
{
    drive_stat_acct(req, 1);
    __elv_add_request(q, req, ELEVATOR_INSERT_SORT, 0);
}

static void drive_stat_acct(struct request *rq, int new_io)
{
    struct hd_struct *part;
    int rw = rq_data_dir(rq);
    int cpu;

    cpu = part_stat_lock();
    part = disk_map_sector_rcu(rq->rq_disk, rq->sector);    //用req找到分区part

    part_round_stats(cpu, part);        //更新分区统计
    part_inc_in_flight(part);

}

void part_round_stats(int cpu, struct hd_struct *part)
{
    unsigned long now = jiffies;    //获取当前时间戳

    if (part->partno)       //如果是分区,则同步更新主分区即物理盘的统计。
        part_round_stats_single(cpu, &part_to_disk(part)->part0, now);  
    part_round_stats_single(cpu, part, now);   //更新io_ticks
}

static void part_round_stats_single(int cpu, struct hd_struct *part,
                    unsigned long now)
{
    if (now == part->stamp)
        return;

    if (part->in_flight) {          //in_flight非0,需要更新。
        __part_stat_add(cpu, part, time_in_queue,
                part->in_flight * (now - part->stamp)); //将(now - part->stamp)*in_flight 累加到hd_struct.disk_stats.io_ticks上
        __part_stat_add(cpu, part, io_ticks, (now - part->stamp)); //将(now - part->stamp)累加到hd_struct.disk_stats.io_ticks上
    }
    part->stamp = now;      //stamp更新为当前时间
}

static inline void part_inc_in_flight(struct hd_struct *part)
{
    part->in_flight++;
    if (part->partno)       //物理盘同步自增
        part_to_disk(part)->part0.in_flight++;
}

static void end_that_request_last(struct request *req, int error)
{
    struct gendisk *disk = req->rq_disk;
    ...
    if (disk && blk_fs_request(req) && req != &req->q->bar_rq) {
        unsigned long duration = jiffies - req->start_time;   //完成时间-请求时间=该请求的await
        const int rw = rq_data_dir(req);
        struct hd_struct *part;
        int cpu;

        cpu = part_stat_lock();
        part = disk_map_sector_rcu(disk, req->sector);

        part_stat_inc(cpu, part, ios[rw]);              //该分区完成读/写请求数+1
        part_stat_add(cpu, part, ticks[rw], duration);  //单个请求的await累加到分区的统计里。
        part_round_stats(cpu, part);                   //更新disk_stats.io_ticks
        part_dec_in_flight(part);                   //hd_struct.in_flight--

        part_stat_unlock();
    }

    ...
}

#define part_stat_inc(cpu, gendiskp, field)             \
    part_stat_add(cpu, gendiskp, field, 1)


#define part_stat_add(cpu, part, field, addnd)  do {            \   //addnd为1
    __part_stat_add((cpu), (part), field, addnd);               if ((part)->partno)                             __part_stat_add((cpu), &part_to_disk((part))->part0,    \       //物理盘同步+1
                field, addnd);              } while (0)

static int dm_request(struct request_queue *q, struct bio *bio)
{
    int r = -EIO;
    int rw = bio_data_dir(bio);
    struct mapped_device *md = q->queuedata;
    int cpu;

    cpu = part_stat_lock();             
    part_stat_inc(cpu, &dm_disk(md)->part0, ios[rw]);       //更新统计
    part_stat_add(cpu, &dm_disk(md)->part0, sectors[rw], bio_sectors(bio));
    part_stat_unlock();
    ...
    r = __split_bio(md, bio);
    up_read(&md->io_lock);
    return 0;
}

static int __split_bio(struct mapped_device *md, struct bio *bio)
{
    struct clone_info ci;
    int error = 0;
    ...
    start_io_acct(ci.io);       //更新统计
    while (ci.sector_count && !error)
        error = __clone_and_map(&ci);

    /* drop the extra reference count */
    dec_pending(ci.io, error);
    dm_table_put(ci.map);

    return 0;
}

static void start_io_acct(struct dm_io *io)
{
    struct mapped_device *md = io->md;
    int cpu;
    io->start_time = jiffies;
    cpu = part_stat_lock();
    part_round_stats(cpu, &dm_disk(md)->part0);
    part_stat_unlock();
    dm_disk(md)->part0.in_flight = atomic_inc_return(&md->pending);
}