Block / Storage · Linux 6.18.37 LTS · source + diagram note

request queue

기존 코드 발췌를 읽으실 때

기존 대표 코드 두 상자는 v6.6 발췌였습니다. 아래에는 v6.18.37의 고정 원문으로 교체하고 실제 함수 경계를 표기했습니다.

Linux v6.18.37의 bio 제출·request/tag 준비, hardware queue dispatch, freeze depth와 완료 경계를 고정 원문 그림과 표로 읽습니다.

전체 흐름

block/blk-mq.c v6.18.37에서 bio 제출은 기존 request와 병합되거나 새 request를 준비한다. 그 뒤 plug 보관, scheduler 삽입, 직접 issue 시도로 갈라진다. blk_mq_run_hw_queue()는 이미 쌓인 작업을 실행할지를 판단하며 request/tag 할당 함수가 아니다. driver 완료는 별도 blk_mq_end_request() 경계다.

그림 1. bio 병합과 request 전달 출구
bio입력 · 준비제한/무결성 검사조건부병합 시도plug / scheduler병합 성공기존 request새 rq 할당 없음병합 실패cached / new rqtag 확보 가능성전달 출구분기flush · plugscheduler · direct병합 성공은 새 request를 만들지 않는다. flush/plug 보관도 device 완료가 아니다.

점선은 병합 실패 후 새 request가 필요한 경로다. 모든 제출이 곧바로 driver로 넘어가지는 않는다.

시점주요 함수/조건결과를 읽는 기준
bio 준비제한·분할·integrity 검사; v6.18.37에는 zone write plug 재진입여기서 끝난 bio에는 request가 없을 수 있음
병합blk_mq_attempt_bio_merge()성공하면 기존 request에 붙고 새 tag를 얻지 않음
새 request__blk_mq_alloc_requests()의 tag 획득요청을 가졌어도 아직 issue/완료가 아님
전달flush / plug / scheduler / direct issue 조건보관·삽입·issue 시도는 서로 다른 출구
완료blk_mq_end_request()driver 완료와 status 처리 경계

소스 코드 위치

먼저 확인할 Linux 6.18.37 LTS 소스 파일

원본 코드:
Linux 6.18.37 LTS: block/blk-mq.c
Linux 6.18.37 LTS: block/blk-core.c
Linux 6.18.37 LTS: include/linux/blk-mq.h

설명: blk-mq.c에서 submit·tag 할당·hardware queue run·freeze·완료 함수의 실제 경계를 분리한다. blk-core.c는 bio 제출 진입 및 공통 block 처리를 함께 확인할 때 참고한다.

대표 코드

고정 버전의 함수 경계를 기준으로 발췌했다. 원래 run_hw_queue 제목 아래의 freeze 코드는 실제 dispatch 함수가 아니다.

blk_mq_submit_bio() 시작

