block层：5. 请求分配

已于 2023-08-31 10:57:01 修改
阅读量285 收藏
点赞数
分类专栏： Kernel 文章标签： linux kernel block mq
于 2023-08-26 11:26:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jakelylll/article/details/132509460
版权

Kernel源码笔记目录

block层：1. 提交io
block层：2. mq提交io
block层：3. plug机制
block层：4. 运行队列
block层：5. 请求分配
block层：6. tag机制
block层：7. 请求下发
block层：8. deadline调度器

请求相关

源码基于5.10

1. 分配请求

static struct request *__blk_mq_alloc_request(struct blk_mq_alloc_data *data)
{
	// 请求队列
	struct request_queue *q = data->q;
	// 电梯
	struct elevator_queue *e = q->elevator;
	u64 alloc_time_ns = 0;
	unsigned int tag;

	// 判断有无QUEUE_FLAG_RQ_ALLOC_TIME标志
	// 有的话记录分配的时间
	if (blk_queue_rq_alloc_time(q))
		alloc_time_ns = ktime_get_ns();

	// 不等待
	if (data->cmd_flags & REQ_NOWAIT)
		data->flags |= BLK_MQ_REQ_NOWAIT;

	// 有电梯
	if (e) {
		// 非刷新请求 && 调度器有limit_depth && 使用保留tag, 则调用调度器的限制队列深度的方法
		if (!op_is_flush(data->cmd_flags) &&
		    e->type->ops.limit_depth &&
		    !(data->flags & BLK_MQ_REQ_RESERVED))
			e->type->ops.limit_depth(data->cmd_flags, data);
	}

retry:
	// 获取ctx
	data->ctx = blk_mq_get_ctx(q);
	// 根据不同的请求返回hctx
	data->hctx = blk_mq_map_queue(q, data->cmd_flags, data->ctx);
	// 没有调度器，则给hctx->state标记 BLK_MQ_S_TAG_ACTIVE
	if (!e)
		blk_mq_tag_busy(data->hctx);

	// 获取一个tag
	tag = blk_mq_get_tag(data);

	// 没tag了
	if (tag == BLK_MQ_NO_TAG) {

		// 不等待，直接返回NULL
		if (data->flags & BLK_MQ_REQ_NOWAIT)
			return NULL;

		// 睡3秒再重试
		msleep(3);
		goto retry;
	}
	// 初始化tag对应的请求
	return blk_mq_rq_ctx_init(data, tag, alloc_time_ns);
}

static struct request *blk_mq_rq_ctx_init(struct blk_mq_alloc_data *data,
		unsigned int tag, u64 alloc_time_ns)
{
	// 获取data里的tags
	struct blk_mq_tags *tags = blk_mq_tags_from_data(data);
	// 取tag的静态请求
	struct request *rq = tags->static_rqs[tag];

	// 根据是否有电梯在不同的字段记录tag
	// todo: 有电梯时为啥要在internal_tag里记录
	if (data->q->elevator) {
		rq->tag = BLK_MQ_NO_TAG;
		rq->internal_tag = tag;
	} else {
		rq->tag = tag;
		rq->internal_tag = BLK_MQ_NO_TAG;
	}

	// 请求队列
	rq->q = data->q;
	// 软件队列
	rq->mq_ctx = data->ctx;
	// 硬件队列
	rq->mq_hctx = data->hctx;
	rq->rq_flags = 0;
	// 命令标志
	rq->cmd_flags = data->cmd_flags;
	// 运行时电源管理请求？
	if (data->flags & BLK_MQ_REQ_PM)
		rq->rq_flags |= RQF_PM;
	// 有io统计需要
	if (blk_queue_io_stat(data->q))
		rq->rq_flags |= RQF_IO_STAT;
	// 一些初始化
	INIT_LIST_HEAD(&rq->queuelist);
	INIT_HLIST_NODE(&rq->hash);
	RB_CLEAR_NODE(&rq->rb_node);
	rq->rq_disk = NULL;
	rq->part = NULL;
#ifdef CONFIG_BLK_RQ_ALLOC_TIME
	// 开始分配请求时的时间戳
	rq->alloc_time_ns = alloc_time_ns;
#endif
	// 需要记录请求开始时时间戳
	if (blk_mq_need_time_stamp(rq))
		rq->start_time_ns = ktime_get_ns();
	else
		rq->start_time_ns = 0;

	rq->io_start_time_ns = 0;
	rq->stats_sectors = 0;
	rq->nr_phys_segments = 0;
#if defined(CONFIG_BLK_DEV_INTEGRITY)
	rq->nr_integrity_segments = 0;
#endif
	// 加密
	blk_crypto_rq_set_defaults(rq);
	// deadline设置为0
	WRITE_ONCE(rq->deadline, 0);

	rq->timeout = 0;

	rq->end_io = NULL;
	rq->end_io_data = NULL;

	// ctx里请求派发的计数
	data->ctx->rq_dispatched[op_is_sync(data->cmd_flags)]++;
	// 引用置1
	refcount_set(&rq->ref, 1);

	// 如果不是刷新请求
	if (!op_is_flush(data->cmd_flags)) {
		struct elevator_queue *e = data->q->elevator;

		rq->elv.icq = NULL;
		// 如果电梯有prepare_request，则调用之
		if (e && e->type->ops.prepare_request) {
			// 如果有icq缓存,则创建icq
			if (e->type->icq_cache)
				blk_mq_sched_assign_ioc(rq);

			// 调度器的准备请求方法
			e->type->ops.prepare_request(rq);
			// rq有调度器的私有数据
			rq->rq_flags |= RQF_ELVPRIV;
		}
	}

	// 已入队的请求数加1
	data->hctx->queued++;
	return rq;
}

