Jens Axboe | 320ae51 | 2013-10-24 09:20:05 +0100 | [diff] [blame] | 1 | #ifndef INT_BLK_MQ_H |
| 2 | #define INT_BLK_MQ_H |
| 3 | |
Christoph Hellwig | 24d2f90 | 2014-04-15 14:14:00 -0600 | [diff] [blame] | 4 | struct blk_mq_tag_set; |
| 5 | |
Jens Axboe | 320ae51 | 2013-10-24 09:20:05 +0100 | [diff] [blame] | 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; |
Jens Axboe | 320ae51 | 2013-10-24 09:20:05 +0100 | [diff] [blame] | 14 | |
Jens Axboe | 4bb659b | 2014-05-09 09:36:49 -0600 | [diff] [blame] | 15 | unsigned int last_tag ____cacheline_aligned_in_smp; |
| 16 | |
Jens Axboe | 320ae51 | 2013-10-24 09:20:05 +0100 | [diff] [blame] | 17 | /* incremented at dispatch time */ |
| 18 | unsigned long rq_dispatched[2]; |
| 19 | unsigned long rq_merged; |
| 20 | |
| 21 | /* incremented at completion time */ |
| 22 | unsigned long ____cacheline_aligned_in_smp rq_completed[2]; |
| 23 | |
| 24 | struct request_queue *queue; |
| 25 | struct kobject kobj; |
Jens Axboe | 4bb659b | 2014-05-09 09:36:49 -0600 | [diff] [blame] | 26 | } ____cacheline_aligned_in_smp; |
Jens Axboe | 320ae51 | 2013-10-24 09:20:05 +0100 | [diff] [blame] | 27 | |
Christoph Hellwig | 30a91cb | 2014-02-10 03:24:38 -0800 | [diff] [blame] | 28 | void __blk_mq_complete_request(struct request *rq); |
Jens Axboe | 320ae51 | 2013-10-24 09:20:05 +0100 | [diff] [blame] | 29 | void blk_mq_run_hw_queue(struct blk_mq_hw_ctx *hctx, bool async); |
Tejun Heo | 780db20 | 2014-07-01 10:31:13 -0600 | [diff] [blame] | 30 | void blk_mq_freeze_queue(struct request_queue *q); |
Ming Lei | 3edcc0c | 2013-12-26 21:31:38 +0800 | [diff] [blame] | 31 | void blk_mq_free_queue(struct request_queue *q); |
Christoph Hellwig | 8727af4 | 2014-04-14 10:30:08 +0200 | [diff] [blame] | 32 | void blk_mq_clone_flush_request(struct request *flush_rq, |
| 33 | struct request *orig_rq); |
Jens Axboe | e3a2b3f | 2014-05-20 11:49:02 -0600 | [diff] [blame] | 34 | int blk_mq_update_nr_requests(struct request_queue *q, unsigned int nr); |
Jens Axboe | aed3ea9 | 2014-12-22 14:04:42 -0700 | [diff] [blame] | 35 | void blk_mq_wake_waiters(struct request_queue *q); |
Jens Axboe | 320ae51 | 2013-10-24 09:20:05 +0100 | [diff] [blame] | 36 | |
| 37 | /* |
| 38 | * CPU hotplug helpers |
| 39 | */ |
| 40 | struct blk_mq_cpu_notifier; |
| 41 | void blk_mq_init_cpu_notifier(struct blk_mq_cpu_notifier *notifier, |
Jens Axboe | e814e71 | 2014-05-21 13:59:08 -0600 | [diff] [blame] | 42 | int (*fn)(void *, unsigned long, unsigned int), |
Jens Axboe | 320ae51 | 2013-10-24 09:20:05 +0100 | [diff] [blame] | 43 | void *data); |
| 44 | void blk_mq_register_cpu_notifier(struct blk_mq_cpu_notifier *notifier); |
| 45 | void blk_mq_unregister_cpu_notifier(struct blk_mq_cpu_notifier *notifier); |
| 46 | void blk_mq_cpu_init(void); |
Jens Axboe | 676141e | 2014-03-20 13:29:18 -0600 | [diff] [blame] | 47 | void blk_mq_enable_hotplug(void); |
| 48 | void blk_mq_disable_hotplug(void); |
Jens Axboe | 320ae51 | 2013-10-24 09:20:05 +0100 | [diff] [blame] | 49 | |
| 50 | /* |
| 51 | * CPU -> queue mappings |
| 52 | */ |
Christoph Hellwig | 24d2f90 | 2014-04-15 14:14:00 -0600 | [diff] [blame] | 53 | extern unsigned int *blk_mq_make_queue_map(struct blk_mq_tag_set *set); |
Jens Axboe | 320ae51 | 2013-10-24 09:20:05 +0100 | [diff] [blame] | 54 | extern int blk_mq_update_queue_map(unsigned int *map, unsigned int nr_queues); |
Jens Axboe | f14bbe7 | 2014-05-27 12:06:53 -0600 | [diff] [blame] | 55 | extern int blk_mq_hw_queue_to_node(unsigned int *map, unsigned int); |
Jens Axboe | 320ae51 | 2013-10-24 09:20:05 +0100 | [diff] [blame] | 56 | |
Jens Axboe | e93ecf6 | 2014-05-19 09:17:48 -0600 | [diff] [blame] | 57 | /* |
Jens Axboe | 67aec14 | 2014-05-30 08:25:36 -0600 | [diff] [blame] | 58 | * sysfs helpers |
| 59 | */ |
| 60 | extern int blk_mq_sysfs_register(struct request_queue *q); |
| 61 | extern void blk_mq_sysfs_unregister(struct request_queue *q); |
| 62 | |
Christoph Hellwig | 9041583 | 2014-09-22 10:21:48 -0600 | [diff] [blame] | 63 | extern void blk_mq_rq_timed_out(struct request *req, bool reserved); |
| 64 | |
Jens Axboe | 67aec14 | 2014-05-30 08:25:36 -0600 | [diff] [blame] | 65 | /* |
Jens Axboe | e93ecf6 | 2014-05-19 09:17:48 -0600 | [diff] [blame] | 66 | * Basic implementation of sparser bitmap, allowing the user to spread |
| 67 | * the bits over more cachelines. |
| 68 | */ |
| 69 | struct blk_align_bitmap { |
| 70 | unsigned long word; |
| 71 | unsigned long depth; |
| 72 | } ____cacheline_aligned_in_smp; |
| 73 | |
Ming Lei | 1aecfe4 | 2014-06-01 00:43:36 +0800 | [diff] [blame] | 74 | static inline struct blk_mq_ctx *__blk_mq_get_ctx(struct request_queue *q, |
| 75 | unsigned int cpu) |
| 76 | { |
| 77 | return per_cpu_ptr(q->queue_ctx, cpu); |
| 78 | } |
| 79 | |
| 80 | /* |
| 81 | * This assumes per-cpu software queueing queues. They could be per-node |
| 82 | * as well, for instance. For now this is hardcoded as-is. Note that we don't |
| 83 | * care about preemption, since we know the ctx's are persistent. This does |
| 84 | * mean that we can't rely on ctx always matching the currently running CPU. |
| 85 | */ |
| 86 | static inline struct blk_mq_ctx *blk_mq_get_ctx(struct request_queue *q) |
| 87 | { |
| 88 | return __blk_mq_get_ctx(q, get_cpu()); |
| 89 | } |
| 90 | |
| 91 | static inline void blk_mq_put_ctx(struct blk_mq_ctx *ctx) |
| 92 | { |
| 93 | put_cpu(); |
| 94 | } |
| 95 | |
Ming Lei | cb96a42 | 2014-06-01 00:43:37 +0800 | [diff] [blame] | 96 | struct blk_mq_alloc_data { |
| 97 | /* input parameter */ |
| 98 | struct request_queue *q; |
| 99 | gfp_t gfp; |
| 100 | bool reserved; |
| 101 | |
| 102 | /* input & output parameter */ |
| 103 | struct blk_mq_ctx *ctx; |
| 104 | struct blk_mq_hw_ctx *hctx; |
| 105 | }; |
| 106 | |
| 107 | static inline void blk_mq_set_alloc_data(struct blk_mq_alloc_data *data, |
| 108 | struct request_queue *q, gfp_t gfp, bool reserved, |
| 109 | struct blk_mq_ctx *ctx, |
| 110 | struct blk_mq_hw_ctx *hctx) |
| 111 | { |
| 112 | data->q = q; |
| 113 | data->gfp = gfp; |
| 114 | data->reserved = reserved; |
| 115 | data->ctx = ctx; |
| 116 | data->hctx = hctx; |
| 117 | } |
| 118 | |
Ming Lei | 19c66e5 | 2014-12-03 19:38:04 +0800 | [diff] [blame] | 119 | static inline bool blk_mq_hw_queue_mapped(struct blk_mq_hw_ctx *hctx) |
| 120 | { |
| 121 | return hctx->nr_ctx && hctx->tags; |
| 122 | } |
| 123 | |
Jens Axboe | 320ae51 | 2013-10-24 09:20:05 +0100 | [diff] [blame] | 124 | #endif |