blk-mq.h 6.3 KB
Newer Older
1
/* SPDX-License-Identifier: GPL-2.0 */
2 3 4
#ifndef INT_BLK_MQ_H
#define INT_BLK_MQ_H

5
#include "blk-stat.h"
6
#include "blk-mq-tag.h"
7

8 9
struct blk_mq_tag_set;

10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
struct blk_mq_ctx {
	struct {
		spinlock_t		lock;
		struct list_head	rq_list;
	}  ____cacheline_aligned_in_smp;

	unsigned int		cpu;
	unsigned int		index_hw;

	/* incremented at dispatch time */
	unsigned long		rq_dispatched[2];
	unsigned long		rq_merged;

	/* incremented at completion time */
	unsigned long		____cacheline_aligned_in_smp rq_completed[2];

	struct request_queue	*queue;
	struct kobject		kobj;
28
} ____cacheline_aligned_in_smp;
29

30 31 32 33 34 35 36 37 38 39 40 41 42
/*
 * Bits for request->gstate.  The lower two bits carry MQ_RQ_* state value
 * and the upper bits the generation number.
 */
enum mq_rq_state {
	MQ_RQ_IDLE		= 0,
	MQ_RQ_IN_FLIGHT		= 1,

	MQ_RQ_STATE_BITS	= 2,
	MQ_RQ_STATE_MASK	= (1 << MQ_RQ_STATE_BITS) - 1,
	MQ_RQ_GEN_INC		= 1 << MQ_RQ_STATE_BITS,
};

43
void blk_mq_freeze_queue(struct request_queue *q);
44
void blk_mq_free_queue(struct request_queue *q);
45
int blk_mq_update_nr_requests(struct request_queue *q, unsigned int nr);
46
void blk_mq_wake_waiters(struct request_queue *q);
47
bool blk_mq_dispatch_rq_list(struct request_queue *, struct list_head *, bool);
48
void blk_mq_flush_busy_ctxs(struct blk_mq_hw_ctx *hctx, struct list_head *list);
49 50
bool blk_mq_get_driver_tag(struct request *rq, struct blk_mq_hw_ctx **hctx,
				bool wait);
51 52
struct request *blk_mq_dequeue_from_ctx(struct blk_mq_hw_ctx *hctx,
					struct blk_mq_ctx *start);
53 54 55 56

/*
 * Internal helpers for allocating/freeing the request map
 */
57 58 59 60 61 62 63 64 65
void blk_mq_free_rqs(struct blk_mq_tag_set *set, struct blk_mq_tags *tags,
		     unsigned int hctx_idx);
void blk_mq_free_rq_map(struct blk_mq_tags *tags);
struct blk_mq_tags *blk_mq_alloc_rq_map(struct blk_mq_tag_set *set,
					unsigned int hctx_idx,
					unsigned int nr_tags,
					unsigned int reserved_tags);
int blk_mq_alloc_rqs(struct blk_mq_tag_set *set, struct blk_mq_tags *tags,
		     unsigned int hctx_idx, unsigned int depth);
66 67 68 69 70 71

/*
 * Internal helpers for request insertion into sw queues
 */
void __blk_mq_insert_request(struct blk_mq_hw_ctx *hctx, struct request *rq,
				bool at_head);
72
void blk_mq_request_bypass_insert(struct request *rq, bool run_queue);
73 74
void blk_mq_insert_requests(struct blk_mq_hw_ctx *hctx, struct blk_mq_ctx *ctx,
				struct list_head *list);
75 76 77 78

/*
 * CPU -> queue mappings
 */
79
extern int blk_mq_hw_queue_to_node(unsigned int *map, unsigned int);
80

C
Christoph Hellwig 已提交
81 82 83 84 85 86
static inline struct blk_mq_hw_ctx *blk_mq_map_queue(struct request_queue *q,
		int cpu)
{
	return q->queue_hw_ctx[q->mq_map[cpu]];
}

87 88 89
/*
 * sysfs helpers
 */
90
extern void blk_mq_sysfs_init(struct request_queue *q);
91
extern void blk_mq_sysfs_deinit(struct request_queue *q);
92
extern int __blk_mq_register_dev(struct device *dev, struct request_queue *q);
93 94
extern int blk_mq_sysfs_register(struct request_queue *q);
extern void blk_mq_sysfs_unregister(struct request_queue *q);
K
Keith Busch 已提交
95
extern void blk_mq_hctx_kobj_init(struct blk_mq_hw_ctx *hctx);
96

97 98
void blk_mq_release(struct request_queue *q);

99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131
/**
 * blk_mq_rq_state() - read the current MQ_RQ_* state of a request
 * @rq: target request.
 */