static inline bool blk_mq_need_time_stamp(struct request *rq)
{
	// 有统计需要 || 有调度器
	return (rq->rq_flags & (RQF_IO_STAT | RQF_STATS)) || rq->q->elevator;
}

request_to_qc_t

static inline blk_qc_t request_to_qc_t(struct blk_mq_hw_ctx *hctx,
		struct request *rq)
{
	// queue_num是队列编号
	// BLK_QC_T_SHIFT是16
	// 无调度器时rq->tag != -1，用低16位存tag，高16位存队列数量
	if (rq->tag != -1)
		return rq->tag | (hctx->queue_num << BLK_QC_T_SHIFT);

	// BLK_QC_T_INTERNAL = (1U << 31)，
	// 有调度器时tag保存在internal_tag里，和上面类似，低16位存tag，高16位存队列数量，
	// 在第32位保存internal的标志
	return rq->internal_tag | (hctx->queue_num << BLK_QC_T_SHIFT) |
			BLK_QC_T_INTERNAL;
}

把bio转换成请求

static void blk_mq_bio_to_request(struct request *rq, struct bio *bio,
		unsigned int nr_segs)
{
	int err;

	// 如果是预读的话，加上快速失败标志
	if (bio->bi_opf & REQ_RAHEAD)
		rq->cmd_flags |= REQ_FAILFAST_MASK;

	// 请求扇区的起点设置为bio的扇区起点
	rq->__sector = bio->bi_iter.bi_sector;
	// todo: what?
	rq->write_hint = bio->bi_write_hint;

	// 把bio里的一些读写信息写到请求里
	blk_rq_bio_prep(rq, bio, nr_segs);

	// todo: 加密相关后面再看
	err = blk_crypto_rq_bio_prep(rq, bio, GFP_NOIO);
	WARN_ON_ONCE(err);

	// 统计相关
	blk_account_io_start(rq);
}

static inline void blk_rq_bio_prep(struct request *rq, struct bio *bio,
		unsigned int nr_segs)
{
	// 段数
	rq->nr_phys_segments = nr_segs;
	// 请求的数据长度
	rq->__data_len = bio->bi_iter.bi_size;
	// 请求的头、尾bio都指向这个bio
	rq->bio = rq->biotail = bio;
	// 设置io优先级？
	rq->ioprio = bio_prio(bio);

	// 设置请求的磁盘
	if (bio->bi_disk)
		rq->rq_disk = bio->bi_disk;
}

void blk_account_io_start(struct request *rq)
{
	// 没有统计io的需要直接返回
	if (!blk_do_io_stat(rq))
		return;

	// 把扇区转换成对应的分区
	rq->part = disk_map_sector_rcu(rq->rq_disk, blk_rq_pos(rq));

	part_stat_lock();
	update_io_ticks(rq->part, jiffies, false);
	part_stat_unlock();
}

