深入 Linux Kernel：cgroup io.max 如何在 Block Layer 中實現 I/O 限速

// block/blk-core.c

void submit_bio(struct bio *bio)
{
	// ... 更新統計資料 ...
	if (bio_op(bio) == REQ_OP_READ) {
		task_io_account_read(bio->bi_iter.bi_size);
		count_vm_events(PGPGIN, bio_sectors(bio));
	} else if (bio_op(bio) == REQ_OP_WRITE) {
		count_vm_events(PGPGOUT, bio_sectors(bio));
	}

	bio_set_ioprio(bio);
	submit_bio_noacct(bio); // noacct = no accounting
}
EXPORT_SYMBOL(submit_bio);

void submit_bio_noacct(struct bio *bio)
{
	// ... 一些基本的 bio 驗證 ...
	struct block_device *bdev = bio->bi_bdev;
	struct request_queue *q = bdev_get_queue(bdev);
	blk_status_t status = BLK_STS_IOERR;
	...
	switch (bio_op(bio)) {
	case REQ_OP_READ:
		break;
	case REQ_OP_WRITE:
		if (bio->bi_opf & REQ_ATOMIC) {
			status = blk_validate_atomic_write_op_size(q, bio);
			if (status != BLK_STS_OK)
				goto end_io;
		}
		break;
	...
	default:
		goto not_supported;
	}

	// throttling 機制
	if (blk_throtl_bio(bio))
		return;
	// 放入請求佇列
	submit_bio_noacct_nocheck(bio);
	return;

not_supported:
	status = BLK_STS_NOTSUPP;
end_io:
	bio->bi_status = status;
	bio_endio(bio);
}

void submit_bio_noacct_nocheck(struct bio *bio)
{
	...
	if (current->bio_list)
		bio_list_add(&current->bio_list[0], bio);
	...
}

static inline bool blk_throtl_bio(struct bio *bio)
{
	if (!blk_should_throtl(bio)) // 檢查是否需要啟用限速
		return false;
	return __blk_throtl_bio(bio); // 執行限速的核心邏輯
}

static inline bool blk_should_throtl(struct bio *bio)
{
	struct throtl_grp *tg = blkg_to_tg(bio->bi_blkg);
	int rw = bio_data_dir(bio);
	// ... 省略 cgroup v1 相關邏輯 ...
	/* iops limit is always counted */
	if (tg->has_rules_iops[rw]) // 是否設定了 IOPS 限制
		return true;
	if (tg->has_rules_bps[rw] && !bio_flagged(bio, BIO_BPS_THROTTLED)) // 是否設定了 BPS 限制
		return true;
	return false;
}

// block/blk-throttle.c
bool __blk_throtl_bio(struct bio *bio)
{
	// ... 初始化變數 ...
	struct throtl_grp *tg = blkg_to_tg(bio->bi_blkg);
	bool throttled = false;

	// ...
	// 迴圈檢查從當前 cgroup 到 root cgroup 的每一層
	while (true) {
		if (tg_within_limit(tg, bio, rw)) {
			// 在限制內，累加用量並繼續檢查父 cgroup
			throtl_charge_bio(tg, bio);
			throtl_trim_slice(tg, rw);
		} else if (bio_issue_as_root_blkg(bio)) {
			// ... 特殊情況處理，例如避免優先級反轉 ...
			tg_dispatch_in_debt(tg, bio, rw);
		} else {
			// 超出限制，跳出迴圈，準備排隊
			break;
		}

		// 爬到父 cgroup
		tg = sq_to_tg(sq->parent_sq);
		if (!tg) {
			// 已到 root 且都通過，不需限速
			bio_set_flag(bio, BIO_BPS_THROTTLED);
			goto out_unlock;
		}
	}

	// 超出限制，將 bio 加入到 tg 的佇列中
	td->nr_queued[rw]++;
	throtl_add_bio_tg(bio, qn, tg);
	throttled = true;

	// 如果佇列之前是空的，則需要安排下一次的派發
	if (tg->flags & THROTL_TG_WAS_EMPTY) {
		tg_update_disptime(tg);
		throtl_schedule_next_dispatch(tg->service_queue.parent_sq, true);
	}

out_unlock:
	// ...
	return throttled;
}

static inline bool bio_issue_as_root_blkg(struct bio *bio)
{
	return (bio->bi_opf & (REQ_META | REQ_SWAP)) != 0;
}

static bool tg_within_limit(struct throtl_grp *tg, struct bio *bio, bool rw)
{
	/* throtl is FIFO - if bios are already queued, should queue */
	// 簡單來說，如果前一個 request 已經被卡住了，那現在這個 request 當然也被卡住了
	if (tg->service_queue.nr_queued[rw])
		return false;

	return tg_may_dispatch(tg, bio, NULL);
}

// block/blk-throttle.c

static bool tg_may_dispatch(struct throtl_grp *tg, struct bio *bio,
			    unsigned long *wait)
{
	bool rw = bio_data_dir(bio);
	unsigned long bps_wait = 0, iops_wait = 0, max_wait = 0;
	u64 bps_limit = tg_bps_limit(tg, rw); // 取得設定的 BPS 上限
	u32 iops_limit = tg_iops_limit(tg, rw); // 取得設定的 IOPS 上限

	// 如果沒有設定限制，直接通過
	if ((bps_limit == U64_MAX && iops_limit == UINT_MAX) ||
	    tg->flags & THROTL_TG_CANCELING) {
		if (wait)
			*wait = 0;
		return true;
	}

	// 如果上一個時間片用完了 (current time > slice end time)，就開始一個新的
	if (throtl_slice_used(tg, rw) && !(tg->service_queue.nr_queued[rw]))
		throtl_start_new_slice(tg, rw, true);
	else {
        // 否則，確保當前時間片至少還有 throtl_slice 的長度
		if (time_before(tg->slice_end[rw], jiffies + tg->td->throtl_slice))
			throtl_extend_slice(tg, rw, jiffies + tg->td->throtl_slice);
	}

    // 計算 BPS 和 IOPS 是否在當前時間片的額度內
	bps_wait = tg_within_bps_limit(tg, bio, bps_limit);
	iops_wait = tg_within_iops_limit(tg, bio, iops_limit);

    // 如果計算出的等待時間是 0，表示額度足夠
	if (bps_wait + iops_wait == 0) {
		if (wait)
			*wait = 0;
		return true;
	}

	// 如果需要等待，計算最長的等待時間
	max_wait = max(bps_wait, iops_ wait);
	if (wait)
		*wait = max_wait;
    
    // 延長時間片以包含等待時間
	if (time_before(tg->slice_end[rw], jiffies + max_wait))
		throtl_extend_slice(tg, rw, jiffies + max_wait);

	return false; // 返回 false，表示需要等待，無法立即派發
}

#define DFL_THROTL_SLICE_HD (HZ / 10)
#define DFL_THROTL_SLICE_SSD (HZ / 50)
#define MAX_THROTL_SLICE (HZ)

static int blk_throtl_init(struct gendisk *disk) 
{
	...
	if (blk_queue_nonrot(q))
		td->throtl_slice = DFL_THROTL_SLICE_SSD;
	else
		td->throtl_slice = DFL_THROTL_SLICE_HD;
	...
}