blk-mq.h revision e2490073cd7c3d6f6ef6e029a208edd4d38efac4
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 atomic_t 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 *, bool); 81typedef struct blk_mq_hw_ctx *(map_queue_fn)(struct request_queue *, const int); 82typedef int (init_hctx_fn)(struct blk_mq_hw_ctx *, void *, unsigned int); 83typedef void (exit_hctx_fn)(struct blk_mq_hw_ctx *, unsigned int); 84typedef int (init_request_fn)(void *, struct request *, unsigned int, 85 unsigned int, unsigned int); 86typedef void (exit_request_fn)(void *, struct request *, unsigned int, 87 unsigned int); 88 89struct blk_mq_ops { 90 /* 91 * Queue request 92 */ 93 queue_rq_fn *queue_rq; 94 95 /* 96 * Map to specific hardware queue 97 */ 98 map_queue_fn *map_queue; 99 100 /* 101 * Called on request timeout 102 */ 103 rq_timed_out_fn *timeout; 104 105 softirq_done_fn *complete; 106 107 /* 108 * Called when the block layer side of a hardware queue has been 109 * set up, allowing the driver to allocate/init matching structures. 110 * Ditto for exit/teardown. 111 */ 112 init_hctx_fn *init_hctx; 113 exit_hctx_fn *exit_hctx; 114 115 /* 116 * Called for every command allocated by the block layer to allow 117 * the driver to set up driver specific data. 118 * Ditto for exit/teardown. 119 */ 120 init_request_fn *init_request; 121 exit_request_fn *exit_request; 122}; 123 124enum { 125 BLK_MQ_RQ_QUEUE_OK = 0, /* queued fine */ 126 BLK_MQ_RQ_QUEUE_BUSY = 1, /* requeue IO for later */ 127 BLK_MQ_RQ_QUEUE_ERROR = 2, /* end IO with error */ 128 129 BLK_MQ_F_SHOULD_MERGE = 1 << 0, 130 BLK_MQ_F_TAG_SHARED = 1 << 1, 131 BLK_MQ_F_SG_MERGE = 1 << 2, 132 BLK_MQ_F_SYSFS_UP = 1 << 3, 133 134 BLK_MQ_S_STOPPED = 0, 135 BLK_MQ_S_TAG_ACTIVE = 1, 136 137 BLK_MQ_MAX_DEPTH = 10240, 138 139 BLK_MQ_CPU_WORK_BATCH = 8, 140}; 141 142struct request_queue *blk_mq_init_queue(struct blk_mq_tag_set *); 143int blk_mq_register_disk(struct gendisk *); 144void blk_mq_unregister_disk(struct gendisk *); 145 146int blk_mq_alloc_tag_set(struct blk_mq_tag_set *set); 147void blk_mq_free_tag_set(struct blk_mq_tag_set *set); 148 149void blk_mq_flush_plug_list(struct blk_plug *plug, bool from_schedule); 150 151void blk_mq_insert_request(struct request *, bool, bool, bool); 152void blk_mq_run_queues(struct request_queue *q, bool async); 153void blk_mq_free_request(struct request *rq); 154bool blk_mq_can_queue(struct blk_mq_hw_ctx *); 155struct request *blk_mq_alloc_request(struct request_queue *q, int rw, 156 gfp_t gfp, bool reserved); 157struct request *blk_mq_tag_to_rq(struct blk_mq_tags *tags, unsigned int tag); 158 159struct blk_mq_hw_ctx *blk_mq_map_queue(struct request_queue *, const int ctx_index); 160struct blk_mq_hw_ctx *blk_mq_alloc_single_hw_queue(struct blk_mq_tag_set *, unsigned int, int); 161 162void blk_mq_start_request(struct request *rq); 163void blk_mq_end_io(struct request *rq, int error); 164void __blk_mq_end_io(struct request *rq, int error); 165 166void blk_mq_requeue_request(struct request *rq); 167void blk_mq_add_to_requeue_list(struct request *rq, bool at_head); 168void blk_mq_kick_requeue_list(struct request_queue *q); 169void blk_mq_complete_request(struct request *rq); 170 171void blk_mq_stop_hw_queue(struct blk_mq_hw_ctx *hctx); 172void blk_mq_start_hw_queue(struct blk_mq_hw_ctx *hctx); 173void blk_mq_stop_hw_queues(struct request_queue *q); 174void blk_mq_start_hw_queues(struct request_queue *q); 175void blk_mq_start_stopped_hw_queues(struct request_queue *q, bool async); 176void blk_mq_delay_queue(struct blk_mq_hw_ctx *hctx, unsigned long msecs); 177void blk_mq_tag_busy_iter(struct blk_mq_tags *tags, void (*fn)(void *data, unsigned long *), void *data); 178 179/* 180 * Driver command data is immediately after the request. So subtract request 181 * size to get back to the original request. 182 */ 183static inline struct request *blk_mq_rq_from_pdu(void *pdu) 184{ 185 return pdu - sizeof(struct request); 186} 187static inline void *blk_mq_rq_to_pdu(struct request *rq) 188{ 189 return (void *) rq + sizeof(*rq); 190} 191 192#define queue_for_each_hw_ctx(q, hctx, i) \ 193 for ((i) = 0; (i) < (q)->nr_hw_queues && \ 194 ({ hctx = (q)->queue_hw_ctx[i]; 1; }); (i)++) 195 196#define queue_for_each_ctx(q, ctx, i) \ 197 for ((i) = 0; (i) < (q)->nr_queues && \ 198 ({ ctx = per_cpu_ptr((q)->queue_ctx, (i)); 1; }); (i)++) 199 200#define hctx_for_each_ctx(hctx, ctx, i) \ 201 for ((i) = 0; (i) < (hctx)->nr_ctx && \ 202 ({ ctx = (hctx)->ctxs[(i)]; 1; }); (i)++) 203 204#define blk_ctx_sum(q, sum) \ 205({ \ 206 struct blk_mq_ctx *__x; \ 207 unsigned int __ret = 0, __i; \ 208 \ 209 queue_for_each_ctx((q), __x, __i) \ 210 __ret += sum; \ 211 __ret; \ 212}) 213 214#endif 215