static inline bool blk_do_io_stat(struct request *rq)
{
	return rq->rq_disk && (rq->rq_flags & RQF_IO_STAT);
}

static void update_io_ticks(struct hd_struct *part, unsigned long now, bool end)
{
	unsigned long stamp;
again:
	// 分区时间戳
	stamp = READ_ONCE(part->stamp);

	// 更新分区时间戳
	if (unlikely(stamp != now)) {
		if (likely(cmpxchg(&part->stamp, stamp, now) == stamp))
			__part_stat_add(part, io_ticks, end ? now - stamp : 1);
	}
	// 更新0号分区时间戳
	if (part->partno) {
		part = &part_to_disk(part)->part0;
		goto again;
	}
}

插入请求

插入请求是给调度器或者ctx里插入

插入刷新请求

void blk_insert_flush(struct request *rq)
{
	struct request_queue *q = rq->q;
	// 队列标志
	unsigned long fflags = q->queue_flags;
	// 刷新策略
	unsigned int policy = blk_flush_policy(fflags, rq);
	// 获取hctx对应的flush_queue
	struct blk_flush_queue *fq = blk_get_flush_queue(q, rq->mq_ctx);

	// 清除REQ_PREFLUSH和REQ_FUA标志,因为policy里已经记录了
	rq->cmd_flags &= ~REQ_PREFLUSH;
	if (!(fflags & (1UL << QUEUE_FLAG_FUA)))
		rq->cmd_flags &= ~REQ_FUA;

	// 刷新请求是同步的
	rq->cmd_flags |= REQ_SYNC;

	// 没有策略的直接结束请求
	if (!policy) {
		blk_mq_end_request(rq, 0);
		return;
	}

	// 没有bio或者只能有一个
	BUG_ON(rq->bio != rq->biotail);

	// 如果有数据，没有刷新需求。这个请求就可以直接处理不用经过刷新机制。
	if ((policy & REQ_FSEQ_DATA) &&
	    !(policy & (REQ_FSEQ_PREFLUSH | REQ_FSEQ_POSTFLUSH))) {
		// 绕过插入
		blk_mq_request_bypass_insert(rq, false, false);
		return;
	}

	/*
	 * @rq should go through flush machinery.  Mark it part of flush
	 * sequence and submit for further processing.
	 */
	// 初始化请求的刷新对象
	memset(&rq->flush, 0, sizeof(rq->flush));
	INIT_LIST_HEAD(&rq->flush.list);
	// 顺序刷新？
	rq->rq_flags |= RQF_FLUSH_SEQ;
	// 保存endio
	rq->flush.saved_end_io = rq->end_io;

	// 设置flush的回调
	rq->end_io = mq_flush_data_end_io;

	spin_lock_irq(&fq->mq_flush_lock);

	// 刷出请求, REQ_FSEQ_ACTIONS = REQ_FSEQ_PREFLUSH | REQ_FSEQ_DATA | REQ_FSEQ_POSTFLUSH
	blk_flush_complete_seq(rq, fq, REQ_FSEQ_ACTIONS & ~policy, 0);
	spin_unlock_irq(&fq->mq_flush_lock);
}

