blk-mq.h revision edf866b3805c5651bf7d035b72dc0190cb6ff4a7
1#ifndef BLK_MQ_H 2#define BLK_MQ_H 3 4#include <linux/blkdev.h> 5 6struct blk_mq_tags; 7 8struct blk_mq_cpu_notifier { 9 struct list_head list; 10 void *data; 11 int (*notify)(void *data, unsigned long action, unsigned int cpu); 12}; 13 14struct blk_mq_ctxmap { 15 unsigned int map_size; 16 unsigned int bits_per_word; 17 struct blk_align_bitmap *map; 18}; 19 20struct blk_mq_hw_ctx { 21 struct { 22 spinlock_t lock; 23 struct list_head dispatch; 24 } ____cacheline_aligned_in_smp; 25 26 unsigned long state; /* BLK_MQ_S_* flags */ 27 struct delayed_work run_work; 28 struct delayed_work delay_work; 29 cpumask_var_t cpumask; 30 int next_cpu; 31 int next_cpu_batch; 32 33 unsigned long flags; /* BLK_MQ_F_* flags */ 34 35 struct request_queue *queue; 36 unsigned int queue_num; 37 38 void *driver_data; 39 40 struct blk_mq_ctxmap ctx_map; 41 42 unsigned int nr_ctx; 43 struct blk_mq_ctx **ctxs; 44 45 unsigned int wait_index; 46 47 struct blk_mq_tags *tags; 48 49 unsigned long queued; 50 unsigned long run; 51#define BLK_MQ_MAX_DISPATCH_ORDER 10 52 unsigned long dispatched[BLK_MQ_MAX_DISPATCH_ORDER]; 53 54 unsigned int numa_node; 55 unsigned int cmd_size; /* per-request extra data */ 56 57 atomic_t nr_active; 58 59 struct blk_mq_cpu_notifier cpu_notifier; 60 struct kobject kobj; 61}; 62 63struct blk_mq_tag_set { 64 struct blk_mq_ops *ops; 65 unsigned int nr_hw_queues; 66 unsigned int queue_depth; /* max hw supported */ 67 unsigned int reserved_tags; 68 unsigned int cmd_size; /* per-request extra data */ 69 int numa_node; 70 unsigned int timeout; 71 unsigned int flags; /* BLK_MQ_F_* */ 72 void *driver_data; 73 74 struct blk_mq_tags **tags; 75 76 struct mutex tag_list_lock; 77 struct list_head tag_list; 78}; 79 80typedef int (queue_rq_fn)(struct blk_mq_hw_ctx *, struct request *); 81typedef struct blk_mq_hw_ctx *(map_queue_fn)(struct request_queue *, const int); 82typedef struct blk_mq_hw_ctx *(alloc_hctx_fn)(struct blk_mq_tag_set *, 83 unsigned int); 84typedef void (free_hctx_fn)(struct blk_mq_hw_ctx *, unsigned int); 85typedef int (init_hctx_fn)(struct blk_mq_hw_ctx *, void *, unsigned int); 86typedef void (exit_hctx_fn)(struct blk_mq_hw_ctx *, unsigned int); 87typedef int (init_request_fn)(void *, struct request *, unsigned int, 88 unsigned int, unsigned int); 89typedef void (exit_request_fn)(void *, struct request *, unsigned int, 90 unsigned int); 91 92struct blk_mq_ops { 93 /* 94 * Queue request 95 */ 96 queue_rq_fn *queue_rq; 97 98 /* 99 * Map to specific hardware queue 100 */ 101 map_queue_fn *map_queue; 102 103 /* 104 * Called on request timeout 105 */ 106 rq_timed_out_fn *timeout; 107 108 softirq_done_fn *complete; 109 110 /* 111 * Override for hctx allocations (should probably go) 112 */ 113 alloc_hctx_fn *alloc_hctx; 114 free_hctx_fn *free_hctx; 115 116 /* 117 * Called when the block layer side of a hardware queue has been 118 * set up, allowing the driver to allocate/init matching structures. 119 * Ditto for exit/teardown. 120 */ 121 init_hctx_fn *init_hctx; 122 exit_hctx_fn *exit_hctx; 123 124 /* 125 * Called for every command allocated by the block layer to allow 126 * the driver to set up driver specific data. 127 * Ditto for exit/teardown. 128 */ 129 init_request_fn *init_request; 130 exit_request_fn *exit_request; 131}; 132 133enum { 134 BLK_MQ_RQ_QUEUE_OK = 0, /* queued fine */ 135 BLK_MQ_RQ_QUEUE_BUSY = 1, /* requeue IO for later */ 136 BLK_MQ_RQ_QUEUE_ERROR = 2, /* end IO with error */ 137 138 BLK_MQ_F_SHOULD_MERGE = 1 << 0, 139 BLK_MQ_F_SHOULD_SORT = 1 << 1, 140 BLK_MQ_F_TAG_SHARED = 1 << 2, 141 142 BLK_MQ_S_STOPPED = 0, 143 BLK_MQ_S_TAG_ACTIVE = 1, 144 145 BLK_MQ_MAX_DEPTH = 2048, 146 147 BLK_MQ_CPU_WORK_BATCH = 8, 148}; 149 150struct request_queue *blk_mq_init_queue(struct blk_mq_tag_set *); 151int blk_mq_register_disk(struct gendisk *); 152void blk_mq_unregister_disk(struct gendisk *); 153 154int blk_mq_alloc_tag_set(struct blk_mq_tag_set *set); 155void blk_mq_free_tag_set(struct blk_mq_tag_set *set); 156 157void blk_mq_flush_plug_list(struct blk_plug *plug, bool from_schedule); 158 159void blk_mq_insert_request(struct request *, bool, bool, bool); 160void blk_mq_run_queues(struct request_queue *q, bool async); 161void blk_mq_free_request(struct request *rq); 162bool blk_mq_can_queue(struct blk_mq_hw_ctx *); 163struct request *blk_mq_alloc_request(struct request_queue *q, int rw, gfp_t gfp); 164struct request *blk_mq_alloc_reserved_request(struct request_queue *q, int rw, gfp_t gfp); 165struct request *blk_mq_tag_to_rq(struct blk_mq_tags *tags, unsigned int tag); 166 167struct blk_mq_hw_ctx *blk_mq_map_queue(struct request_queue *, const int ctx_index); 168struct blk_mq_hw_ctx *blk_mq_alloc_single_hw_queue(struct blk_mq_tag_set *, unsigned int); 169void blk_mq_free_single_hw_queue(struct blk_mq_hw_ctx *, unsigned int); 170 171void blk_mq_end_io(struct request *rq, int error); 172void __blk_mq_end_io(struct request *rq, int error); 173 174void blk_mq_requeue_request(struct request *rq); 175 176void blk_mq_complete_request(struct request *rq); 177 178void blk_mq_stop_hw_queue(struct blk_mq_hw_ctx *hctx); 179void blk_mq_start_hw_queue(struct blk_mq_hw_ctx *hctx); 180void blk_mq_stop_hw_queues(struct request_queue *q); 181void blk_mq_start_hw_queues(struct request_queue *q); 182void blk_mq_start_stopped_hw_queues(struct request_queue *q, bool async); 183void blk_mq_delay_queue(struct blk_mq_hw_ctx *hctx, unsigned long msecs); 184void blk_mq_tag_busy_iter(struct blk_mq_tags *tags, void (*fn)(void *data, unsigned long *), void *data); 185 186/* 187 * Driver command data is immediately after the request. So subtract request 188 * size to get back to the original request. 189 */ 190static inline struct request *blk_mq_rq_from_pdu(void *pdu) 191{ 192 return pdu - sizeof(struct request); 193} 194static inline void *blk_mq_rq_to_pdu(struct request *rq) 195{ 196 return (void *) rq + sizeof(*rq); 197} 198 199#define queue_for_each_hw_ctx(q, hctx, i) \ 200 for ((i) = 0; (i) < (q)->nr_hw_queues && \ 201 ({ hctx = (q)->queue_hw_ctx[i]; 1; }); (i)++) 202 203#define queue_for_each_ctx(q, ctx, i) \ 204 for ((i) = 0; (i) < (q)->nr_queues && \ 205 ({ ctx = per_cpu_ptr((q)->queue_ctx, (i)); 1; }); (i)++) 206 207#define hctx_for_each_ctx(hctx, ctx, i) \ 208 for ((i) = 0; (i) < (hctx)->nr_ctx && \ 209 ({ ctx = (hctx)->ctxs[(i)]; 1; }); (i)++) 210 211#define blk_ctx_sum(q, sum) \ 212({ \ 213 struct blk_mq_ctx *__x; \ 214 unsigned int __ret = 0, __i; \ 215 \ 216 queue_for_each_ctx((q), __x, __i) \ 217 __ret += sum; \ 218 __ret; \ 219}) 220 221#endif 222