static inline int blk_mq_rq_state(struct request *rq)
{
	return READ_ONCE(rq->gstate) & MQ_RQ_STATE_MASK;
}

/**
 * blk_mq_rq_update_state() - set the current MQ_RQ_* state of a request
 * @rq: target request.
 * @state: new state to set.
 *
 * Set @rq's state to @state.  The caller is responsible for ensuring that
 * there are no other updaters.  A request can transition into IN_FLIGHT
 * only from IDLE and doing so increments the generation number.
 */
static inline void blk_mq_rq_update_state(struct request *rq,
					  enum mq_rq_state state)
{
	u64 old_val = READ_ONCE(rq->gstate);
	u64 new_val = (old_val & ~MQ_RQ_STATE_MASK) | state;

	if (state == MQ_RQ_IN_FLIGHT) {
		WARN_ON_ONCE((old_val & MQ_RQ_STATE_MASK) != MQ_RQ_IDLE);
		new_val += MQ_RQ_GEN_INC;
	}

	/* avoid exposing interim values */
	WRITE_ONCE(rq->gstate, new_val);
}

132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153
static inline struct blk_mq_ctx *__blk_mq_get_ctx(struct request_queue *q,
					   unsigned int cpu)
{
	return per_cpu_ptr(q->queue_ctx, cpu);
}

/*
 * This assumes per-cpu software queueing queues. They could be per-node
 * as well, for instance. For now this is hardcoded as-is. Note that we don't
 * care about preemption, since we know the ctx's are persistent. This does
 * mean that we can't rely on ctx always matching the currently running CPU.
 */
static inline struct blk_mq_ctx *blk_mq_get_ctx(struct request_queue *q)
{
	return __blk_mq_get_ctx(q, get_cpu());
}

static inline void blk_mq_put_ctx(struct blk_mq_ctx *ctx)
{
	put_cpu();
}

154 155 156
struct blk_mq_alloc_data {
	/* input parameter */
	struct request_queue *q;
157
	blk_mq_req_flags_t flags;
158
	unsigned int shallow_depth;
159 160 161 162 163 164

	/* input & output parameter */
	struct blk_mq_ctx *ctx;
	struct blk_mq_hw_ctx *hctx;
};

165 166
static inline struct blk_mq_tags *blk_mq_tags_from_data(struct blk_mq_alloc_data *data)
{
167 168 169
	if (data->flags & BLK_MQ_REQ_INTERNAL)
		return data->hctx->sched_tags;

170 171 172
	return data->hctx->tags;
}

173 174 175 176 177
static inline bool blk_mq_hctx_stopped(struct blk_mq_hw_ctx *hctx)
{
	return test_bit(BLK_MQ_S_STOPPED, &hctx->state);
}

178 179 180 181 182
static inline bool blk_mq_hw_queue_mapped(struct blk_mq_hw_ctx *hctx)
{
	return hctx->nr_ctx && hctx->tags;
}

183 184 185
void blk_mq_in_flight(struct request_queue *q, struct hd_struct *part,
			unsigned int inflight[2]);

186 187 188 189 190 191 192 193
static inline void blk_mq_put_dispatch_budget(struct blk_mq_hw_ctx *hctx)
{
	struct request_queue *q = hctx->queue;

	if (q->mq_ops->put_budget)
		q->mq_ops->put_budget(hctx);
}

194
static inline bool blk_mq_get_dispatch_budget(struct blk_mq_hw_ctx *hctx)
195 196 197 198 199
{
	struct request_queue *q = hctx->queue;

	if (q->mq_ops->get_budget)
		return q->mq_ops->get_budget(hctx);
200
	return true;
201 202
}

203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234
static inline void __blk_mq_put_driver_tag(struct blk_mq_hw_ctx *hctx,
					   struct request *rq)
{
	blk_mq_put_tag(hctx, hctx->tags, rq->mq_ctx, rq->tag);
	rq->tag = -1;

	if (rq->rq_flags & RQF_MQ_INFLIGHT) {
		rq->rq_flags &= ~RQF_MQ_INFLIGHT;
		atomic_dec(&hctx->nr_active);
	}
}

static inline void blk_mq_put_driver_tag_hctx(struct blk_mq_hw_ctx *hctx,
				       struct request *rq)
{
	if (rq->tag == -1 || rq->internal_tag == -1)
		return;

	__blk_mq_put_driver_tag(hctx, rq);
}

static inline void blk_mq_put_driver_tag(struct request *rq)
{
	struct blk_mq_hw_ctx *hctx;

	if (rq->tag == -1 || rq->internal_tag == -1)
		return;

	hctx = blk_mq_map_queue(rq->q, rq->mq_ctx->cpu);
	__blk_mq_put_driver_tag(hctx, rq);
}

235
#endif