static unsigned int blk_flush_policy(unsigned long fflags, struct request *rq)
{
	unsigned int policy = 0;

	// 请求里有数据，这个获取的是数据长度对应的扇区数
	if (blk_rq_sectors(rq))
		policy |= REQ_FSEQ_DATA;

	// 如果有writeback caching
	if (fflags & (1UL << QUEUE_FLAG_WC)) {
		// 预刷新？
		if (rq->cmd_flags & REQ_PREFLUSH)
			policy |= REQ_FSEQ_PREFLUSH;
		
		// flag没有fua, 但是cmd有fua
		if (!(fflags & (1UL << QUEUE_FLAG_FUA)) &&
		    (rq->cmd_flags & REQ_FUA))
			policy |= REQ_FSEQ_POSTFLUSH;
	}
	return policy;
}
static void blk_flush_complete_seq(struct request *rq,
				   struct blk_flush_queue *fq,
				   unsigned int seq, blk_status_t error)
{
	struct request_queue *q = rq->q;
	struct list_head *pending = &fq->flush_queue[fq->flush_pending_idx];
	unsigned int cmd_flags;

	BUG_ON(rq->flush.seq & seq);
	// 设置seq?
	rq->flush.seq |= seq;
	// 命令标志
	cmd_flags = rq->cmd_flags;

	if (likely(!error))
		// 计算rq的顺序
		seq = blk_flush_cur_seq(rq);
	else
		seq = REQ_FSEQ_DONE;

	switch (seq) {
	case REQ_FSEQ_PREFLUSH:
	case REQ_FSEQ_POSTFLUSH:
		// 预刷出或已经刷出

		// 如果pending是空的，则记录pending时间
		if (list_empty(pending))
			fq->flush_pending_since = jiffies;
		// 把rq移到pending末尾
		list_move_tail(&rq->flush.list, pending);
		break;

	case REQ_FSEQ_DATA:
		// 有数据刷出

		// 把rq移到 flush_data_in_flight 队列
		list_move_tail(&rq->flush.list, &fq->flush_data_in_flight);

		// 添加到运行队列里
		blk_flush_queue_rq(rq, true);
		break;

	case REQ_FSEQ_DONE:
		// 请求已经执行完了
		BUG_ON(!list_empty(&rq->queuelist));

		// 从flush里删除
		list_del_init(&rq->flush.list);
		// 先还原成正常请求之前的数据
		blk_flush_restore_request(rq);

		// 结束请求
		blk_mq_end_request(rq, error);
		break;

	default:
		BUG();
	}
	
	// 刷出请求
	blk_kick_flush(q, fq, cmd_flags);
}

static unsigned int blk_flush_cur_seq(struct request *rq)
{
	// ffz是找第一个0的位置
	return 1 << ffz(rq->flush.seq);
}

static void blk_flush_queue_rq(struct request *rq, bool add_front)
{
	// 添加到队列里
	blk_mq_add_to_requeue_list(rq, add_front, true);
}

void blk_mq_add_to_requeue_list(struct request *rq, bool at_head,
				bool kick_requeue_list)
{
	struct request_queue *q = rq->q;
	unsigned long flags;

	// 不能有这个标志
	BUG_ON(rq->rq_flags & RQF_SOFTBARRIER);

	spin_lock_irqsave(&q->requeue_lock, flags);
	if (at_head) {
		// 添加在头部，设置这个标志，这个标志是:io调度器可能无法传递
		rq->rq_flags |= RQF_SOFTBARRIER;
		// 加到队列前面
		list_add(&rq->queuelist, &q->requeue_list);
	} else {
		// 加到队列末尾
		list_add_tail(&rq->queuelist, &q->requeue_list);
	}
	spin_unlock_irqrestore(&q->requeue_lock, flags);

	// 如果需要唤醒队列，则唤醒之
	if (kick_requeue_list)
		blk_mq_kick_requeue_list(q);
}

void blk_mq_kick_requeue_list(struct request_queue *q)
{
	// 运行kblockd_workqueue。第1个参数是指定cpu，最后一个参数是延迟时间
	// 延迟为0表示立即开始
	kblockd_mod_delayed_work_on(WORK_CPU_UNBOUND, &q->requeue_work, 0);
}

static void blk_flush_restore_request(struct request *rq)
{
	// 刷新完bio是NULL，我们应该还原它
	rq->bio = rq->biotail;

	// 去除刷出请求
	rq->rq_flags &= ~RQF_FLUSH_SEQ;
	// 还原之前的回调函数
	rq->end_io = rq->flush.saved_end_io;
}

