1 #ifndef BLK_MQ_H 2 #define BLK_MQ_H 3 4 #include <linux/blkdev.h> 5 6 struct blk_mq_tags; 7 8 struct 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 14 struct blk_mq_ctxmap { 15 unsigned int map_size; 16 unsigned int bits_per_word; 17 struct blk_align_bitmap *map; 18 }; 19 20 struct 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 63 struct 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 80 typedef int (queue_rq_fn)(struct blk_mq_hw_ctx *, struct request *); 81 typedef struct blk_mq_hw_ctx *(map_queue_fn)(struct request_queue *, const int); 82 typedef int (init_hctx_fn)(struct blk_mq_hw_ctx *, void *, unsigned int); 83 typedef void (exit_hctx_fn)(struct blk_mq_hw_ctx *, unsigned int); 84 typedef int (init_request_fn)(void *, struct request *, unsigned int, 85 unsigned int, unsigned int); 86 typedef void (exit_request_fn)(void *, struct request *, unsigned int, 87 unsigned int); 88 89 struct 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 124 enum { 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_SHOULD_SORT = 1 << 1, 131 BLK_MQ_F_TAG_SHARED = 1 << 2, 132 BLK_MQ_F_SG_MERGE = 1 << 3, 133 BLK_MQ_F_SYSFS_UP = 1 << 4, 134 135 BLK_MQ_S_STOPPED = 0, 136 BLK_MQ_S_TAG_ACTIVE = 1, 137 138 BLK_MQ_MAX_DEPTH = 10240, 139 140 BLK_MQ_CPU_WORK_BATCH = 8, 141 }; 142 143 struct request_queue *blk_mq_init_queue(struct blk_mq_tag_set *); 144 int blk_mq_register_disk(struct gendisk *); 145 void blk_mq_unregister_disk(struct gendisk *); 146 147 int blk_mq_alloc_tag_set(struct blk_mq_tag_set *set); 148 void blk_mq_free_tag_set(struct blk_mq_tag_set *set); 149 150 void blk_mq_flush_plug_list(struct blk_plug *plug, bool from_schedule); 151 152 void blk_mq_insert_request(struct request *, bool, bool, bool); 153 void blk_mq_run_queues(struct request_queue *q, bool async); 154 void blk_mq_free_request(struct request *rq); 155 bool blk_mq_can_queue(struct blk_mq_hw_ctx *); 156 struct request *blk_mq_alloc_request(struct request_queue *q, int rw, 157 gfp_t gfp, bool reserved); 158 struct request *blk_mq_tag_to_rq(struct blk_mq_tags *tags, unsigned int tag); 159 160 struct blk_mq_hw_ctx *blk_mq_map_queue(struct request_queue *, const int ctx_index); 161 struct blk_mq_hw_ctx *blk_mq_alloc_single_hw_queue(struct blk_mq_tag_set *, unsigned int, int); 162 163 void blk_mq_end_io(struct request *rq, int error); 164 void __blk_mq_end_io(struct request *rq, int error); 165 166 void blk_mq_requeue_request(struct request *rq); 167 void blk_mq_add_to_requeue_list(struct request *rq, bool at_head); 168 void blk_mq_kick_requeue_list(struct request_queue *q); 169 void blk_mq_complete_request(struct request *rq); 170 171 void blk_mq_stop_hw_queue(struct blk_mq_hw_ctx *hctx); 172 void blk_mq_start_hw_queue(struct blk_mq_hw_ctx *hctx); 173 void blk_mq_stop_hw_queues(struct request_queue *q); 174 void blk_mq_start_hw_queues(struct request_queue *q); 175 void blk_mq_start_stopped_hw_queues(struct request_queue *q, bool async); 176 void blk_mq_delay_queue(struct blk_mq_hw_ctx *hctx, unsigned long msecs); 177 void 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 */ 183 static inline struct request *blk_mq_rq_from_pdu(void *pdu) 184 { 185 return pdu - sizeof(struct request); 186 } 187 static 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