blob: 07c75d0ec00b4773fd5d01f69b983f5a203338d2 [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{
Jan Kara1cdb7f92017-02-02 15:56:50 +010078 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
Jan Kara1cdb7f92017-02-02 15:56:50 +010093 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 Axboe93e9d8e2016-04-12 12:32:46 -0600350static ssize_t queue_wc_show(struct request_queue *q, char *page)
351{
352 if (test_bit(QUEUE_FLAG_WC, &q->queue_flags))
353 return sprintf(page, "write back\n");
354
355 return sprintf(page, "write through\n");
356}
357
358static ssize_t queue_wc_store(struct request_queue *q, const char *page,
359 size_t count)
360{
361 int set = -1;
362
363 if (!strncmp(page, "write back", 10))
364 set = 1;
365 else if (!strncmp(page, "write through", 13) ||
366 !strncmp(page, "none", 4))
367 set = 0;
368
369 if (set == -1)
370 return -EINVAL;
371
372 spin_lock_irq(q->queue_lock);
373 if (set)
374 queue_flag_set(QUEUE_FLAG_WC, q);
375 else
376 queue_flag_clear(QUEUE_FLAG_WC, q);
377 spin_unlock_irq(q->queue_lock);
378
379 return count;
380}
381
Yigal Kormanea6ca602016-06-23 17:05:51 -0400382static ssize_t queue_dax_show(struct request_queue *q, char *page)
383{
384 return queue_var_show(blk_queue_dax(q), page);
385}
386
Jens Axboe8324aa92008-01-29 14:51:59 +0100387static struct queue_sysfs_entry queue_requests_entry = {
388 .attr = {.name = "nr_requests", .mode = S_IRUGO | S_IWUSR },
389 .show = queue_requests_show,
390 .store = queue_requests_store,
391};
392
393static struct queue_sysfs_entry queue_ra_entry = {
394 .attr = {.name = "read_ahead_kb", .mode = S_IRUGO | S_IWUSR },
395 .show = queue_ra_show,
396 .store = queue_ra_store,
397};
398
399static struct queue_sysfs_entry queue_max_sectors_entry = {
400 .attr = {.name = "max_sectors_kb", .mode = S_IRUGO | S_IWUSR },
401 .show = queue_max_sectors_show,
402 .store = queue_max_sectors_store,
403};
404
405static struct queue_sysfs_entry queue_max_hw_sectors_entry = {
406 .attr = {.name = "max_hw_sectors_kb", .mode = S_IRUGO },
407 .show = queue_max_hw_sectors_show,
408};
409
Martin K. Petersenc77a5712010-03-10 00:48:33 -0500410static struct queue_sysfs_entry queue_max_segments_entry = {
411 .attr = {.name = "max_segments", .mode = S_IRUGO },
412 .show = queue_max_segments_show,
413};
414
Martin K. Petersen13f05c82010-09-10 20:50:10 +0200415static struct queue_sysfs_entry queue_max_integrity_segments_entry = {
416 .attr = {.name = "max_integrity_segments", .mode = S_IRUGO },
417 .show = queue_max_integrity_segments_show,
418};
419
Martin K. Petersenc77a5712010-03-10 00:48:33 -0500420static struct queue_sysfs_entry queue_max_segment_size_entry = {
421 .attr = {.name = "max_segment_size", .mode = S_IRUGO },
422 .show = queue_max_segment_size_show,
423};
424
Jens Axboe8324aa92008-01-29 14:51:59 +0100425static struct queue_sysfs_entry queue_iosched_entry = {
426 .attr = {.name = "scheduler", .mode = S_IRUGO | S_IWUSR },
427 .show = elv_iosched_show,
428 .store = elv_iosched_store,
429};
430
Martin K. Petersene68b9032008-01-29 19:14:08 +0100431static struct queue_sysfs_entry queue_hw_sector_size_entry = {
432 .attr = {.name = "hw_sector_size", .mode = S_IRUGO },
Martin K. Petersene1defc42009-05-22 17:17:49 -0400433 .show = queue_logical_block_size_show,
434};
435
436static struct queue_sysfs_entry queue_logical_block_size_entry = {
437 .attr = {.name = "logical_block_size", .mode = S_IRUGO },
438 .show = queue_logical_block_size_show,
Martin K. Petersene68b9032008-01-29 19:14:08 +0100439};
440
Martin K. Petersenc72758f2009-05-22 17:17:53 -0400441static struct queue_sysfs_entry queue_physical_block_size_entry = {
442 .attr = {.name = "physical_block_size", .mode = S_IRUGO },
443 .show = queue_physical_block_size_show,
444};
445
446static struct queue_sysfs_entry queue_io_min_entry = {
447 .attr = {.name = "minimum_io_size", .mode = S_IRUGO },
448 .show = queue_io_min_show,
449};
450
451static struct queue_sysfs_entry queue_io_opt_entry = {
452 .attr = {.name = "optimal_io_size", .mode = S_IRUGO },
453 .show = queue_io_opt_show,
Jens Axboe8324aa92008-01-29 14:51:59 +0100454};
455
Martin K. Petersen86b37282009-11-10 11:50:21 +0100456static struct queue_sysfs_entry queue_discard_granularity_entry = {
457 .attr = {.name = "discard_granularity", .mode = S_IRUGO },
458 .show = queue_discard_granularity_show,
459};
460
Jens Axboe0034af02015-07-16 09:14:26 -0600461static struct queue_sysfs_entry queue_discard_max_hw_entry = {
462 .attr = {.name = "discard_max_hw_bytes", .mode = S_IRUGO },
463 .show = queue_discard_max_hw_show,
464};
465
Martin K. Petersen86b37282009-11-10 11:50:21 +0100466static struct queue_sysfs_entry queue_discard_max_entry = {
Jens Axboe0034af02015-07-16 09:14:26 -0600467 .attr = {.name = "discard_max_bytes", .mode = S_IRUGO | S_IWUSR },
Martin K. Petersen86b37282009-11-10 11:50:21 +0100468 .show = queue_discard_max_show,
Jens Axboe0034af02015-07-16 09:14:26 -0600469 .store = queue_discard_max_store,
Martin K. Petersen86b37282009-11-10 11:50:21 +0100470};
471
Martin K. Petersen98262f22009-12-03 09:24:48 +0100472static struct queue_sysfs_entry queue_discard_zeroes_data_entry = {
473 .attr = {.name = "discard_zeroes_data", .mode = S_IRUGO },
474 .show = queue_discard_zeroes_data_show,
475};
476
Martin K. Petersen4363ac72012-09-18 12:19:27 -0400477static struct queue_sysfs_entry queue_write_same_max_entry = {
478 .attr = {.name = "write_same_max_bytes", .mode = S_IRUGO },
479 .show = queue_write_same_max_show,
480};
481
Bartlomiej Zolnierkiewicz1308835f2009-01-07 12:22:39 +0100482static struct queue_sysfs_entry queue_nonrot_entry = {
483 .attr = {.name = "rotational", .mode = S_IRUGO | S_IWUSR },
Jens Axboe956bcb72010-08-07 18:13:50 +0200484 .show = queue_show_nonrot,
485 .store = queue_store_nonrot,
Bartlomiej Zolnierkiewicz1308835f2009-01-07 12:22:39 +0100486};
487
Alan D. Brunelleac9fafa2008-04-29 14:44:19 +0200488static struct queue_sysfs_entry queue_nomerges_entry = {
489 .attr = {.name = "nomerges", .mode = S_IRUGO | S_IWUSR },
490 .show = queue_nomerges_show,
491 .store = queue_nomerges_store,
492};
493
Jens Axboec7c22e42008-09-13 20:26:01 +0200494static struct queue_sysfs_entry queue_rq_affinity_entry = {
495 .attr = {.name = "rq_affinity", .mode = S_IRUGO | S_IWUSR },
496 .show = queue_rq_affinity_show,
497 .store = queue_rq_affinity_store,
498};
499
Jens Axboebc58ba92009-01-23 10:54:44 +0100500static struct queue_sysfs_entry queue_iostats_entry = {
501 .attr = {.name = "iostats", .mode = S_IRUGO | S_IWUSR },
Jens Axboe956bcb72010-08-07 18:13:50 +0200502 .show = queue_show_iostats,
503 .store = queue_store_iostats,
Jens Axboebc58ba92009-01-23 10:54:44 +0100504};
505
Jens Axboee2e1a142010-06-09 10:42:09 +0200506static struct queue_sysfs_entry queue_random_entry = {
507 .attr = {.name = "add_random", .mode = S_IRUGO | S_IWUSR },
Jens Axboe956bcb72010-08-07 18:13:50 +0200508 .show = queue_show_random,
509 .store = queue_store_random,
Jens Axboee2e1a142010-06-09 10:42:09 +0200510};
511
Jens Axboe05229be2015-11-05 10:44:55 -0700512static struct queue_sysfs_entry queue_poll_entry = {
513 .attr = {.name = "io_poll", .mode = S_IRUGO | S_IWUSR },
514 .show = queue_poll_show,
515 .store = queue_poll_store,
516};
517
Jens Axboe93e9d8e2016-04-12 12:32:46 -0600518static struct queue_sysfs_entry queue_wc_entry = {
519 .attr = {.name = "write_cache", .mode = S_IRUGO | S_IWUSR },
520 .show = queue_wc_show,
521 .store = queue_wc_store,
522};
523
Yigal Kormanea6ca602016-06-23 17:05:51 -0400524static struct queue_sysfs_entry queue_dax_entry = {
525 .attr = {.name = "dax", .mode = S_IRUGO },
526 .show = queue_dax_show,
527};
528
Jens Axboe8324aa92008-01-29 14:51:59 +0100529static struct attribute *default_attrs[] = {
530 &queue_requests_entry.attr,
531 &queue_ra_entry.attr,
532 &queue_max_hw_sectors_entry.attr,
533 &queue_max_sectors_entry.attr,
Martin K. Petersenc77a5712010-03-10 00:48:33 -0500534 &queue_max_segments_entry.attr,
Martin K. Petersen13f05c82010-09-10 20:50:10 +0200535 &queue_max_integrity_segments_entry.attr,
Martin K. Petersenc77a5712010-03-10 00:48:33 -0500536 &queue_max_segment_size_entry.attr,
Jens Axboe8324aa92008-01-29 14:51:59 +0100537 &queue_iosched_entry.attr,
Martin K. Petersene68b9032008-01-29 19:14:08 +0100538 &queue_hw_sector_size_entry.attr,
Martin K. Petersene1defc42009-05-22 17:17:49 -0400539 &queue_logical_block_size_entry.attr,
Martin K. Petersenc72758f2009-05-22 17:17:53 -0400540 &queue_physical_block_size_entry.attr,
541 &queue_io_min_entry.attr,
542 &queue_io_opt_entry.attr,
Martin K. Petersen86b37282009-11-10 11:50:21 +0100543 &queue_discard_granularity_entry.attr,
544 &queue_discard_max_entry.attr,
Jens Axboe0034af02015-07-16 09:14:26 -0600545 &queue_discard_max_hw_entry.attr,
Martin K. Petersen98262f22009-12-03 09:24:48 +0100546 &queue_discard_zeroes_data_entry.attr,
Martin K. Petersen4363ac72012-09-18 12:19:27 -0400547 &queue_write_same_max_entry.attr,
Bartlomiej Zolnierkiewicz1308835f2009-01-07 12:22:39 +0100548 &queue_nonrot_entry.attr,
Alan D. Brunelleac9fafa2008-04-29 14:44:19 +0200549 &queue_nomerges_entry.attr,
Jens Axboec7c22e42008-09-13 20:26:01 +0200550 &queue_rq_affinity_entry.attr,
Jens Axboebc58ba92009-01-23 10:54:44 +0100551 &queue_iostats_entry.attr,
Jens Axboee2e1a142010-06-09 10:42:09 +0200552 &queue_random_entry.attr,
Jens Axboe05229be2015-11-05 10:44:55 -0700553 &queue_poll_entry.attr,
Jens Axboe93e9d8e2016-04-12 12:32:46 -0600554 &queue_wc_entry.attr,
Yigal Kormanea6ca602016-06-23 17:05:51 -0400555 &queue_dax_entry.attr,
Jens Axboe8324aa92008-01-29 14:51:59 +0100556 NULL,
557};
558
559#define to_queue(atr) container_of((atr), struct queue_sysfs_entry, attr)
560
561static ssize_t
562queue_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
563{
564 struct queue_sysfs_entry *entry = to_queue(attr);
565 struct request_queue *q =
566 container_of(kobj, struct request_queue, kobj);
567 ssize_t res;
568
569 if (!entry->show)
570 return -EIO;
571 mutex_lock(&q->sysfs_lock);
Bart Van Assche3f3299d2012-11-28 13:42:38 +0100572 if (blk_queue_dying(q)) {
Jens Axboe8324aa92008-01-29 14:51:59 +0100573 mutex_unlock(&q->sysfs_lock);
574 return -ENOENT;
575 }
576 res = entry->show(q, page);
577 mutex_unlock(&q->sysfs_lock);
578 return res;
579}
580
581static ssize_t
582queue_attr_store(struct kobject *kobj, struct attribute *attr,
583 const char *page, size_t length)
584{
585 struct queue_sysfs_entry *entry = to_queue(attr);
Jens Axboe6728cb02008-01-31 13:03:55 +0100586 struct request_queue *q;
Jens Axboe8324aa92008-01-29 14:51:59 +0100587 ssize_t res;
588
589 if (!entry->store)
590 return -EIO;
Jens Axboe6728cb02008-01-31 13:03:55 +0100591
592 q = container_of(kobj, struct request_queue, kobj);
Jens Axboe8324aa92008-01-29 14:51:59 +0100593 mutex_lock(&q->sysfs_lock);
Bart Van Assche3f3299d2012-11-28 13:42:38 +0100594 if (blk_queue_dying(q)) {
Jens Axboe8324aa92008-01-29 14:51:59 +0100595 mutex_unlock(&q->sysfs_lock);
596 return -ENOENT;
597 }
598 res = entry->store(q, page, length);
599 mutex_unlock(&q->sysfs_lock);
600 return res;
601}
602
Tejun Heo548bc8e2013-01-09 08:05:13 -0800603static void blk_free_queue_rcu(struct rcu_head *rcu_head)
604{
605 struct request_queue *q = container_of(rcu_head, struct request_queue,
606 rcu_head);
607 kmem_cache_free(blk_requestq_cachep, q);
608}
609
Jens Axboe8324aa92008-01-29 14:51:59 +0100610/**
Andrew Morton499337b2011-09-21 10:01:22 +0200611 * blk_release_queue: - release a &struct request_queue when it is no longer needed
612 * @kobj: the kobj belonging to the request queue to be released
Jens Axboe8324aa92008-01-29 14:51:59 +0100613 *
614 * Description:
Andrew Morton499337b2011-09-21 10:01:22 +0200615 * blk_release_queue is the pair to blk_init_queue() or
Jens Axboe8324aa92008-01-29 14:51:59 +0100616 * blk_queue_make_request(). It should be called when a request queue is
617 * being released; typically when a block device is being de-registered.
618 * Currently, its primary task it to free all the &struct request
619 * structures that were allocated to the queue and the queue itself.
620 *
Bart Van Assche45a9c9d2014-12-09 16:57:48 +0100621 * Note:
622 * The low level driver must have finished any outstanding requests first
623 * via blk_cleanup_queue().
Jens Axboe8324aa92008-01-29 14:51:59 +0100624 **/
625static void blk_release_queue(struct kobject *kobj)
626{
627 struct request_queue *q =
628 container_of(kobj, struct request_queue, kobj);
Jens Axboe8324aa92008-01-29 14:51:59 +0100629
Jan Kara33c17052017-02-02 15:56:51 +0100630 bdi_put(q->backing_dev_info);
Tejun Heoe8989fa2012-03-05 13:15:20 -0800631 blkcg_exit_queue(q);
632
Tejun Heo7e5a8792011-12-14 00:33:42 +0100633 if (q->elevator) {
634 spin_lock_irq(q->queue_lock);
635 ioc_clear_queue(q);
636 spin_unlock_irq(q->queue_lock);
Hannes Reinecke777eb1b2011-09-28 08:07:01 -0600637 elevator_exit(q->elevator);
Tejun Heo7e5a8792011-12-14 00:33:42 +0100638 }
Hannes Reinecke777eb1b2011-09-28 08:07:01 -0600639
Tejun Heoa0516612012-06-26 15:05:44 -0700640 blk_exit_rl(&q->root_rl);
Jens Axboe8324aa92008-01-29 14:51:59 +0100641
642 if (q->queue_tags)
643 __blk_queue_free_tags(q);
644
Bart Van Assche45a9c9d2014-12-09 16:57:48 +0100645 if (!q->mq_ops)
Ming Leif70ced02014-09-25 23:23:47 +0800646 blk_free_flush_queue(q->fq);
Ming Leie09aae72015-01-29 20:17:27 +0800647 else
648 blk_mq_release(q);
Christoph Hellwig18741982014-02-10 09:29:00 -0700649
Jens Axboe8324aa92008-01-29 14:51:59 +0100650 blk_trace_shutdown(q);
651
Kent Overstreet54efd502015-04-23 22:37:18 -0700652 if (q->bio_split)
653 bioset_free(q->bio_split);
654
Tejun Heoa73f7302011-12-14 00:33:37 +0100655 ida_simple_remove(&blk_queue_ida, q->id);
Tejun Heo548bc8e2013-01-09 08:05:13 -0800656 call_rcu(&q->rcu_head, blk_free_queue_rcu);
Jens Axboe8324aa92008-01-29 14:51:59 +0100657}
658
Emese Revfy52cf25d2010-01-19 02:58:23 +0100659static const struct sysfs_ops queue_sysfs_ops = {
Jens Axboe8324aa92008-01-29 14:51:59 +0100660 .show = queue_attr_show,
661 .store = queue_attr_store,
662};
663
664struct kobj_type blk_queue_ktype = {
665 .sysfs_ops = &queue_sysfs_ops,
666 .default_attrs = default_attrs,
667 .release = blk_release_queue,
668};
669
670int blk_register_queue(struct gendisk *disk)
671{
672 int ret;
Li Zefan1d54ad62009-04-14 14:00:05 +0800673 struct device *dev = disk_to_dev(disk);
Jens Axboe8324aa92008-01-29 14:51:59 +0100674 struct request_queue *q = disk->queue;
675
Akinobu Mitafb199742008-04-21 09:51:06 +0200676 if (WARN_ON(!q))
Jens Axboe8324aa92008-01-29 14:51:59 +0100677 return -ENXIO;
678
Tejun Heo749fefe2012-09-20 14:08:52 -0700679 /*
Tejun Heo17497ac2014-09-24 13:31:50 -0400680 * SCSI probing may synchronously create and destroy a lot of
681 * request_queues for non-existent devices. Shutting down a fully
682 * functional queue takes measureable wallclock time as RCU grace
683 * periods are involved. To avoid excessive latency in these
684 * cases, a request_queue starts out in a degraded mode which is
685 * faster to shut down and is made fully functional here as
686 * request_queues for non-existent devices never get registered.
Tejun Heo749fefe2012-09-20 14:08:52 -0700687 */
Alan Sterndf35c7c2014-09-09 11:50:58 -0400688 if (!blk_queue_init_done(q)) {
689 queue_flag_set_unlocked(QUEUE_FLAG_INIT_DONE, q);
Dan Williams3ef28e82015-10-21 13:20:12 -0400690 percpu_ref_switch_to_percpu(&q->q_usage_counter);
Alan Sterndf35c7c2014-09-09 11:50:58 -0400691 blk_queue_bypass_end(q);
692 }
Tejun Heo749fefe2012-09-20 14:08:52 -0700693
Li Zefan1d54ad62009-04-14 14:00:05 +0800694 ret = blk_trace_init_sysfs(dev);
695 if (ret)
696 return ret;
697
Linus Torvaldsc9059592009-06-11 10:52:27 -0700698 ret = kobject_add(&q->kobj, kobject_get(&dev->kobj), "%s", "queue");
Liu Yuaned5302d2011-04-19 13:47:58 +0200699 if (ret < 0) {
700 blk_trace_remove_sysfs(dev);
Jens Axboe8324aa92008-01-29 14:51:59 +0100701 return ret;
Liu Yuaned5302d2011-04-19 13:47:58 +0200702 }
Jens Axboe8324aa92008-01-29 14:51:59 +0100703
704 kobject_uevent(&q->kobj, KOBJ_ADD);
705
Jens Axboe320ae512013-10-24 09:20:05 +0100706 if (q->mq_ops)
Matias Bjørlingb21d5b32016-09-16 14:25:06 +0200707 blk_mq_register_dev(dev, q);
Jens Axboe320ae512013-10-24 09:20:05 +0100708
Martin K. Petersencd43e262009-05-22 17:17:52 -0400709 if (!q->request_fn)
710 return 0;
711
Jens Axboe8324aa92008-01-29 14:51:59 +0100712 ret = elv_register_queue(q);
713 if (ret) {
714 kobject_uevent(&q->kobj, KOBJ_REMOVE);
715 kobject_del(&q->kobj);
Liu Yuan80656b62011-04-13 22:14:54 +0200716 blk_trace_remove_sysfs(dev);
Xiaotian Fengc87ffbb2010-08-23 12:30:29 +0200717 kobject_put(&dev->kobj);
Jens Axboe8324aa92008-01-29 14:51:59 +0100718 return ret;
719 }
720
721 return 0;
722}
723
724void blk_unregister_queue(struct gendisk *disk)
725{
726 struct request_queue *q = disk->queue;
727
Akinobu Mitafb199742008-04-21 09:51:06 +0200728 if (WARN_ON(!q))
729 return;
730
Jens Axboe320ae512013-10-24 09:20:05 +0100731 if (q->mq_ops)
Matias Bjørlingb21d5b32016-09-16 14:25:06 +0200732 blk_mq_unregister_dev(disk_to_dev(disk), q);
Jens Axboe320ae512013-10-24 09:20:05 +0100733
Zdenek Kabelac48c0d4d2009-09-25 06:19:26 +0200734 if (q->request_fn)
Jens Axboe8324aa92008-01-29 14:51:59 +0100735 elv_unregister_queue(q);
736
Zdenek Kabelac48c0d4d2009-09-25 06:19:26 +0200737 kobject_uevent(&q->kobj, KOBJ_REMOVE);
738 kobject_del(&q->kobj);
739 blk_trace_remove_sysfs(disk_to_dev(disk));
740 kobject_put(&disk_to_dev(disk)->kobj);
Jens Axboe8324aa92008-01-29 14:51:59 +0100741}