static void blk_kick_flush(struct request_queue *q, struct blk_flush_queue *fq,
			   unsigned int flags)
{
	// 待刷出请求队列？
	struct list_head *pending = &fq->flush_queue[fq->flush_pending_idx];
	// 第1个请求
	struct request *first_rq =
		list_first_entry(pending, struct request, flush.list);
	struct request *flush_rq = fq->flush_rq;

	// 同时只能有一个运行或者待刷出队列是空的
	if (fq->flush_pending_idx != fq->flush_running_idx || list_empty(pending))
		return;

	// 有正在运行的，并且没有超过5秒
	if (!list_empty(&fq->flush_data_in_flight) &&
	    time_before(jiffies,
	    		// FLUSH_PENDING_TIMEOUT是5秒
			fq->flush_pending_since + FLUSH_PENDING_TIMEOUT))
		return;

	// 切换pending_idx
	fq->flush_pending_idx ^= 1;

	// 初始化flush_rq请求
	blk_rq_init(q, flush_rq);

	// 使用第1个请求的上下文
	flush_rq->mq_ctx = first_rq->mq_ctx;
	flush_rq->mq_hctx = first_rq->mq_hctx;

	if (!q->elevator) {
		// 没有调度器
		flush_rq->tag = first_rq->tag;

		/*
		 * 这个标记防止多次统计
		 */
		flush_rq->rq_flags |= RQF_MQ_INFLIGHT;
	} else
		// 有调度器
		flush_rq->internal_tag = first_rq->internal_tag;

	// REQ_OP_FLUSH：刷出易失缓存
	flush_rq->cmd_flags = REQ_OP_FLUSH | REQ_PREFLUSH;
	// REQ_DRV：需要驱动？ REQ_FAILFAST_MASK： 快速结束
	flush_rq->cmd_flags |= (flags & REQ_DRV) | (flags & REQ_FAILFAST_MASK);
	// 顺序刷出
	flush_rq->rq_flags |= RQF_FLUSH_SEQ;
	// 磁盘
	flush_rq->rq_disk = first_rq->rq_disk;
	// 结束回调
	flush_rq->end_io = flush_end_io;
	
	smp_wmb();
	// 设引用为1
	refcount_set(&flush_rq->ref, 1);

	// 刷出，把请求添加列队列里
	blk_flush_queue_rq(flush_rq, false);
}

void blk_rq_init(struct request_queue *q, struct request *rq)
{
	memset(rq, 0, sizeof(*rq));

	INIT_LIST_HEAD(&rq->queuelist);
	// 设置队列
	rq->q = q;
	rq->__sector = (sector_t) -1;
	INIT_HLIST_NODE(&rq->hash);
	RB_CLEAR_NODE(&rq->rb_node);
	// 没有tag
	rq->tag = BLK_MQ_NO_TAG;
	rq->internal_tag = BLK_MQ_NO_TAG;
	// 开始时间
	rq->start_time_ns = ktime_get_ns();

	rq->part = NULL;
	// 加密
	blk_crypto_rq_set_defaults(rq);
}

批量插入

这个函数主要在flush_plug时调用,它会把plug里的请求,按hctx排序来按hctx刷出.

void blk_mq_sched_insert_requests(struct blk_mq_hw_ctx *hctx,
				  struct blk_mq_ctx *ctx,
				  struct list_head *list, bool run_queue_async)
{
	struct elevator_queue *e;
	struct request_queue *q = hctx->queue;

	// 增加引用计数，怕在使用期间队列被释放了
	percpu_ref_get(&q->q_usage_counter);

	// 获取调度器
	e = hctx->queue->elevator;
	if (e && e->type->ops.insert_requests)
		// 有电梯 && 有插入请求函数，则调用之
		e->type->ops.insert_requests(hctx, list, false);
	else {
		// 没有调度器或者调度器没有insert函数的话就调用通用函数
	
		// 队列不忙 && 没有电梯 && 不是异步,直接发布
		// 这样能给软队列节省一个入队或出队请求
		if (!hctx->dispatch_busy && !e && !run_queue_async) {
			// 直接发布请求
			blk_mq_try_issue_list_directly(hctx, list);
			// 链表空了，则退出
			if (list_empty(list))
				goto out;
		}
		// 把list里剩余的元素插入队列
		blk_mq_insert_requests(hctx, ctx, list);
	}

	// 运行队列
	blk_mq_run_hw_queue(hctx, run_queue_async);
 out:
	// 减少引用
	percpu_ref_put(&q->q_usage_counter);
}

void blk_mq_insert_requests(struct blk_mq_hw_ctx *hctx, struct blk_mq_ctx *ctx,
			    struct list_head *list)

{
	struct request *rq;
	enum hctx_type type = hctx->type;

	// 这个打印插入的trace
	list_for_each_entry(rq, list, queuelist) {
		// 原注释：抢占不会刷新列表头，所以ctx->cpu可能已经下线？
		BUG_ON(rq->mq_ctx != ctx);
		trace_block_rq_insert(hctx->queue, rq);
	}