고정 원본: block/blk-mq.c:3121-3159
void blk_mq_submit_bio(struct bio *bio)
{
	struct request_queue *q = bdev_get_queue(bio->bi_bdev);
	struct blk_plug *plug = current->plug;
	const int is_sync = op_is_sync(bio->bi_opf);
	struct blk_mq_hw_ctx *hctx;
	unsigned int nr_segs;
	struct request *rq;
	blk_status_t ret;

	/*
	 * If the plug has a cached request for this queue, try to use it.
	 */
	rq = blk_mq_peek_cached_request(plug, q, bio->bi_opf);

	/*
	 * A BIO that was released from a zone write plug has already been
	 * through the preparation in this function, already holds a reference
	 * on the queue usage counter, and is the only write BIO in-flight for
	 * the target zone. Go straight to preparing a request for it.
	 */
	if (bio_zone_write_plugging(bio)) {
		nr_segs = bio->__bi_nr_segments;
		if (rq)
			blk_queue_exit(q);
		goto new_request;
	}

	/*
	 * The cached request already holds a q_usage_counter reference and we
	 * don't have to acquire a new one if we use it.
	 */
	if (!rq) {
		if (unlikely(bio_queue_enter(bio)))
			return;
	}

	/*
	 * Device reconfiguration may change logical block size or reduce the

v6.18.37은 cached request 조회와 zone write plug 재진입을 먼저 구분한다. queue 사용 참조가 필요한 경우 bio_queue_enter()를 호출한다.

blk_mq_submit_bio()의 request·출구 분기

고정 원본: block/blk-mq.c:3181-3244
	blk_mq_bio_issue_init(q, bio);
	if (blk_mq_attempt_bio_merge(q, bio, nr_segs))
		goto queue_exit;

	if (bio_needs_zone_write_plugging(bio)) {
		if (blk_zone_plug_bio(bio, nr_segs))
			goto queue_exit;
	}

new_request:
	if (rq) {
		blk_mq_use_cached_rq(rq, plug, bio);
	} else {
		rq = blk_mq_get_new_requests(q, plug, bio);
		if (unlikely(!rq)) {
			if (bio->bi_opf & REQ_NOWAIT)
				bio_wouldblock_error(bio);
			goto queue_exit;
		}
	}

	trace_block_getrq(bio);

	rq_qos_track(q, rq, bio);

	blk_mq_bio_to_request(rq, bio, nr_segs);

	ret = blk_crypto_rq_get_keyslot(rq);
	if (ret != BLK_STS_OK) {
		bio->bi_status = ret;
		bio_endio(bio);
		blk_mq_free_request(rq);
		return;
	}

	if (bio_zone_write_plugging(bio))
		blk_zone_write_plug_init_request(rq);

	if (op_is_flush(bio->bi_opf) && blk_insert_flush(rq))
		return;

	if (plug) {
		blk_add_rq_to_plug(plug, rq);
		return;
	}

	hctx = rq->mq_hctx;
	if ((rq->rq_flags & RQF_USE_SCHED) ||
	    (hctx->dispatch_busy && (q->nr_hw_queues == 1 || !is_sync))) {
		blk_mq_insert_request(rq, 0);
		blk_mq_run_hw_queue(hctx, true);
	} else {
		blk_mq_run_dispatch_ops(q, blk_mq_try_issue_directly(hctx, rq));
	}
	return;

queue_exit:
	/*
	 * Don't drop the queue reference if we were trying to use a cached
	 * request and thus didn't acquire one.
	 */
	if (!rq)
		blk_queue_exit(q);
}

병합·cached/new request·flush/plug/scheduler/direct 분기는 조건에 따라 갈라진다. 이 반환은 device 완료를 뜻하지 않는다.

__blk_mq_alloc_requests()의 tag 획득

고정 원본: block/blk-mq.c:506-561
	if (data->cmd_flags & REQ_NOWAIT)
		data->flags |= BLK_MQ_REQ_NOWAIT;

