blob: 995b58d46ed109b0c7241b6db5b870ed911dc845 [file] [log] [blame]
Jens Axboe8324aa92008-01-29 14:51:59 +01001/*
2 * Functions related to sysfs handling
3 */
4#include <linux/kernel.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +09005#include <linux/slab.h>
Jens Axboe8324aa92008-01-29 14:51:59 +01006#include <linux/module.h>
7#include <linux/bio.h>
8#include <linux/blkdev.h>
Tejun Heo66114ca2015-05-22 17:13:32 -04009#include <linux/backing-dev.h>
Jens Axboe8324aa92008-01-29 14:51:59 +010010#include <linux/blktrace_api.h>
Jens Axboe320ae512013-10-24 09:20:05 +010011#include <linux/blk-mq.h>
Tejun Heoeea8f412015-05-22 17:13:17 -040012#include <linux/blk-cgroup.h>
Jens Axboe8324aa92008-01-29 14:51:59 +010013
14#include "blk.h"
Ming Lei3edcc0c2013-12-26 21:31:38 +080015#include "blk-mq.h"
Jens Axboe8324aa92008-01-29 14:51:59 +010016
17struct queue_sysfs_entry {
18 struct attribute attr;
19 ssize_t (*show)(struct request_queue *, char *);
20 ssize_t (*store)(struct request_queue *, const char *, size_t);
21};
22
23static ssize_t
Xiaotian Feng9cb308c2009-07-17 15:26:26 +080024queue_var_show(unsigned long var, char *page)
Jens Axboe8324aa92008-01-29 14:51:59 +010025{
Xiaotian Feng9cb308c2009-07-17 15:26:26 +080026 return sprintf(page, "%lu\n", var);
Jens Axboe8324aa92008-01-29 14:51:59 +010027}
28
29static ssize_t
30queue_var_store(unsigned long *var, const char *page, size_t count)
31{
Dave Reisnerb1f3b642012-09-08 11:55:45 -040032 int err;
33 unsigned long v;
Jens Axboe8324aa92008-01-29 14:51:59 +010034
Jingoo Haned751e62013-09-11 14:20:08 -070035 err = kstrtoul(page, 10, &v);
Dave Reisnerb1f3b642012-09-08 11:55:45 -040036 if (err || v > UINT_MAX)
37 return -EINVAL;
38
39 *var = v;
40
Jens Axboe8324aa92008-01-29 14:51:59 +010041 return count;
42}
43
44static ssize_t queue_requests_show(struct request_queue *q, char *page)
45{
46 return queue_var_show(q->nr_requests, (page));
47}
48
49static ssize_t
50queue_requests_store(struct request_queue *q, const char *page, size_t count)
51{
Jens Axboe8324aa92008-01-29 14:51:59 +010052 unsigned long nr;
Jens Axboee3a2b3f2014-05-20 11:49:02 -060053 int ret, err;
Jens Axboeb8a9ae72009-09-11 22:44:29 +020054
Jens Axboee3a2b3f2014-05-20 11:49:02 -060055 if (!q->request_fn && !q->mq_ops)
Jens Axboeb8a9ae72009-09-11 22:44:29 +020056 return -EINVAL;
57
58 ret = queue_var_store(&nr, page, count);
Dave Reisnerb1f3b642012-09-08 11:55:45 -040059 if (ret < 0)
60 return ret;
61
Jens Axboe8324aa92008-01-29 14:51:59 +010062 if (nr < BLKDEV_MIN_RQ)
63 nr = BLKDEV_MIN_RQ;
64
Jens Axboee3a2b3f2014-05-20 11:49:02 -060065 if (q->request_fn)
66 err = blk_update_nr_requests(q, nr);
67 else
68 err = blk_mq_update_nr_requests(q, nr);
Jens Axboe8324aa92008-01-29 14:51:59 +010069
Jens Axboee3a2b3f2014-05-20 11:49:02 -060070 if (err)
71 return err;
Tejun Heoa0516612012-06-26 15:05:44 -070072
Jens Axboe8324aa92008-01-29 14:51:59 +010073 return ret;
74}
75
76static ssize_t queue_ra_show(struct request_queue *q, char *page)
77{
Xiaotian Feng9cb308c2009-07-17 15:26:26 +080078 unsigned long ra_kb = q->backing_dev_info.ra_pages <<
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +030079 (PAGE_SHIFT - 10);
Jens Axboe8324aa92008-01-29 14:51:59 +010080
81 return queue_var_show(ra_kb, (page));
82}
83
84static ssize_t
85queue_ra_store(struct request_queue *q, const char *page, size_t count)
86{
87 unsigned long ra_kb;
88 ssize_t ret = queue_var_store(&ra_kb, page, count);
89
Dave Reisnerb1f3b642012-09-08 11:55:45 -040090 if (ret < 0)
91 return ret;
92
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +030093 q->backing_dev_info.ra_pages = ra_kb >> (PAGE_SHIFT - 10);
Jens Axboe8324aa92008-01-29 14:51:59 +010094
95 return ret;
96}
97
98static ssize_t queue_max_sectors_show(struct request_queue *q, char *page)
99{
Martin K. Petersenae03bf62009-05-22 17:17:50 -0400100 int max_sectors_kb = queue_max_sectors(q) >> 1;
Jens Axboe8324aa92008-01-29 14:51:59 +0100101
102 return queue_var_show(max_sectors_kb, (page));
103}
104
Martin K. Petersenc77a5712010-03-10 00:48:33 -0500105static ssize_t queue_max_segments_show(struct request_queue *q, char *page)
106{
107 return queue_var_show(queue_max_segments(q), (page));
108}
109
Martin K. Petersen13f05c82010-09-10 20:50:10 +0200110static ssize_t queue_max_integrity_segments_show(struct request_queue *q, char *page)
111{
112 return queue_var_show(q->limits.max_integrity_segments, (page));
113}
114
Martin K. Petersenc77a5712010-03-10 00:48:33 -0500115static ssize_t queue_max_segment_size_show(struct request_queue *q, char *page)
116{
Martin K. Petersene692cb62010-12-01 19:41:49 +0100117 if (blk_queue_cluster(q))
Martin K. Petersenc77a5712010-03-10 00:48:33 -0500118 return queue_var_show(queue_max_segment_size(q), (page));
119
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300120 return queue_var_show(PAGE_SIZE, (page));
Martin K. Petersenc77a5712010-03-10 00:48:33 -0500121}
122
Martin K. Petersene1defc42009-05-22 17:17:49 -0400123static ssize_t queue_logical_block_size_show(struct request_queue *q, char *page)
Martin K. Petersene68b9032008-01-29 19:14:08 +0100124{
Martin K. Petersene1defc42009-05-22 17:17:49 -0400125 return queue_var_show(queue_logical_block_size(q), page);
Martin K. Petersene68b9032008-01-29 19:14:08 +0100126}
127
Martin K. Petersenc72758f2009-05-22 17:17:53 -0400128static ssize_t queue_physical_block_size_show(struct request_queue *q, char *page)
129{
130 return queue_var_show(queue_physical_block_size(q), page);
131}
132
133static ssize_t queue_io_min_show(struct request_queue *q, char *page)
134{
135 return queue_var_show(queue_io_min(q), page);
136}
137
138static ssize_t queue_io_opt_show(struct request_queue *q, char *page)
139{
140 return queue_var_show(queue_io_opt(q), page);
Jens Axboe8324aa92008-01-29 14:51:59 +0100141}
142
Martin K. Petersen86b37282009-11-10 11:50:21 +0100143static ssize_t queue_discard_granularity_show(struct request_queue *q, char *page)
144{
145 return queue_var_show(q->limits.discard_granularity, page);
146}
147
Jens Axboe0034af02015-07-16 09:14:26 -0600148static ssize_t queue_discard_max_hw_show(struct request_queue *q, char *page)
149{
Jens Axboe0034af02015-07-16 09:14:26 -0600150
Alan18f922d02016-02-17 14:15:30 +0000151 return sprintf(page, "%llu\n",
152 (unsigned long long)q->limits.max_hw_discard_sectors << 9);
Jens Axboe0034af02015-07-16 09:14:26 -0600153}
154
Martin K. Petersen86b37282009-11-10 11:50:21 +0100155static ssize_t queue_discard_max_show(struct request_queue *q, char *page)
156{
Martin K. Petersena934a002011-05-18 10:37:35 +0200157 return sprintf(page, "%llu\n",
158 (unsigned long long)q->limits.max_discard_sectors << 9);
Martin K. Petersen86b37282009-11-10 11:50:21 +0100159}
160
Jens Axboe0034af02015-07-16 09:14:26 -0600161static ssize_t queue_discard_max_store(struct request_queue *q,
162 const char *page, size_t count)
163{
164 unsigned long max_discard;
165 ssize_t ret = queue_var_store(&max_discard, page, count);
166
167 if (ret < 0)
168 return ret;
169
170 if (max_discard & (q->limits.discard_granularity - 1))
171 return -EINVAL;
172
173 max_discard >>= 9;
174 if (max_discard > UINT_MAX)
175 return -EINVAL;
176
177 if (max_discard > q->limits.max_hw_discard_sectors)
178 max_discard = q->limits.max_hw_discard_sectors;
179
180 q->limits.max_discard_sectors = max_discard;
181 return ret;
182}
183
Martin K. Petersen98262f22009-12-03 09:24:48 +0100184static ssize_t queue_discard_zeroes_data_show(struct request_queue *q, char *page)
185{
186 return queue_var_show(queue_discard_zeroes_data(q), page);
187}
188
Martin K. Petersen4363ac72012-09-18 12:19:27 -0400189static ssize_t queue_write_same_max_show(struct request_queue *q, char *page)
190{
191 return sprintf(page, "%llu\n",
192 (unsigned long long)q->limits.max_write_same_sectors << 9);
193}
194
195
Jens Axboe8324aa92008-01-29 14:51:59 +0100196static ssize_t
197queue_max_sectors_store(struct request_queue *q, const char *page, size_t count)
198{
199 unsigned long max_sectors_kb,
Martin K. Petersenae03bf62009-05-22 17:17:50 -0400200 max_hw_sectors_kb = queue_max_hw_sectors(q) >> 1,
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300201 page_kb = 1 << (PAGE_SHIFT - 10);
Jens Axboe8324aa92008-01-29 14:51:59 +0100202 ssize_t ret = queue_var_store(&max_sectors_kb, page, count);
203
Dave Reisnerb1f3b642012-09-08 11:55:45 -0400204 if (ret < 0)
205 return ret;
206
Martin K. Petersenca369d52015-11-13 16:46:48 -0500207 max_hw_sectors_kb = min_not_zero(max_hw_sectors_kb, (unsigned long)
208 q->limits.max_dev_sectors >> 1);
209
Jens Axboe8324aa92008-01-29 14:51:59 +0100210 if (max_sectors_kb > max_hw_sectors_kb || max_sectors_kb < page_kb)
211 return -EINVAL;
Wu Fengguang7c239512008-11-25 09:08:39 +0100212
Jens Axboe8324aa92008-01-29 14:51:59 +0100213 spin_lock_irq(q->queue_lock);
Nikanth Karthikesanc295fc02009-09-01 22:40:15 +0200214 q->limits.max_sectors = max_sectors_kb << 1;
Jens Axboe8324aa92008-01-29 14:51:59 +0100215 spin_unlock_irq(q->queue_lock);
216
217 return ret;
218}
219
220static ssize_t queue_max_hw_sectors_show(struct request_queue *q, char *page)
221{
Martin K. Petersenae03bf62009-05-22 17:17:50 -0400222 int max_hw_sectors_kb = queue_max_hw_sectors(q) >> 1;
Jens Axboe8324aa92008-01-29 14:51:59 +0100223
224 return queue_var_show(max_hw_sectors_kb, (page));
225}
226
Jens Axboe956bcb72010-08-07 18:13:50 +0200227#define QUEUE_SYSFS_BIT_FNS(name, flag, neg) \
228static ssize_t \
229queue_show_##name(struct request_queue *q, char *page) \
230{ \
231 int bit; \
232 bit = test_bit(QUEUE_FLAG_##flag, &q->queue_flags); \
233 return queue_var_show(neg ? !bit : bit, page); \
234} \
235static ssize_t \
236queue_store_##name(struct request_queue *q, const char *page, size_t count) \
237{ \
238 unsigned long val; \
239 ssize_t ret; \
240 ret = queue_var_store(&val, page, count); \
Arnd Bergmannc678ef52013-04-03 21:53:57 +0200241 if (ret < 0) \
242 return ret; \
Jens Axboe956bcb72010-08-07 18:13:50 +0200243 if (neg) \
244 val = !val; \
245 \
246 spin_lock_irq(q->queue_lock); \
247 if (val) \
248 queue_flag_set(QUEUE_FLAG_##flag, q); \
249 else \
250 queue_flag_clear(QUEUE_FLAG_##flag, q); \
251 spin_unlock_irq(q->queue_lock); \
252 return ret; \
Bartlomiej Zolnierkiewicz1308835f2009-01-07 12:22:39 +0100253}
254
Jens Axboe956bcb72010-08-07 18:13:50 +0200255QUEUE_SYSFS_BIT_FNS(nonrot, NONROT, 1);
256QUEUE_SYSFS_BIT_FNS(random, ADD_RANDOM, 0);
257QUEUE_SYSFS_BIT_FNS(iostats, IO_STAT, 0);
258#undef QUEUE_SYSFS_BIT_FNS
Bartlomiej Zolnierkiewicz1308835f2009-01-07 12:22:39 +0100259
Alan D. Brunelleac9fafa2008-04-29 14:44:19 +0200260static ssize_t queue_nomerges_show(struct request_queue *q, char *page)
261{
Alan D. Brunelle488991e2010-01-29 09:04:08 +0100262 return queue_var_show((blk_queue_nomerges(q) << 1) |
263 blk_queue_noxmerges(q), page);
Alan D. Brunelleac9fafa2008-04-29 14:44:19 +0200264}
265
266static ssize_t queue_nomerges_store(struct request_queue *q, const char *page,
267 size_t count)
268{
269 unsigned long nm;
270 ssize_t ret = queue_var_store(&nm, page, count);
271
Dave Reisnerb1f3b642012-09-08 11:55:45 -0400272 if (ret < 0)
273 return ret;
274
Jens Axboebf0f9702008-05-07 09:09:39 +0200275 spin_lock_irq(q->queue_lock);
Alan D. Brunelle488991e2010-01-29 09:04:08 +0100276 queue_flag_clear(QUEUE_FLAG_NOMERGES, q);
277 queue_flag_clear(QUEUE_FLAG_NOXMERGES, q);
278 if (nm == 2)
Jens Axboebf0f9702008-05-07 09:09:39 +0200279 queue_flag_set(QUEUE_FLAG_NOMERGES, q);
Alan D. Brunelle488991e2010-01-29 09:04:08 +0100280 else if (nm)
281 queue_flag_set(QUEUE_FLAG_NOXMERGES, q);
Jens Axboebf0f9702008-05-07 09:09:39 +0200282 spin_unlock_irq(q->queue_lock);
Bartlomiej Zolnierkiewicz1308835f2009-01-07 12:22:39 +0100283
Alan D. Brunelleac9fafa2008-04-29 14:44:19 +0200284 return ret;
285}
286
Jens Axboec7c22e42008-09-13 20:26:01 +0200287static ssize_t queue_rq_affinity_show(struct request_queue *q, char *page)
288{
Xiaotian Feng9cb308c2009-07-17 15:26:26 +0800289 bool set = test_bit(QUEUE_FLAG_SAME_COMP, &q->queue_flags);
Dan Williams5757a6d2011-07-23 20:44:25 +0200290 bool force = test_bit(QUEUE_FLAG_SAME_FORCE, &q->queue_flags);
Jens Axboec7c22e42008-09-13 20:26:01 +0200291
Dan Williams5757a6d2011-07-23 20:44:25 +0200292 return queue_var_show(set << force, page);
Jens Axboec7c22e42008-09-13 20:26:01 +0200293}
294
295static ssize_t
296queue_rq_affinity_store(struct request_queue *q, const char *page, size_t count)
297{
298 ssize_t ret = -EINVAL;
Christoph Hellwig0a06ff02013-11-14 14:32:07 -0800299#ifdef CONFIG_SMP
Jens Axboec7c22e42008-09-13 20:26:01 +0200300 unsigned long val;
301
302 ret = queue_var_store(&val, page, count);
Dave Reisnerb1f3b642012-09-08 11:55:45 -0400303 if (ret < 0)
304 return ret;
305
Jens Axboec7c22e42008-09-13 20:26:01 +0200306 spin_lock_irq(q->queue_lock);
Eric Seppanene8037d42011-08-23 21:25:12 +0200307 if (val == 2) {
Jens Axboec7c22e42008-09-13 20:26:01 +0200308 queue_flag_set(QUEUE_FLAG_SAME_COMP, q);
Eric Seppanene8037d42011-08-23 21:25:12 +0200309 queue_flag_set(QUEUE_FLAG_SAME_FORCE, q);
310 } else if (val == 1) {
311 queue_flag_set(QUEUE_FLAG_SAME_COMP, q);
312 queue_flag_clear(QUEUE_FLAG_SAME_FORCE, q);
313 } else if (val == 0) {
Dan Williams5757a6d2011-07-23 20:44:25 +0200314 queue_flag_clear(QUEUE_FLAG_SAME_COMP, q);
315 queue_flag_clear(QUEUE_FLAG_SAME_FORCE, q);
316 }
Jens Axboec7c22e42008-09-13 20:26:01 +0200317 spin_unlock_irq(q->queue_lock);
318#endif
319 return ret;
320}
Jens Axboe8324aa92008-01-29 14:51:59 +0100321
Jens Axboe05229be2015-11-05 10:44:55 -0700322static ssize_t queue_poll_show(struct request_queue *q, char *page)
323{
324 return queue_var_show(test_bit(QUEUE_FLAG_POLL, &q->queue_flags), page);
325}
326
327static ssize_t queue_poll_store(struct request_queue *q, const char *page,
328 size_t count)
329{
330 unsigned long poll_on;
331 ssize_t ret;
332
333 if (!q->mq_ops || !q->mq_ops->poll)
334 return -EINVAL;
335
336 ret = queue_var_store(&poll_on, page, count);
337 if (ret < 0)
338 return ret;
339
340 spin_lock_irq(q->queue_lock);
341 if (poll_on)
342 queue_flag_set(QUEUE_FLAG_POLL, q);
343 else
344 queue_flag_clear(QUEUE_FLAG_POLL, q);
345 spin_unlock_irq(q->queue_lock);
346
347 return ret;
348}
349
Jens Axboe8324aa92008-01-29 14:51:59 +0100350static struct queue_sysfs_entry queue_requests_entry = {
351 .attr = {.name = "nr_requests", .mode = S_IRUGO | S_IWUSR },
352 .show = queue_requests_show,
353 .store = queue_requests_store,
354};
355
356static struct queue_sysfs_entry queue_ra_entry = {
357 .attr = {.name = "read_ahead_kb", .mode = S_IRUGO | S_IWUSR },
358 .show = queue_ra_show,
359 .store = queue_ra_store,
360};
361
362static struct queue_sysfs_entry queue_max_sectors_entry = {
363 .attr = {.name = "max_sectors_kb", .mode = S_IRUGO | S_IWUSR },
364 .show = queue_max_sectors_show,
365 .store = queue_max_sectors_store,
366};
367
368static struct queue_sysfs_entry queue_max_hw_sectors_entry = {
369 .attr = {.name = "max_hw_sectors_kb", .mode = S_IRUGO },
370 .show = queue_max_hw_sectors_show,
371};
372
Martin K. Petersenc77a5712010-03-10 00:48:33 -0500373static struct queue_sysfs_entry queue_max_segments_entry = {
374 .attr = {.name = "max_segments", .mode = S_IRUGO },
375 .show = queue_max_segments_show,
376};
377
Martin K. Petersen13f05c82010-09-10 20:50:10 +0200378static struct queue_sysfs_entry queue_max_integrity_segments_entry = {
379 .attr = {.name = "max_integrity_segments", .mode = S_IRUGO },
380 .show = queue_max_integrity_segments_show,
381};
382
Martin K. Petersenc77a5712010-03-10 00:48:33 -0500383static struct queue_sysfs_entry queue_max_segment_size_entry = {
384 .attr = {.name = "max_segment_size", .mode = S_IRUGO },
385 .show = queue_max_segment_size_show,
386};
387
Jens Axboe8324aa92008-01-29 14:51:59 +0100388static struct queue_sysfs_entry queue_iosched_entry = {
389 .attr = {.name = "scheduler", .mode = S_IRUGO | S_IWUSR },
390 .show = elv_iosched_show,
391 .store = elv_iosched_store,
392};
393
Martin K. Petersene68b9032008-01-29 19:14:08 +0100394static struct queue_sysfs_entry queue_hw_sector_size_entry = {
395 .attr = {.name = "hw_sector_size", .mode = S_IRUGO },
Martin K. Petersene1defc42009-05-22 17:17:49 -0400396 .show = queue_logical_block_size_show,
397};
398
399static struct queue_sysfs_entry queue_logical_block_size_entry = {
400 .attr = {.name = "logical_block_size", .mode = S_IRUGO },
401 .show = queue_logical_block_size_show,
Martin K. Petersene68b9032008-01-29 19:14:08 +0100402};
403
Martin K. Petersenc72758f2009-05-22 17:17:53 -0400404static struct queue_sysfs_entry queue_physical_block_size_entry = {
405 .attr = {.name = "physical_block_size", .mode = S_IRUGO },
406 .show = queue_physical_block_size_show,
407};
408
409static struct queue_sysfs_entry queue_io_min_entry = {
410 .attr = {.name = "minimum_io_size", .mode = S_IRUGO },
411 .show = queue_io_min_show,
412};
413
414static struct queue_sysfs_entry queue_io_opt_entry = {
415 .attr = {.name = "optimal_io_size", .mode = S_IRUGO },
416 .show = queue_io_opt_show,
Jens Axboe8324aa92008-01-29 14:51:59 +0100417};
418
Martin K. Petersen86b37282009-11-10 11:50:21 +0100419static struct queue_sysfs_entry queue_discard_granularity_entry = {
420 .attr = {.name = "discard_granularity", .mode = S_IRUGO },
421 .show = queue_discard_granularity_show,
422};
423
Jens Axboe0034af02015-07-16 09:14:26 -0600424static struct queue_sysfs_entry queue_discard_max_hw_entry = {
425 .attr = {.name = "discard_max_hw_bytes", .mode = S_IRUGO },
426 .show = queue_discard_max_hw_show,
427};
428
Martin K. Petersen86b37282009-11-10 11:50:21 +0100429static struct queue_sysfs_entry queue_discard_max_entry = {
Jens Axboe0034af02015-07-16 09:14:26 -0600430 .attr = {.name = "discard_max_bytes", .mode = S_IRUGO | S_IWUSR },
Martin K. Petersen86b37282009-11-10 11:50:21 +0100431 .show = queue_discard_max_show,
Jens Axboe0034af02015-07-16 09:14:26 -0600432 .store = queue_discard_max_store,
Martin K. Petersen86b37282009-11-10 11:50:21 +0100433};
434
Martin K. Petersen98262f22009-12-03 09:24:48 +0100435static struct queue_sysfs_entry queue_discard_zeroes_data_entry = {
436 .attr = {.name = "discard_zeroes_data", .mode = S_IRUGO },
437 .show = queue_discard_zeroes_data_show,
438};
439
Martin K. Petersen4363ac72012-09-18 12:19:27 -0400440static struct queue_sysfs_entry queue_write_same_max_entry = {
441 .attr = {.name = "write_same_max_bytes", .mode = S_IRUGO },
442 .show = queue_write_same_max_show,
443};
444
Bartlomiej Zolnierkiewicz1308835f2009-01-07 12:22:39 +0100445static struct queue_sysfs_entry queue_nonrot_entry = {
446 .attr = {.name = "rotational", .mode = S_IRUGO | S_IWUSR },
Jens Axboe956bcb72010-08-07 18:13:50 +0200447 .show = queue_show_nonrot,
448 .store = queue_store_nonrot,
Bartlomiej Zolnierkiewicz1308835f2009-01-07 12:22:39 +0100449};
450
Alan D. Brunelleac9fafa2008-04-29 14:44:19 +0200451static struct queue_sysfs_entry queue_nomerges_entry = {
452 .attr = {.name = "nomerges", .mode = S_IRUGO | S_IWUSR },
453 .show = queue_nomerges_show,
454 .store = queue_nomerges_store,
455};
456
Jens Axboec7c22e42008-09-13 20:26:01 +0200457static struct queue_sysfs_entry queue_rq_affinity_entry = {
458 .attr = {.name = "rq_affinity", .mode = S_IRUGO | S_IWUSR },
459 .show = queue_rq_affinity_show,
460 .store = queue_rq_affinity_store,
461};
462
Jens Axboebc58ba92009-01-23 10:54:44 +0100463static struct queue_sysfs_entry queue_iostats_entry = {
464 .attr = {.name = "iostats", .mode = S_IRUGO | S_IWUSR },
Jens Axboe956bcb72010-08-07 18:13:50 +0200465 .show = queue_show_iostats,
466 .store = queue_store_iostats,
Jens Axboebc58ba92009-01-23 10:54:44 +0100467};
468
Jens Axboee2e1a142010-06-09 10:42:09 +0200469static struct queue_sysfs_entry queue_random_entry = {
470 .attr = {.name = "add_random", .mode = S_IRUGO | S_IWUSR },
Jens Axboe956bcb72010-08-07 18:13:50 +0200471 .show = queue_show_random,
472 .store = queue_store_random,
Jens Axboee2e1a142010-06-09 10:42:09 +0200473};
474
Jens Axboe05229be2015-11-05 10:44:55 -0700475static struct queue_sysfs_entry queue_poll_entry = {
476 .attr = {.name = "io_poll", .mode = S_IRUGO | S_IWUSR },
477 .show = queue_poll_show,
478 .store = queue_poll_store,
479};
480
Jens Axboe8324aa92008-01-29 14:51:59 +0100481static struct attribute *default_attrs[] = {
482 &queue_requests_entry.attr,
483 &queue_ra_entry.attr,
484 &queue_max_hw_sectors_entry.attr,
485 &queue_max_sectors_entry.attr,
Martin K. Petersenc77a5712010-03-10 00:48:33 -0500486 &queue_max_segments_entry.attr,
Martin K. Petersen13f05c82010-09-10 20:50:10 +0200487 &queue_max_integrity_segments_entry.attr,
Martin K. Petersenc77a5712010-03-10 00:48:33 -0500488 &queue_max_segment_size_entry.attr,
Jens Axboe8324aa92008-01-29 14:51:59 +0100489 &queue_iosched_entry.attr,
Martin K. Petersene68b9032008-01-29 19:14:08 +0100490 &queue_hw_sector_size_entry.attr,
Martin K. Petersene1defc42009-05-22 17:17:49 -0400491 &queue_logical_block_size_entry.attr,
Martin K. Petersenc72758f2009-05-22 17:17:53 -0400492 &queue_physical_block_size_entry.attr,
493 &queue_io_min_entry.attr,
494 &queue_io_opt_entry.attr,
Martin K. Petersen86b37282009-11-10 11:50:21 +0100495 &queue_discard_granularity_entry.attr,
496 &queue_discard_max_entry.attr,
Jens Axboe0034af02015-07-16 09:14:26 -0600497 &queue_discard_max_hw_entry.attr,
Martin K. Petersen98262f22009-12-03 09:24:48 +0100498 &queue_discard_zeroes_data_entry.attr,
Martin K. Petersen4363ac72012-09-18 12:19:27 -0400499 &queue_write_same_max_entry.attr,
Bartlomiej Zolnierkiewicz1308835f2009-01-07 12:22:39 +0100500 &queue_nonrot_entry.attr,
Alan D. Brunelleac9fafa2008-04-29 14:44:19 +0200501 &queue_nomerges_entry.attr,
Jens Axboec7c22e42008-09-13 20:26:01 +0200502 &queue_rq_affinity_entry.attr,
Jens Axboebc58ba92009-01-23 10:54:44 +0100503 &queue_iostats_entry.attr,
Jens Axboee2e1a142010-06-09 10:42:09 +0200504 &queue_random_entry.attr,
Jens Axboe05229be2015-11-05 10:44:55 -0700505 &queue_poll_entry.attr,
Jens Axboe8324aa92008-01-29 14:51:59 +0100506 NULL,
507};
508
509#define to_queue(atr) container_of((atr), struct queue_sysfs_entry, attr)
510
511static ssize_t
512queue_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
513{
514 struct queue_sysfs_entry *entry = to_queue(attr);
515 struct request_queue *q =
516 container_of(kobj, struct request_queue, kobj);
517 ssize_t res;
518
519 if (!entry->show)
520 return -EIO;
521 mutex_lock(&q->sysfs_lock);
Bart Van Assche3f3299d2012-11-28 13:42:38 +0100522 if (blk_queue_dying(q)) {
Jens Axboe8324aa92008-01-29 14:51:59 +0100523 mutex_unlock(&q->sysfs_lock);
524 return -ENOENT;
525 }
526 res = entry->show(q, page);
527 mutex_unlock(&q->sysfs_lock);
528 return res;
529}
530
531static ssize_t
532queue_attr_store(struct kobject *kobj, struct attribute *attr,
533 const char *page, size_t length)
534{
535 struct queue_sysfs_entry *entry = to_queue(attr);
Jens Axboe6728cb02008-01-31 13:03:55 +0100536 struct request_queue *q;
Jens Axboe8324aa92008-01-29 14:51:59 +0100537 ssize_t res;
538
539 if (!entry->store)
540 return -EIO;
Jens Axboe6728cb02008-01-31 13:03:55 +0100541
542 q = container_of(kobj, struct request_queue, kobj);
Jens Axboe8324aa92008-01-29 14:51:59 +0100543 mutex_lock(&q->sysfs_lock);
Bart Van Assche3f3299d2012-11-28 13:42:38 +0100544 if (blk_queue_dying(q)) {
Jens Axboe8324aa92008-01-29 14:51:59 +0100545 mutex_unlock(&q->sysfs_lock);
546 return -ENOENT;
547 }
548 res = entry->store(q, page, length);
549 mutex_unlock(&q->sysfs_lock);
550 return res;
551}
552
Tejun Heo548bc8e2013-01-09 08:05:13 -0800553static void blk_free_queue_rcu(struct rcu_head *rcu_head)
554{
555 struct request_queue *q = container_of(rcu_head, struct request_queue,
556 rcu_head);
557 kmem_cache_free(blk_requestq_cachep, q);
558}
559
Jens Axboe8324aa92008-01-29 14:51:59 +0100560/**
Andrew Morton499337b2011-09-21 10:01:22 +0200561 * blk_release_queue: - release a &struct request_queue when it is no longer needed
562 * @kobj: the kobj belonging to the request queue to be released
Jens Axboe8324aa92008-01-29 14:51:59 +0100563 *
564 * Description:
Andrew Morton499337b2011-09-21 10:01:22 +0200565 * blk_release_queue is the pair to blk_init_queue() or
Jens Axboe8324aa92008-01-29 14:51:59 +0100566 * blk_queue_make_request(). It should be called when a request queue is
567 * being released; typically when a block device is being de-registered.
568 * Currently, its primary task it to free all the &struct request
569 * structures that were allocated to the queue and the queue itself.
570 *
Bart Van Assche45a9c9d2014-12-09 16:57:48 +0100571 * Note:
572 * The low level driver must have finished any outstanding requests first
573 * via blk_cleanup_queue().
Jens Axboe8324aa92008-01-29 14:51:59 +0100574 **/
575static void blk_release_queue(struct kobject *kobj)
576{
577 struct request_queue *q =
578 container_of(kobj, struct request_queue, kobj);
Jens Axboe8324aa92008-01-29 14:51:59 +0100579
Tejun Heob02176f2015-09-08 12:20:22 -0400580 bdi_exit(&q->backing_dev_info);
Tejun Heoe8989fa2012-03-05 13:15:20 -0800581 blkcg_exit_queue(q);
582
Tejun Heo7e5a8792011-12-14 00:33:42 +0100583 if (q->elevator) {
584 spin_lock_irq(q->queue_lock);
585 ioc_clear_queue(q);
586 spin_unlock_irq(q->queue_lock);
Hannes Reinecke777eb1b2011-09-28 08:07:01 -0600587 elevator_exit(q->elevator);
Tejun Heo7e5a8792011-12-14 00:33:42 +0100588 }
Hannes Reinecke777eb1b2011-09-28 08:07:01 -0600589
Tejun Heoa0516612012-06-26 15:05:44 -0700590 blk_exit_rl(&q->root_rl);
Jens Axboe8324aa92008-01-29 14:51:59 +0100591
592 if (q->queue_tags)
593 __blk_queue_free_tags(q);
594
Bart Van Assche45a9c9d2014-12-09 16:57:48 +0100595 if (!q->mq_ops)
Ming Leif70ced02014-09-25 23:23:47 +0800596 blk_free_flush_queue(q->fq);
Ming Leie09aae72015-01-29 20:17:27 +0800597 else
598 blk_mq_release(q);
Christoph Hellwig18741982014-02-10 09:29:00 -0700599
Jens Axboe8324aa92008-01-29 14:51:59 +0100600 blk_trace_shutdown(q);
601
Kent Overstreet54efd502015-04-23 22:37:18 -0700602 if (q->bio_split)
603 bioset_free(q->bio_split);
604
Tejun Heoa73f7302011-12-14 00:33:37 +0100605 ida_simple_remove(&blk_queue_ida, q->id);
Tejun Heo548bc8e2013-01-09 08:05:13 -0800606 call_rcu(&q->rcu_head, blk_free_queue_rcu);
Jens Axboe8324aa92008-01-29 14:51:59 +0100607}
608
Emese Revfy52cf25d2010-01-19 02:58:23 +0100609static const struct sysfs_ops queue_sysfs_ops = {
Jens Axboe8324aa92008-01-29 14:51:59 +0100610 .show = queue_attr_show,
611 .store = queue_attr_store,
612};
613
614struct kobj_type blk_queue_ktype = {
615 .sysfs_ops = &queue_sysfs_ops,
616 .default_attrs = default_attrs,
617 .release = blk_release_queue,
618};
619
620int blk_register_queue(struct gendisk *disk)
621{
622 int ret;
Li Zefan1d54ad62009-04-14 14:00:05 +0800623 struct device *dev = disk_to_dev(disk);
Jens Axboe8324aa92008-01-29 14:51:59 +0100624 struct request_queue *q = disk->queue;
625
Akinobu Mitafb199742008-04-21 09:51:06 +0200626 if (WARN_ON(!q))
Jens Axboe8324aa92008-01-29 14:51:59 +0100627 return -ENXIO;
628
Tejun Heo749fefe2012-09-20 14:08:52 -0700629 /*
Tejun Heo17497ac2014-09-24 13:31:50 -0400630 * SCSI probing may synchronously create and destroy a lot of
631 * request_queues for non-existent devices. Shutting down a fully
632 * functional queue takes measureable wallclock time as RCU grace
633 * periods are involved. To avoid excessive latency in these
634 * cases, a request_queue starts out in a degraded mode which is
635 * faster to shut down and is made fully functional here as
636 * request_queues for non-existent devices never get registered.
Tejun Heo749fefe2012-09-20 14:08:52 -0700637 */
Alan Sterndf35c7c2014-09-09 11:50:58 -0400638 if (!blk_queue_init_done(q)) {
639 queue_flag_set_unlocked(QUEUE_FLAG_INIT_DONE, q);
Dan Williams3ef28e82015-10-21 13:20:12 -0400640 percpu_ref_switch_to_percpu(&q->q_usage_counter);
Alan Sterndf35c7c2014-09-09 11:50:58 -0400641 blk_queue_bypass_end(q);
642 }
Tejun Heo749fefe2012-09-20 14:08:52 -0700643
Li Zefan1d54ad62009-04-14 14:00:05 +0800644 ret = blk_trace_init_sysfs(dev);
645 if (ret)
646 return ret;
647
Linus Torvaldsc9059592009-06-11 10:52:27 -0700648 ret = kobject_add(&q->kobj, kobject_get(&dev->kobj), "%s", "queue");
Liu Yuaned5302d2011-04-19 13:47:58 +0200649 if (ret < 0) {
650 blk_trace_remove_sysfs(dev);
Jens Axboe8324aa92008-01-29 14:51:59 +0100651 return ret;
Liu Yuaned5302d2011-04-19 13:47:58 +0200652 }
Jens Axboe8324aa92008-01-29 14:51:59 +0100653
654 kobject_uevent(&q->kobj, KOBJ_ADD);
655
Jens Axboe320ae512013-10-24 09:20:05 +0100656 if (q->mq_ops)
657 blk_mq_register_disk(disk);
658
Martin K. Petersencd43e262009-05-22 17:17:52 -0400659 if (!q->request_fn)
660 return 0;
661
Jens Axboe8324aa92008-01-29 14:51:59 +0100662 ret = elv_register_queue(q);
663 if (ret) {
664 kobject_uevent(&q->kobj, KOBJ_REMOVE);
665 kobject_del(&q->kobj);
Liu Yuan80656b62011-04-13 22:14:54 +0200666 blk_trace_remove_sysfs(dev);
Xiaotian Fengc87ffbb2010-08-23 12:30:29 +0200667 kobject_put(&dev->kobj);
Jens Axboe8324aa92008-01-29 14:51:59 +0100668 return ret;
669 }
670
671 return 0;
672}
673
674void blk_unregister_queue(struct gendisk *disk)
675{
676 struct request_queue *q = disk->queue;
677
Akinobu Mitafb199742008-04-21 09:51:06 +0200678 if (WARN_ON(!q))
679 return;
680
Jens Axboe320ae512013-10-24 09:20:05 +0100681 if (q->mq_ops)
682 blk_mq_unregister_disk(disk);
683
Zdenek Kabelac48c0d4d2009-09-25 06:19:26 +0200684 if (q->request_fn)
Jens Axboe8324aa92008-01-29 14:51:59 +0100685 elv_unregister_queue(q);
686
Zdenek Kabelac48c0d4d2009-09-25 06:19:26 +0200687 kobject_uevent(&q->kobj, KOBJ_REMOVE);
688 kobject_del(&q->kobj);
689 blk_trace_remove_sysfs(disk_to_dev(disk));
690 kobject_put(&disk_to_dev(disk)->kobj);
Jens Axboe8324aa92008-01-29 14:51:59 +0100691}