	spin_lock(&ctx->lock);
	// 把list添加到软队列的末尾
	list_splice_tail_init(list, &ctx->rq_lists[type]);
	// 标记软队列有准备提交的请求
	blk_mq_hctx_mark_pending(hctx, ctx);
	spin_unlock(&ctx->lock);
}

static void blk_mq_hctx_mark_pending(struct blk_mq_hw_ctx *hctx,
				     struct blk_mq_ctx *ctx)
{
	const int bit = ctx->index_hw[hctx->type];

	// 标记软位图，这个标记之后就表示有准备提交的请求
	if (!sbitmap_test_bit(&hctx->ctx_map, bit))
		sbitmap_set_bit(&hctx->ctx_map, bit);
}

批量插入的主要流程很简单：

  1. 把list里的请求全部加到软队列里
  2. 标记软队列对应hctx的位图，表示这个软队列有请求需要提交
  3. 运行队列

调度器插入请求

void blk_mq_sched_insert_request(struct request *rq, bool at_head,
				 bool run_queue, bool async)
{
	struct request_queue *q = rq->q;
	struct elevator_queue *e = q->elevator;
	struct blk_mq_ctx *ctx = rq->mq_ctx;
	struct blk_mq_hw_ctx *hctx = rq->mq_hctx;

	// 有调度器时，rq->tag应该为空，tag在internal_tag里保存
	WARN_ON(e && (rq->tag != BLK_MQ_NO_TAG));

	// 判断是否要绕过插入直接发布, bypass的条件是flush或passthrough请求
	if (blk_mq_sched_bypass_insert(hctx, !!e, rq)) {
		// 如果是刷新请求则放到队头
		at_head = (rq->rq_flags & RQF_FLUSH_SEQ) ? true : at_head;
		// 直接插入到hctx的派发队列里，最后一个参数表示是否运行队列
		blk_mq_request_bypass_insert(rq, at_head, false);
		goto run;
	}

	// 如果没有直接发布就加到软队列里
	if (e && e->type->ops.insert_requests) {
		// 有调度器 && 有insert_requests方法，则调用之
		LIST_HEAD(list);

		list_add(&rq->queuelist, &list);
		e->type->ops.insert_requests(hctx, &list, at_head);
	} else {
		// 否则调用通用方法插入请求
		spin_lock(&ctx->lock);
		// 这个会把请求插到软队列里
		__blk_mq_insert_request(hctx, rq, at_head);
		spin_unlock(&ctx->lock);
	}

run:
	// 若需运行，则执行请求
	if (run_queue)
		blk_mq_run_hw_queue(hctx, async);
}
直接发布
static bool blk_mq_sched_bypass_insert(struct blk_mq_hw_ctx *hctx,
				       bool has_sched,
				       struct request *rq)
{
	// RQF_FLUSH_SEQ是顺序刷出
	// blk_rq_is_passthrough判断是否是REQ_OP_SCSI_IN/OUT，REQ_OP_DRV_IN/OUT这4种之一的请求
	// 这2种情况绕过插入，直接发出请求
	if ((rq->rq_flags & RQF_FLUSH_SEQ) || blk_rq_is_passthrough(rq))
		return true;

	// 有调度器，则需要排序
	if (has_sched)
		rq->rq_flags |= RQF_SORTED;

	return false;
}

void blk_mq_request_bypass_insert(struct request *rq, bool at_head,
				  bool run_queue)
{
	struct blk_mq_hw_ctx *hctx = rq->mq_hctx;

	spin_lock(&hctx->lock);

	// 添加到硬件队列的派发队列,
	// 加到dispatch队列后，在运行队列时，会优先处理
	if (at_head)
		list_add(&rq->queuelist, &hctx->dispatch);
	else
		list_add_tail(&rq->queuelist, &hctx->dispatch);
	spin_unlock(&hctx->lock);

	// 如需运行硬件队列，则运行之
	if (run_queue)
		blk_mq_run_hw_queue(hctx, false);
}
插入软队列
void __blk_mq_insert_request(struct blk_mq_hw_ctx *hctx, struct request *rq,
			     bool at_head)
{
	struct blk_mq_ctx *ctx = rq->mq_ctx;

	lockdep_assert_held(&ctx->lock);

	// 把请求插到队列里
	__blk_mq_insert_req_list(hctx, rq, at_head);
	// 标记hctx有待处理的请求
	blk_mq_hctx_mark_pending(hctx, ctx);
}

