| 1 | #ifndef INT_BLK_MQ_H |
| 2 | #define INT_BLK_MQ_H |
| 3 | |
| 4 | struct blk_mq_tag_set; |
| 5 | |
| 6 | struct blk_mq_ctx { |
| 7 | struct { |
| 8 | spinlock_t lock; |
| 9 | struct list_head rq_list; |
| 10 | } ____cacheline_aligned_in_smp; |
| 11 | |
| 12 | unsigned int cpu; |
| 13 | unsigned int index_hw; |
| 14 | |
| 15 | /* incremented at dispatch time */ |
| 16 | unsigned long rq_dispatched[2]; |
| 17 | unsigned long rq_merged; |
| 18 | |
| 19 | /* incremented at completion time */ |
| 20 | unsigned long ____cacheline_aligned_in_smp rq_completed[2]; |
| 21 | |
| 22 | struct request_queue *queue; |
| 23 | struct kobject kobj; |
| 24 | } ____cacheline_aligned_in_smp; |
| 25 | |
| 26 | void blk_mq_run_hw_queue(struct blk_mq_hw_ctx *hctx, bool async); |
| 27 | void blk_mq_freeze_queue(struct request_queue *q); |
| 28 | void blk_mq_free_queue(struct request_queue *q); |
| 29 | int blk_mq_update_nr_requests(struct request_queue *q, unsigned int nr); |
| 30 | void blk_mq_wake_waiters(struct request_queue *q); |
| 31 | |
| 32 | /* |
| 33 | * CPU hotplug helpers |
| 34 | */ |
| 35 | void blk_mq_enable_hotplug(void); |
| 36 | void blk_mq_disable_hotplug(void); |
| 37 | |
| 38 | /* |
| 39 | * CPU -> queue mappings |
| 40 | */ |
| 41 | int blk_mq_map_queues(struct blk_mq_tag_set *set); |
| 42 | extern int blk_mq_hw_queue_to_node(unsigned int *map, unsigned int); |
| 43 | |
| 44 | static inline struct blk_mq_hw_ctx *blk_mq_map_queue(struct request_queue *q, |
| 45 | int cpu) |
| 46 | { |
| 47 | return q->queue_hw_ctx[q->mq_map[cpu]]; |
| 48 | } |
| 49 | |
| 50 | /* |
| 51 | * sysfs helpers |
| 52 | */ |
| 53 | extern int blk_mq_sysfs_register(struct request_queue *q); |
| 54 | extern void blk_mq_sysfs_unregister(struct request_queue *q); |
| 55 | extern void blk_mq_hctx_kobj_init(struct blk_mq_hw_ctx *hctx); |
| 56 | |
| 57 | extern void blk_mq_rq_timed_out(struct request *req, bool reserved); |
| 58 | |
| 59 | void blk_mq_release(struct request_queue *q); |
| 60 | |
| 61 | static inline struct blk_mq_ctx *__blk_mq_get_ctx(struct request_queue *q, |
| 62 | unsigned int cpu) |
| 63 | { |
| 64 | return per_cpu_ptr(q->queue_ctx, cpu); |
| 65 | } |
| 66 | |
| 67 | /* |
| 68 | * This assumes per-cpu software queueing queues. They could be per-node |
| 69 | * as well, for instance. For now this is hardcoded as-is. Note that we don't |
| 70 | * care about preemption, since we know the ctx's are persistent. This does |
| 71 | * mean that we can't rely on ctx always matching the currently running CPU. |
| 72 | */ |
| 73 | static inline struct blk_mq_ctx *blk_mq_get_ctx(struct request_queue *q) |
| 74 | { |
| 75 | return __blk_mq_get_ctx(q, get_cpu()); |
| 76 | } |
| 77 | |
| 78 | static inline void blk_mq_put_ctx(struct blk_mq_ctx *ctx) |
| 79 | { |
| 80 | put_cpu(); |
| 81 | } |
| 82 | |
| 83 | struct blk_mq_alloc_data { |
| 84 | /* input parameter */ |
| 85 | struct request_queue *q; |
| 86 | unsigned int flags; |
| 87 | |
| 88 | /* input & output parameter */ |
| 89 | struct blk_mq_ctx *ctx; |
| 90 | struct blk_mq_hw_ctx *hctx; |
| 91 | }; |
| 92 | |
| 93 | static inline void blk_mq_set_alloc_data(struct blk_mq_alloc_data *data, |
| 94 | struct request_queue *q, unsigned int flags, |
| 95 | struct blk_mq_ctx *ctx, struct blk_mq_hw_ctx *hctx) |
| 96 | { |
| 97 | data->q = q; |
| 98 | data->flags = flags; |
| 99 | data->ctx = ctx; |
| 100 | data->hctx = hctx; |
| 101 | } |
| 102 | |
| 103 | static inline bool blk_mq_hw_queue_mapped(struct blk_mq_hw_ctx *hctx) |
| 104 | { |
| 105 | return hctx->nr_ctx && hctx->tags; |
| 106 | } |
| 107 | |
| 108 | #endif |