retry:
	data->ctx = blk_mq_get_ctx(q);
	data->hctx = blk_mq_map_queue(data->cmd_flags, data->ctx);

	if (q->elevator) {
		/*
		 * All requests use scheduler tags when an I/O scheduler is
		 * enabled for the queue.
		 */
		data->rq_flags |= RQF_SCHED_TAGS;

		/*
		 * Flush/passthrough requests are special and go directly to the
		 * dispatch list.
		 */
		if ((data->cmd_flags & REQ_OP_MASK) != REQ_OP_FLUSH &&
		    !blk_op_is_passthrough(data->cmd_flags)) {
			struct elevator_mq_ops *ops = &q->elevator->type->ops;

			WARN_ON_ONCE(data->flags & BLK_MQ_REQ_RESERVED);

			data->rq_flags |= RQF_USE_SCHED;
			if (ops->limit_depth)
				ops->limit_depth(data->cmd_flags, data);
		}
	} else {
		blk_mq_tag_busy(data->hctx);
	}

	if (data->flags & BLK_MQ_REQ_RESERVED)
		data->rq_flags |= RQF_RESV;

	/*
	 * Try batched alloc if we want more than 1 tag.
	 */
	if (data->nr_tags > 1) {
		rq = __blk_mq_alloc_requests_batch(data);
		if (rq) {
			blk_mq_rq_time_init(rq, alloc_time_ns);
			return rq;
		}
		data->nr_tags = 1;
	}

	/*
	 * Waiting allocations only fail because of an inactive hctx.  In that
	 * case just retry the hctx assignment and tag allocation as CPU hotplug
	 * should have migrated us to an online CPU by now.
	 */
	tag = blk_mq_get_tag(data);
	if (tag == BLK_MQ_NO_TAG) {
		if (data->flags & BLK_MQ_REQ_NOWAIT)
			return NULL;

scheduler가 있으면 scheduler tag 조건을 설정한다. BLK_MQ_NO_TAG에서 NOWAIT은 NULL을 반환할 수 있고, 대기형은 재시도한다.

blk_mq_run_hw_queue() 실제 정의

고정 원본: block/blk-mq.c:2334-2370
void blk_mq_run_hw_queue(struct blk_mq_hw_ctx *hctx, bool async)
{
	bool need_run;

	/*
	 * We can't run the queue inline with interrupts disabled.
	 */
	WARN_ON_ONCE(!async && in_interrupt());

	might_sleep_if(!async && hctx->flags & BLK_MQ_F_BLOCKING);

	need_run = blk_mq_hw_queue_need_run(hctx);
	if (!need_run) {
		unsigned long flags;

		/*
		 * Synchronize with blk_mq_unquiesce_queue(), because we check
		 * if hw queue is quiesced locklessly above, we need the use
		 * ->queue_lock to make sure we see the up-to-date status to
		 * not miss rerunning the hw queue.
		 */
		spin_lock_irqsave(&hctx->queue->queue_lock, flags);
		need_run = blk_mq_hw_queue_need_run(hctx);
		spin_unlock_irqrestore(&hctx->queue->queue_lock, flags);

		if (!need_run)
			return;
	}

	if (async || !cpumask_test_cpu(raw_smp_processor_id(), hctx->cpumask)) {
		blk_mq_delay_run_hw_queue(hctx, 0);
		return;
	}

	blk_mq_run_dispatch_ops(hctx->queue,
				blk_mq_sched_dispatch_requests(hctx));
}

quiesced/empty이면 반환할 수 있고, async/CPU 조건에서 지연 실행한다. 이 함수는 새 request를 할당하지 않는다.

__blk_freeze_queue_start()·blk_freeze_queue_start()·wait

고정 원본: block/blk-mq.c:163-193
bool __blk_freeze_queue_start(struct request_queue *q,
			      struct task_struct *owner)
{
	bool freeze;

	mutex_lock(&q->mq_freeze_lock);
	freeze = blk_freeze_set_owner(q, owner);
	if (++q->mq_freeze_depth == 1) {
		percpu_ref_kill(&q->q_usage_counter);
		mutex_unlock(&q->mq_freeze_lock);
		if (queue_is_mq(q))
			blk_mq_run_hw_queues(q, false);
	} else {
		mutex_unlock(&q->mq_freeze_lock);
	}

	return freeze;
}

void blk_freeze_queue_start(struct request_queue *q)
{
	if (__blk_freeze_queue_start(q, current))
		blk_freeze_acquire_lock(q);
}
EXPORT_SYMBOL_GPL(blk_freeze_queue_start);

void blk_mq_freeze_queue_wait(struct request_queue *q)
{
	wait_event(q->mq_freeze_wq, percpu_ref_is_zero(&q->q_usage_counter));
}
EXPORT_SYMBOL_GPL(blk_mq_freeze_queue_wait);

v6.18.37에서는 owner 설정과 freeze depth 첫 진입을 __blk_freeze_queue_start()가 처리한다. wrapper는 필요하면 owner lock을 잡고, wait는 별도다.

blk_mq_end_request() — 완료 경계

고정 원본: block/blk-mq.c:1159-1164
void blk_mq_end_request(struct request *rq, blk_status_t error)
{
	if (blk_update_request(rq, error, blk_rq_bytes(rq)))
		BUG();
	__blk_mq_end_request(rq, error);
}

driver가 완료를 알리는 별도 경로다. blk_update_request()와 __blk_mq_end_request()가 status를 처리한다.

함수별 분석

blk_mq_submit_bio()에서 cached request가 이미 보유한 queue 사용 참조를 재사용한다. 새 참조가 필요한 때 bio_queue_enter()에 들어가고, zone write plug에서 풀려난 bio는 이미 준비된 상태로 new_request에 재진입한다. blk_mq_attempt_bio_merge()와 zone write plug 분기는 tag 할당보다 앞선다. blk_crypto_rq_get_keyslot() 실패는 bio_endio() 후 request를 해제한다. 정상 준비 뒤에도 flush와 plug가 먼저 받을 수 있고, scheduler를 쓰거나 dispatch가 바쁘면 삽입 후 hardware queue를 실행한다. 그 외에는 직접 issue를 시도한다.

그림 2. 준비 오류·tag 실패·driver 완료의 경계
bio제출 시작검사 · 병합준비 오류bio 종료no rq / bio_endio할당 오류NOWAIT 실패tag/rq 없음requestqueued/issued완료 전 단계driver 완료end_requeststatus 전달제출 함수 반환이나 queue 실행 호출은 완료 callback이 아니다. 오류 위치별 소유권을 구분한다.

오류는 발생 위치마다 bio와 request의 소유 상태가 다르다. 그림은 대표 경로만 보인다.

경계호출자가 알 수 있는 것동일시하면 안 되는 것
준비 검사bio가 이른 오류로 종료될 수 있음request 할당 실패와 동일하지 않음
병합 성공bio가 기존 request에 합쳐짐새 tag 생성이나 별도 issue 아님
tag 미획득NOWAIT에서 BLK_MQ_NO_TAG면 NULL 가능device latency나 완료 오류 아님
제출 출구flush/plug/scheduler/direct issue 갈림모든 분기가 즉시 driver dispatch 아님
완료 함수request 상태와 blk_status_t 처리run_hw_queue() 호출 자체가 완료 아님

구조체와 필드

request_queue.q_usage_counter는 queue 사용 중인 경로의 참조를 세고 freeze가 신규 진입을 막는 기준이다. blk_plug에 cached request가 있으면 그 request가 가진 참조·tag를 재사용할 수 있다. blk_mq_alloc_data는 새 request의 ctx/hctx와 tag 선택 맥락을 전달한다. hctx는 dispatch 대상이지만 그 자체가 한 request의 완료 상태는 아니다.

그림 3. queue 참조와 cached/new request의 갈림
queue사용 참조freeze 중 진입 제한재사용cached rq기존 queue 참조 유지새 요청get_new_requests확보한 queue 참조 사용할당기blk_mq_get_tagscheduler/driver tag결과requestdispatch 전 상태cached rq는 기존 queue 참조·tag를 재사용한다. 새 rq의 tag 획득도 driver issue·완료는 아니다.

상단 cached 경로는 tag allocator를 지나지 않는다. 하단 새 request 경로에서 scheduler tag와 driver tag 조건을 확인한다.

객체/필드의미주의할 점
request_queue.q_usage_counterbio/request가 queue를 사용하는 동안의 참조freeze depth와 별개; drain 대기는 별도
blk_plug.cached_rq(s)plug에 보관된 재사용 request새 tag를 매번 받는다고 보면 안 됨
blk_mq_alloc_data.rq_flagsscheduler tag 및 scheduler 사용 여부scheduler tag와 driver tag를 혼동하지 않음
blk_mq_hw_ctxCPU/type에 매핑된 hardware queue 문맥quiesce·pending 조건은 run에서 다시 확인
requestbio를 묶고 dispatch·완료로 이어지는 객체allocation, issue, completion은 각기 다른 시점

실행 단계와 상태 변화

v6.18.37은 첫 need_run 판단이 거짓이면 queue_lock 아래에서 재검사해 unquiesce와의 경합을 다룬다. 그 뒤 async 또는 현재 CPU가 hctx cpumask 밖이면 지연 실행하고, 그 외에는 scheduler dispatch를 호출한다. freeze는 별도 경로다. v6.18.37은 __blk_freeze_queue_start()가 owner와 freeze depth를 다루고 wrapper가 필요할 때 lock을 잡는다. 첫 freeze는 percpu_ref_kill() 뒤 밀린 hardware queue도 실행해 참조가 빠져나가게 한다. blk_mq_freeze_queue_wait()가 참조 수 0을 기다리는 것은 신규 진입 차단과 다른 단계다.

그림 4. hardware queue 실행 조건과 freeze depth·drain
RUN: pending과 quiesce를 검사한 뒤 dispatch 선택FREEZE: 새 queue 참조 차단과 기존 참조 drainhctxrun_hw_queuepending · QUIESCED불가returnquiesced/emptyasync/CPU 외delay_run나중에 실행그 외dispatchdriver issue 시도queuefreeze_depth첫 freeze인지 검사depth 1percpu_ref_kill신규 진입 차단별도 waitref == 0진행 중 참조 drain경계변경 가능완료와는 별개freeze는 dispatch 중단 플래그와 다르다. run_hw_queue는 request를 할당하지 않는다.

윗줄의 반환·지연·inline dispatch는 조건부 대안이다. 아랫줄의 freeze는 신규 사용 제한과 기존 참조 drain을 나눠 보인다.

조건/호출변화 또는 다음 단계잘못된 해석
blk_mq_hw_queue_need_run() falsequiesced 또는 pending 없음 → 반환; 버전에 따라 재검사request 할당 실패/완료와 같지 않음
async 또는 CPU mask 밖blk_mq_delay_run_hw_queue() 예약이 함수 호출 시점에 driver 완료 아님
동기·허용 CPUblk_mq_sched_dispatch_requests() 시도모든 request가 driver에 수락된다는 보장 아님
첫 freeze depthpercpu_ref_kill(q_usage_counter)기존 사용자가 즉시 사라지는 것은 아님
blk_mq_freeze_queue_wait()참조 0까지 대기quiesce flag 설정이나 완료 callback과 동일하지 않음

불변 조건과 실패 사례

queue 참조

cached request는 기존 사용 참조를 보유한다. 새 request 경로의 bio_queue_enter()와 중복해 세지 않는다.

tag와 issue

tag 확보는 request 준비 단계다. scheduler tag 여부와 driver issue, 완료를 분리한다.

freeze와 quiesce

freeze 첫 깊이는 신규 queue 참조를 차단하고 별도 wait로 기존 참조를 drain한다. quiesce는 dispatch 선택에 영향을 준다.

버전별 run

v6.18.37은 첫 need_run 판단이 거짓이면 queue_lock 아래에서 재검사해 unquiesce와의 경합을 다룬다.

계측과 검증

공유 tracefs 설정을 바꾸지 않고 현재 장치 통계와 queue 구성을 먼저 읽는다. block_rq_issue/block_rq_complete 이벤트가 보이더라도 그것만으로 tag 대기 시간, freeze depth 또는 병합되지 않은 bio 전체를 역산할 수 없다. 내부 함수 순서는 고정 소스와 대조해야 한다.

읽기 전용 관찰확인 가능한 것한계
cat /proc/diskstats장치별 누적 I/O·시간 카운터bio 병합·tag 획득·freeze depth를 분리 못함
cat /sys/block/<dev>/queue/scheduler현재 scheduler 선택개별 request의 scheduler 진입을 증명하지 않음
ls /sys/block/<dev>/mq/노출된 hardware queue 디렉터리run 호출 횟수나 dispatch 성공 횟수 아님
ls /sys/kernel/tracing/events/block/tracepoint 존재 여부공유 계측 설정을 바꾸지 않음
읽기 전용 예:
cat /proc/diskstats
cat /sys/block/<dev>/queue/scheduler
ls /sys/block/<dev>/mq/

추가 확인 사항

  • 이 bio는 기존 request에 병합되었는가, cached request를 썼는가, 새 tag를 얻었는가?
  • scheduler tag 조건과 flush/passthrough 예외는 어느 분기에서 갈리는가?
  • blk_mq_run_hw_queue()의 반환은 pending 없음, quiesce, 지연 예약 중 어느 상태인가?
  • freeze depth가 처음 1이 된 시점과 q_usage_counter가 0이 된 시점은 언제인가?
  • 제출 오류와 driver가 알린 blk_status_t를 어떻게 구분할 수 있는가?