static inline void __blk_mq_insert_req_list(struct blk_mq_hw_ctx *hctx,
					    struct request *rq,
					    bool at_head)
{
	struct blk_mq_ctx *ctx = rq->mq_ctx;
	enum hctx_type type = hctx->type;

	lockdep_assert_held(&ctx->lock);

	trace_block_rq_insert(hctx->queue, rq);

	// 根据at_head的值，加到软队列头或者队列尾
	if (at_head)
		list_add(&rq->queuelist, &ctx->rq_lists[type]);
	else
		list_add_tail(&rq->queuelist, &ctx->rq_lists[type]);
}
苟浩
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
5.C++内存池、内存分配
107
03-16 9588
C++重要语言基础1.语言基础1.1空间的配置与释放--std:alloc(SGI实现)1.2内存池 1.语言基础 1.1空间的配置与释放–std:alloc(SGI实现) SGI标准模版库： 设计时需要考虑的问题： 从堆区申请内存空间； 考虑多线程； 考虑内存不足时的应对措施； 考虑大量小区块可能造成的内存碎片问题； SGI的alloc类是使用了双层配置器：分别处理大内存请求和小内存请...
关于mysql出现java.sql.SQLException错误！
weixin_34033624的博客
10-24 4550
2019独角兽企业重金招聘Python工程师标准>>> ...
Android驱动开发知识储备（纯手打，更新：2018.4.11）
z979451341的博客
03-29 5665
Android软件层次结构（1）操作系统层显示驱动（Frame Buffer），Flash内存驱动，照相机驱动，音频驱动，WiFi驱动，键盘驱动，蓝牙驱动，Binder IPC驱动，Power Management  ,这些都包括在Linux内核里。（2）各种库和Android运行环境C库、多媒体框架、SGL（2D图像引擎），SSL（安全），OpenGL ES（3D），界面管理工具，SQLite，...
BLOCK层代码分析（7）IO下发之request的分配和获取
flyingnosky的专栏
11-23 2427
前面已经介绍下发过程中的bounce操作，BIO的切分和合并操作，若bio仍存在，那么会将当前的bio生成新的request，最终将request下发。但实际上并不是在下发过程中分配request的，request是提前分配好的（称为静态reqeust），在下发过程中直接从sbitmaps中获取空闲的tag，最终得到tag所对应的request。 BLOCK层的每个tag对应一个request，两者是一一对应的关系。而tag的分配和释放是由sbitmap管理的。因此首先简单...
linux内核block层Multi queue多队列核心点分析
dongzhiyan_hjp
12-21 9499
内核块设备层单队列时代，我们IO传输的底层函数是一切从submit_bio开始 submit_bio->generic_make_request-> blk_queue_bio。如果看多相关源码，会发现经常用到q->queue_lock自旋锁，在IO发送过程、IO传输完成、IO合并都有。多核多进程IO传输时，会在q->queue_lock锁上自旋等待浪费不少时间，内核引入Multi queue多队列架构应该就是为了解决这个问题。Multi queue多队列架构主要有两个数据结构:每个
BLOCK层代码分析（3）IO下发概述
flyingnosky的专栏
11-16 1930
对于每个线程，存在成员current->bio_list来放置本线程发送的BIO。这里有三条路径发送IO到底层： 路径一，使能了plug/unplug机制，此时会等待plug池中存取足够的IO后统一往调度器插入IO，并选取IO下发； 路径二，没有使能plug/unplug机制，此时会将IO插入调度器中，并选取IO下发； 路径三，跳过调度层，直接下发IO； 简单来讲，这里有三条链：current->bio_list存储在当前线程的所有bio; plug-...
内核block层Multi queue多队列的一次优化实践
dongzhiyan_hjp
11-01 2457
熟悉block层多队列、nvme的小伙伴应该知道，nvme硬件多通道(或者称为多队列)的优势特别大。普通的ssd硬盘也只有一个通道进行IO数据传输，但是nvme却可以多个硬件队列同时IO读写，性能特别好。谈到这里想到一点，如果是单线程IO读写，只能发挥一个nvme硬件队列的优势，能不能发挥下nvme多个硬件队列的优势呢？ 1 nvme 硬件队列繁忙时也容易io wait 先介绍一个知识点，每个CPU都绑定一个唯一的nvme硬件队列，当然这些硬件队列可能会有重复的。我见过的一款性能不错的服务器，nv..
ANR问题简析
热门推荐
qzh123456的博客
12-07 1万+
ANR问题，相信是每位开发日常都会遇到的问题，对于这类问题的分析，按照官方的推荐，或网络博客的总结思路能解决一定的问题，但是多数时候大家的困惑就是应用本逻辑很简单，耗时很短或应用堆栈完全正常，或者或处于空闲状态，可系统为什么就认为接收者发生ANR了呢？下面将之前公司的一次内部分享开放出来，用几个实例从不同角度分析导致ANR产生的Root Case。也希望对大家以后分析该类问题有一定参考，不对的地方
2021web前端面试题总结，每天熟悉看两道，重在积累...持续更新中........
wanghe1111_的博客
09-28 1万+
2022前端面试题整理：文章目录Http、HTML、浏览器相关1. 说一下http和https2. tcp三次握手，一句话概括3. TCP和UDP的区别4. WebSocket的实现和应用5.HTTP请求的方式，HEAD方式6.web quality(无障碍)7. 几个很实用的BOM属性对象方法8.说一下HTML5 drag api9.说一下http2.010. 补充400和401、403状态码11. fetch发送2次请求的原因
内核block层IO调度器—bfq算法之1整体流程介绍
dongzhiyan_hjp
07-18 5625
内核block层bfq调度算法工作原理
block_io.rar_block driver
09-23
在Linux操作系统中，块I/O（Block I/O）是设备驱动程序与系统内存之间进行数据传输的一种机制，主要处理磁盘、SSD等存储设备的数据读写操作。"block_io.rar_block driver"这个标题暗示了我们正在讨论的是一个用于块...
LTE物理层总结.rar
12-28
物理层根据网络状况和用户需求动态分配资源，采用Turbo编码或LDPC（Low-Density Parity Check）编码提供错误保护。 7. **物理信道** 包括下行链路的PDCCH（Physical Downlink Control Channel）、PDSCH（Physical...
5G block编码和速率匹配.zip
05-29
其中，块编码（Block Coding）和速率匹配（Rate Matching）是5G物理层的关键技术，用于提高数据传输的可靠性和效率。在5G系统中，上行控制信息（UCI）扮演着至关重要的角色，它包含了用户设备（UE）向基站（eNodeB）...
Linux_block_driver.rar_Linux block device_Linux 块设备_linux drive
09-22
这些设备在操作系统中被抽象为块设备层，以便系统能够以一致的方式处理不同的存储媒介。本文将深入探讨Linux块设备驱动程序及其工作原理。 首先，我们要理解Linux内核中的块设备模型。在Linux中，块设备驱动程序是...
i2o_block.rar_V2
09-24
在Linux内核启动时，驱动会调用`i2o_block_init`函数进行初始化，这个过程包括设置设备列表、分配资源和注册设备。同时，`i2o_register_driver`函数用于将I2O Block驱动注册到内核的设备模型中，使得系统能够识别并...
【Linux】进程间通信（IPC）——匿名管道
2201_76024104的博客
07-08 1167
1.：一个进程需要将它的数据发送给另一个进程，比如我们有两个进程，一个负责获取数据，另一个负责处理数据，这时第一个进程就要将获取到的数据交给第二个进程2.：多个进程间共享同样的资源3.：一个进程需要给其他进程发送消息，通知他们发生了某种事件4.：有些事件需要完全控制另一个进程，比如我们在使用gdb调试时，gdb就是一个进程，它控制了我们要调试的进程进程之前是有互相传递信息的需求，但是，一个进程不可能去另一个进程的地址空间中取信息，所以这就要求操作系统去提供一块交换数据的空间来供进程之间使用。
【Linux】 GCC/G++与Makefile使用
Long_kin的博客
07-11 964
收藏向 使用解析
【Linux】：程序替换
Yikefore的博客
07-09 1094
程序替换的详细介绍以及各种程序替换接口介绍以及使用！
Linux —— 进程间通信
最新发布
学习C++的小陈同学
07-11 950
本篇整理了关于进程间通信的内容，以及详解的介绍了两种进程间通信的方式，以及相关的接口和代码演练

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值