blob: 3e44a9da2a13579cacaee3d5e03bb3868f34d02a [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 <<
79 (PAGE_CACHE_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
Jens Axboe8324aa92008-01-29 14:51:59 +010093 q->backing_dev_info.ra_pages = ra_kb >> (PAGE_CACHE_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
120 return queue_var_show(PAGE_CACHE_SIZE, (page));
121}
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{
150 unsigned long long val;
151
152 val = q->limits.max_hw_discard_sectors << 9;
153 return sprintf(page, "%llu\n", val);
154}
155
Martin K. Petersen86b37282009-11-10 11:50:21 +0100156static ssize_t queue_discard_max_show(struct request_queue *q, char *page)
157{
Martin K. Petersena934a002011-05-18 10:37:35 +0200158 return sprintf(page, "%llu\n",
159 (unsigned long long)q->limits.max_discard_sectors << 9);
Martin K. Petersen86b37282009-11-10 11:50:21 +0100160}
161
Jens Axboe0034af02015-07-16 09:14:26 -0600162static ssize_t queue_discard_max_store(struct request_queue *q,
163 const char *page, size_t count)
164{
165 unsigned long max_discard;
166 ssize_t ret = queue_var_store(&max_discard, page, count);
167
168 if (ret < 0)
169 return ret;
170
171 if (max_discard & (q->limits.discard_granularity - 1))
172 return -EINVAL;
173
174 max_discard >>= 9;
175 if (max_discard > UINT_MAX)
176 return -EINVAL;
177
178 if (max_discard > q->limits.max_hw_discard_sectors)
179 max_discard = q->limits.max_hw_discard_sectors;
180
181 q->limits.max_discard_sectors = max_discard;
182 return ret;
183}
184
Martin K. Petersen98262f22009-12-03 09:24:48 +0100185static ssize_t queue_discard_zeroes_data_show(struct request_queue *q, char *page)
186{
187 return queue_var_show(queue_discard_zeroes_data(q), page);
188}
189
Martin K. Petersen4363ac72012-09-18 12:19:27 -0400190static ssize_t queue_write_same_max_show(struct request_queue *q, char *page)
191{
192 return sprintf(page, "%llu\n",
193 (unsigned long long)q->limits.max_write_same_sectors << 9);
194}
195
196
Jens Axboe8324aa92008-01-29 14:51:59 +0100197static ssize_t
198queue_max_sectors_store(struct request_queue *q, const char *page, size_t count)
199{
200 unsigned long max_sectors_kb,
Martin K. Petersenae03bf62009-05-22 17:17:50 -0400201 max_hw_sectors_kb = queue_max_hw_sectors(q) >> 1,
Jens Axboe8324aa92008-01-29 14:51:59 +0100202 page_kb = 1 << (PAGE_CACHE_SHIFT - 10);
203 ssize_t ret = queue_var_store(&max_sectors_kb, page, count);
204
Dave Reisnerb1f3b642012-09-08 11:55:45 -0400205 if (ret < 0)
206 return ret;
207
Jens Axboe8324aa92008-01-29 14:51:59 +0100208 if (max_sectors_kb > max_hw_sectors_kb || max_sectors_kb < page_kb)
209 return -EINVAL;
Wu Fengguang7c239512008-11-25 09:08:39 +0100210
Jens Axboe8324aa92008-01-29 14:51:59 +0100211 spin_lock_irq(q->queue_lock);
Nikanth Karthikesanc295fc02009-09-01 22:40:15 +0200212 q->limits.max_sectors = max_sectors_kb << 1;
Jens Axboe8324aa92008-01-29 14:51:59 +0100213 spin_unlock_irq(q->queue_lock);
214
215 return ret;
216}
217
218static ssize_t queue_max_hw_sectors_show(struct request_queue *q, char *page)
219{
Martin K. Petersenae03bf62009-05-22 17:17:50 -0400220 int max_hw_sectors_kb = queue_max_hw_sectors(q) >> 1;
Jens Axboe8324aa92008-01-29 14:51:59 +0100221
222 return queue_var_show(max_hw_sectors_kb, (page));
223}
224
Jens Axboe956bcb72010-08-07 18:13:50 +0200225#define QUEUE_SYSFS_BIT_FNS(name, flag, neg) \
226static ssize_t \
227queue_show_##name(struct request_queue *q, char *page) \
228{ \
229 int bit; \
230 bit = test_bit(QUEUE_FLAG_##flag, &q->queue_flags); \
231 return queue_var_show(neg ? !bit : bit, page); \
232} \
233static ssize_t \
234queue_store_##name(struct request_queue *q, const char *page, size_t count) \
235{ \
236 unsigned long val; \
237 ssize_t ret; \
238 ret = queue_var_store(&val, page, count); \
Arnd Bergmannc678ef52013-04-03 21:53:57 +0200239 if (ret < 0) \
240 return ret; \
Jens Axboe956bcb72010-08-07 18:13:50 +0200241 if (neg) \
242 val = !val; \
243 \
244 spin_lock_irq(q->queue_lock); \
245 if (val) \
246 queue_flag_set(QUEUE_FLAG_##flag, q); \
247 else \
248 queue_flag_clear(QUEUE_FLAG_##flag, q); \
249 spin_unlock_irq(q->queue_lock); \
250 return ret; \
Bartlomiej Zolnierkiewicz1308835f2009-01-07 12:22:39 +0100251}
252
Jens Axboe956bcb72010-08-07 18:13:50 +0200253QUEUE_SYSFS_BIT_FNS(nonrot, NONROT, 1);
254QUEUE_SYSFS_BIT_FNS(random, ADD_RANDOM, 0);
255QUEUE_SYSFS_BIT_FNS(iostats, IO_STAT, 0);
256#undef QUEUE_SYSFS_BIT_FNS
Bartlomiej Zolnierkiewicz1308835f2009-01-07 12:22:39 +0100257
Alan D. Brunelleac9fafa2008-04-29 14:44:19 +0200258static ssize_t queue_nomerges_show(struct request_queue *q, char *page)
259{
Alan D. Brunelle488991e2010-01-29 09:04:08 +0100260 return queue_var_show((blk_queue_nomerges(q) << 1) |
261 blk_queue_noxmerges(q), page);
Alan D. Brunelleac9fafa2008-04-29 14:44:19 +0200262}
263
264static ssize_t queue_nomerges_store(struct request_queue *q, const char *page,
265 size_t count)
266{
267 unsigned long nm;
268 ssize_t ret = queue_var_store(&nm, page, count);
269
Dave Reisnerb1f3b642012-09-08 11:55:45 -0400270 if (ret < 0)
271 return ret;
272
Jens Axboebf0f9702008-05-07 09:09:39 +0200273 spin_lock_irq(q->queue_lock);
Alan D. Brunelle488991e2010-01-29 09:04:08 +0100274 queue_flag_clear(QUEUE_FLAG_NOMERGES, q);
275 queue_flag_clear(QUEUE_FLAG_NOXMERGES, q);
276 if (nm == 2)
Jens Axboebf0f9702008-05-07 09:09:39 +0200277 queue_flag_set(QUEUE_FLAG_NOMERGES, q);
Alan D. Brunelle488991e2010-01-29 09:04:08 +0100278 else if (nm)
279 queue_flag_set(QUEUE_FLAG_NOXMERGES, q);
Jens Axboebf0f9702008-05-07 09:09:39 +0200280 spin_unlock_irq(q->queue_lock);
Bartlomiej Zolnierkiewicz1308835f2009-01-07 12:22:39 +0100281
Alan D. Brunelleac9fafa2008-04-29 14:44:19 +0200282 return ret;
283}
284
Jens Axboec7c22e42008-09-13 20:26:01 +0200285static ssize_t queue_rq_affinity_show(struct request_queue *q, char *page)
286{
Xiaotian Feng9cb308c2009-07-17 15:26:26 +0800287 bool set = test_bit(QUEUE_FLAG_SAME_COMP, &q->queue_flags);
Dan Williams5757a6d2011-07-23 20:44:25 +0200288 bool force = test_bit(QUEUE_FLAG_SAME_FORCE, &q->queue_flags);
Jens Axboec7c22e42008-09-13 20:26:01 +0200289
Dan Williams5757a6d2011-07-23 20:44:25 +0200290 return queue_var_show(set << force, page);
Jens Axboec7c22e42008-09-13 20:26:01 +0200291}
292
293static ssize_t
294queue_rq_affinity_store(struct request_queue *q, const char *page, size_t count)
295{
296 ssize_t ret = -EINVAL;
Christoph Hellwig0a06ff02013-11-14 14:32:07 -0800297#ifdef CONFIG_SMP
Jens Axboec7c22e42008-09-13 20:26:01 +0200298 unsigned long val;
299
300 ret = queue_var_store(&val, page, count);
Dave Reisnerb1f3b642012-09-08 11:55:45 -0400301 if (ret < 0)
302 return ret;
303
Jens Axboec7c22e42008-09-13 20:26:01 +0200304 spin_lock_irq(q->queue_lock);
Eric Seppanene8037d42011-08-23 21:25:12 +0200305 if (val == 2) {
Jens Axboec7c22e42008-09-13 20:26:01 +0200306 queue_flag_set(QUEUE_FLAG_SAME_COMP, q);
Eric Seppanene8037d42011-08-23 21:25:12 +0200307 queue_flag_set(QUEUE_FLAG_SAME_FORCE, q);
308 } else if (val == 1) {
309 queue_flag_set(QUEUE_FLAG_SAME_COMP, q);
310 queue_flag_clear(QUEUE_FLAG_SAME_FORCE, q);
311 } else if (val == 0) {
Dan Williams5757a6d2011-07-23 20:44:25 +0200312 queue_flag_clear(QUEUE_FLAG_SAME_COMP, q);
313 queue_flag_clear(QUEUE_FLAG_SAME_FORCE, q);
314 }
Jens Axboec7c22e42008-09-13 20:26:01 +0200315 spin_unlock_irq(q->queue_lock);
316#endif
317 return ret;
318}
Jens Axboe8324aa92008-01-29 14:51:59 +0100319
320static struct queue_sysfs_entry queue_requests_entry = {
321 .attr = {.name = "nr_requests", .mode = S_IRUGO | S_IWUSR },
322 .show = queue_requests_show,
323 .store = queue_requests_store,
324};
325
326static struct queue_sysfs_entry queue_ra_entry = {
327 .attr = {.name = "read_ahead_kb", .mode = S_IRUGO | S_IWUSR },
328 .show = queue_ra_show,
329 .store = queue_ra_store,
330};
331
332static struct queue_sysfs_entry queue_max_sectors_entry = {
333 .attr = {.name = "max_sectors_kb", .mode = S_IRUGO | S_IWUSR },
334 .show = queue_max_sectors_show,
335 .store = queue_max_sectors_store,
336};
337
338static struct queue_sysfs_entry queue_max_hw_sectors_entry = {
339 .attr = {.name = "max_hw_sectors_kb", .mode = S_IRUGO },
340 .show = queue_max_hw_sectors_show,
341};
342
Martin K. Petersenc77a5712010-03-10 00:48:33 -0500343static struct queue_sysfs_entry queue_max_segments_entry = {
344 .attr = {.name = "max_segments", .mode = S_IRUGO },
345 .show = queue_max_segments_show,
346};
347
Martin K. Petersen13f05c82010-09-10 20:50:10 +0200348static struct queue_sysfs_entry queue_max_integrity_segments_entry = {
349 .attr = {.name = "max_integrity_segments", .mode = S_IRUGO },
350 .show = queue_max_integrity_segments_show,
351};
352
Martin K. Petersenc77a5712010-03-10 00:48:33 -0500353static struct queue_sysfs_entry queue_max_segment_size_entry = {
354 .attr = {.name = "max_segment_size", .mode = S_IRUGO },
355 .show = queue_max_segment_size_show,
356};
357
Jens Axboe8324aa92008-01-29 14:51:59 +0100358static struct queue_sysfs_entry queue_iosched_entry = {
359 .attr = {.name = "scheduler", .mode = S_IRUGO | S_IWUSR },
360 .show = elv_iosched_show,
361 .store = elv_iosched_store,
362};
363
Martin K. Petersene68b9032008-01-29 19:14:08 +0100364static struct queue_sysfs_entry queue_hw_sector_size_entry = {
365 .attr = {.name = "hw_sector_size", .mode = S_IRUGO },
Martin K. Petersene1defc42009-05-22 17:17:49 -0400366 .show = queue_logical_block_size_show,
367};
368
369static struct queue_sysfs_entry queue_logical_block_size_entry = {
370 .attr = {.name = "logical_block_size", .mode = S_IRUGO },
371 .show = queue_logical_block_size_show,
Martin K. Petersene68b9032008-01-29 19:14:08 +0100372};
373
Martin K. Petersenc72758f2009-05-22 17:17:53 -0400374static struct queue_sysfs_entry queue_physical_block_size_entry = {
375 .attr = {.name = "physical_block_size", .mode = S_IRUGO },
376 .show = queue_physical_block_size_show,
377};
378
379static struct queue_sysfs_entry queue_io_min_entry = {
380 .attr = {.name = "minimum_io_size", .mode = S_IRUGO },
381 .show = queue_io_min_show,
382};
383
384static struct queue_sysfs_entry queue_io_opt_entry = {
385 .attr = {.name = "optimal_io_size", .mode = S_IRUGO },
386 .show = queue_io_opt_show,
Jens Axboe8324aa92008-01-29 14:51:59 +0100387};
388
Martin K. Petersen86b37282009-11-10 11:50:21 +0100389static struct queue_sysfs_entry queue_discard_granularity_entry = {
390 .attr = {.name = "discard_granularity", .mode = S_IRUGO },
391 .show = queue_discard_granularity_show,
392};
393
Jens Axboe0034af02015-07-16 09:14:26 -0600394static struct queue_sysfs_entry queue_discard_max_hw_entry = {
395 .attr = {.name = "discard_max_hw_bytes", .mode = S_IRUGO },
396 .show = queue_discard_max_hw_show,
397};
398
Martin K. Petersen86b37282009-11-10 11:50:21 +0100399static struct queue_sysfs_entry queue_discard_max_entry = {
Jens Axboe0034af02015-07-16 09:14:26 -0600400 .attr = {.name = "discard_max_bytes", .mode = S_IRUGO | S_IWUSR },
Martin K. Petersen86b37282009-11-10 11:50:21 +0100401 .show = queue_discard_max_show,
Jens Axboe0034af02015-07-16 09:14:26 -0600402 .store = queue_discard_max_store,
Martin K. Petersen86b37282009-11-10 11:50:21 +0100403};
404
Martin K. Petersen98262f22009-12-03 09:24:48 +0100405static struct queue_sysfs_entry queue_discard_zeroes_data_entry = {
406 .attr = {.name = "discard_zeroes_data", .mode = S_IRUGO },
407 .show = queue_discard_zeroes_data_show,
408};
409
Martin K. Petersen4363ac72012-09-18 12:19:27 -0400410static struct queue_sysfs_entry queue_write_same_max_entry = {
411 .attr = {.name = "write_same_max_bytes", .mode = S_IRUGO },
412 .show = queue_write_same_max_show,
413};
414
Bartlomiej Zolnierkiewicz1308835f2009-01-07 12:22:39 +0100415static struct queue_sysfs_entry queue_nonrot_entry = {
416 .attr = {.name = "rotational", .mode = S_IRUGO | S_IWUSR },
Jens Axboe956bcb72010-08-07 18:13:50 +0200417 .show = queue_show_nonrot,
418 .store = queue_store_nonrot,
Bartlomiej Zolnierkiewicz1308835f2009-01-07 12:22:39 +0100419};
420
Alan D. Brunelleac9fafa2008-04-29 14:44:19 +0200421static struct queue_sysfs_entry queue_nomerges_entry = {
422 .attr = {.name = "nomerges", .mode = S_IRUGO | S_IWUSR },
423 .show = queue_nomerges_show,
424 .store = queue_nomerges_store,
425};
426
Jens Axboec7c22e42008-09-13 20:26:01 +0200427static struct queue_sysfs_entry queue_rq_affinity_entry = {
428 .attr = {.name = "rq_affinity", .mode = S_IRUGO | S_IWUSR },
429 .show = queue_rq_affinity_show,
430 .store = queue_rq_affinity_store,
431};
432
Jens Axboebc58ba92009-01-23 10:54:44 +0100433static struct queue_sysfs_entry queue_iostats_entry = {
434 .attr = {.name = "iostats", .mode = S_IRUGO | S_IWUSR },
Jens Axboe956bcb72010-08-07 18:13:50 +0200435 .show = queue_show_iostats,
436 .store = queue_store_iostats,
Jens Axboebc58ba92009-01-23 10:54:44 +0100437};
438
Jens Axboee2e1a142010-06-09 10:42:09 +0200439static struct queue_sysfs_entry queue_random_entry = {
440 .attr = {.name = "add_random", .mode = S_IRUGO | S_IWUSR },
Jens Axboe956bcb72010-08-07 18:13:50 +0200441 .show = queue_show_random,
442 .store = queue_store_random,
Jens Axboee2e1a142010-06-09 10:42:09 +0200443};
444
Jens Axboe8324aa92008-01-29 14:51:59 +0100445static struct attribute *default_attrs[] = {
446 &queue_requests_entry.attr,
447 &queue_ra_entry.attr,
448 &queue_max_hw_sectors_entry.attr,
449 &queue_max_sectors_entry.attr,
Martin K. Petersenc77a5712010-03-10 00:48:33 -0500450 &queue_max_segments_entry.attr,
Martin K. Petersen13f05c82010-09-10 20:50:10 +0200451 &queue_max_integrity_segments_entry.attr,
Martin K. Petersenc77a5712010-03-10 00:48:33 -0500452 &queue_max_segment_size_entry.attr,
Jens Axboe8324aa92008-01-29 14:51:59 +0100453 &queue_iosched_entry.attr,
Martin K. Petersene68b9032008-01-29 19:14:08 +0100454 &queue_hw_sector_size_entry.attr,
Martin K. Petersene1defc42009-05-22 17:17:49 -0400455 &queue_logical_block_size_entry.attr,
Martin K. Petersenc72758f2009-05-22 17:17:53 -0400456 &queue_physical_block_size_entry.attr,
457 &queue_io_min_entry.attr,
458 &queue_io_opt_entry.attr,
Martin K. Petersen86b37282009-11-10 11:50:21 +0100459 &queue_discard_granularity_entry.attr,
460 &queue_discard_max_entry.attr,
Jens Axboe0034af02015-07-16 09:14:26 -0600461 &queue_discard_max_hw_entry.attr,
Martin K. Petersen98262f22009-12-03 09:24:48 +0100462 &queue_discard_zeroes_data_entry.attr,
Martin K. Petersen4363ac72012-09-18 12:19:27 -0400463 &queue_write_same_max_entry.attr,
Bartlomiej Zolnierkiewicz1308835f2009-01-07 12:22:39 +0100464 &queue_nonrot_entry.attr,
Alan D. Brunelleac9fafa2008-04-29 14:44:19 +0200465 &queue_nomerges_entry.attr,
Jens Axboec7c22e42008-09-13 20:26:01 +0200466 &queue_rq_affinity_entry.attr,
Jens Axboebc58ba92009-01-23 10:54:44 +0100467 &queue_iostats_entry.attr,
Jens Axboee2e1a142010-06-09 10:42:09 +0200468 &queue_random_entry.attr,
Jens Axboe8324aa92008-01-29 14:51:59 +0100469 NULL,
470};
471
472#define to_queue(atr) container_of((atr), struct queue_sysfs_entry, attr)
473
474static ssize_t
475queue_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
476{
477 struct queue_sysfs_entry *entry = to_queue(attr);
478 struct request_queue *q =
479 container_of(kobj, struct request_queue, kobj);
480 ssize_t res;
481
482 if (!entry->show)
483 return -EIO;
484 mutex_lock(&q->sysfs_lock);
Bart Van Assche3f3299d2012-11-28 13:42:38 +0100485 if (blk_queue_dying(q)) {
Jens Axboe8324aa92008-01-29 14:51:59 +0100486 mutex_unlock(&q->sysfs_lock);
487 return -ENOENT;
488 }
489 res = entry->show(q, page);
490 mutex_unlock(&q->sysfs_lock);
491 return res;
492}
493
494static ssize_t
495queue_attr_store(struct kobject *kobj, struct attribute *attr,
496 const char *page, size_t length)
497{
498 struct queue_sysfs_entry *entry = to_queue(attr);
Jens Axboe6728cb02008-01-31 13:03:55 +0100499 struct request_queue *q;
Jens Axboe8324aa92008-01-29 14:51:59 +0100500 ssize_t res;
501
502 if (!entry->store)
503 return -EIO;
Jens Axboe6728cb02008-01-31 13:03:55 +0100504
505 q = container_of(kobj, struct request_queue, kobj);
Jens Axboe8324aa92008-01-29 14:51:59 +0100506 mutex_lock(&q->sysfs_lock);
Bart Van Assche3f3299d2012-11-28 13:42:38 +0100507 if (blk_queue_dying(q)) {
Jens Axboe8324aa92008-01-29 14:51:59 +0100508 mutex_unlock(&q->sysfs_lock);
509 return -ENOENT;
510 }
511 res = entry->store(q, page, length);
512 mutex_unlock(&q->sysfs_lock);
513 return res;
514}
515
Tejun Heo548bc8e2013-01-09 08:05:13 -0800516static void blk_free_queue_rcu(struct rcu_head *rcu_head)
517{
518 struct request_queue *q = container_of(rcu_head, struct request_queue,
519 rcu_head);
520 kmem_cache_free(blk_requestq_cachep, q);
521}
522
Jens Axboe8324aa92008-01-29 14:51:59 +0100523/**
Andrew Morton499337b2011-09-21 10:01:22 +0200524 * blk_release_queue: - release a &struct request_queue when it is no longer needed
525 * @kobj: the kobj belonging to the request queue to be released
Jens Axboe8324aa92008-01-29 14:51:59 +0100526 *
527 * Description:
Andrew Morton499337b2011-09-21 10:01:22 +0200528 * blk_release_queue is the pair to blk_init_queue() or
Jens Axboe8324aa92008-01-29 14:51:59 +0100529 * blk_queue_make_request(). It should be called when a request queue is
530 * being released; typically when a block device is being de-registered.
531 * Currently, its primary task it to free all the &struct request
532 * structures that were allocated to the queue and the queue itself.
533 *
Bart Van Assche45a9c9d2014-12-09 16:57:48 +0100534 * Note:
535 * The low level driver must have finished any outstanding requests first
536 * via blk_cleanup_queue().
Jens Axboe8324aa92008-01-29 14:51:59 +0100537 **/
538static void blk_release_queue(struct kobject *kobj)
539{
540 struct request_queue *q =
541 container_of(kobj, struct request_queue, kobj);
Jens Axboe8324aa92008-01-29 14:51:59 +0100542
Tejun Heoe8989fa2012-03-05 13:15:20 -0800543 blkcg_exit_queue(q);
544
Tejun Heo7e5a8792011-12-14 00:33:42 +0100545 if (q->elevator) {
546 spin_lock_irq(q->queue_lock);
547 ioc_clear_queue(q);
548 spin_unlock_irq(q->queue_lock);
Hannes Reinecke777eb1b2011-09-28 08:07:01 -0600549 elevator_exit(q->elevator);
Tejun Heo7e5a8792011-12-14 00:33:42 +0100550 }
Hannes Reinecke777eb1b2011-09-28 08:07:01 -0600551
Tejun Heoa0516612012-06-26 15:05:44 -0700552 blk_exit_rl(&q->root_rl);
Jens Axboe8324aa92008-01-29 14:51:59 +0100553
554 if (q->queue_tags)
555 __blk_queue_free_tags(q);
556
Bart Van Assche45a9c9d2014-12-09 16:57:48 +0100557 if (!q->mq_ops)
Ming Leif70ced02014-09-25 23:23:47 +0800558 blk_free_flush_queue(q->fq);
Ming Leie09aae72015-01-29 20:17:27 +0800559 else
560 blk_mq_release(q);
Christoph Hellwig18741982014-02-10 09:29:00 -0700561
Jens Axboe8324aa92008-01-29 14:51:59 +0100562 blk_trace_shutdown(q);
563
Kent Overstreet54efd502015-04-23 22:37:18 -0700564 if (q->bio_split)
565 bioset_free(q->bio_split);
566
Tejun Heoa73f7302011-12-14 00:33:37 +0100567 ida_simple_remove(&blk_queue_ida, q->id);
Tejun Heo548bc8e2013-01-09 08:05:13 -0800568 call_rcu(&q->rcu_head, blk_free_queue_rcu);
Jens Axboe8324aa92008-01-29 14:51:59 +0100569}
570
Emese Revfy52cf25d2010-01-19 02:58:23 +0100571static const struct sysfs_ops queue_sysfs_ops = {
Jens Axboe8324aa92008-01-29 14:51:59 +0100572 .show = queue_attr_show,
573 .store = queue_attr_store,
574};
575
576struct kobj_type blk_queue_ktype = {
577 .sysfs_ops = &queue_sysfs_ops,
578 .default_attrs = default_attrs,
579 .release = blk_release_queue,
580};
581
582int blk_register_queue(struct gendisk *disk)
583{
584 int ret;
Li Zefan1d54ad62009-04-14 14:00:05 +0800585 struct device *dev = disk_to_dev(disk);
Jens Axboe8324aa92008-01-29 14:51:59 +0100586 struct request_queue *q = disk->queue;
587
Akinobu Mitafb199742008-04-21 09:51:06 +0200588 if (WARN_ON(!q))
Jens Axboe8324aa92008-01-29 14:51:59 +0100589 return -ENXIO;
590
Tejun Heo749fefe2012-09-20 14:08:52 -0700591 /*
Tejun Heo17497ac2014-09-24 13:31:50 -0400592 * SCSI probing may synchronously create and destroy a lot of
593 * request_queues for non-existent devices. Shutting down a fully
594 * functional queue takes measureable wallclock time as RCU grace
595 * periods are involved. To avoid excessive latency in these
596 * cases, a request_queue starts out in a degraded mode which is
597 * faster to shut down and is made fully functional here as
598 * request_queues for non-existent devices never get registered.
Tejun Heo749fefe2012-09-20 14:08:52 -0700599 */
Alan Sterndf35c7c2014-09-09 11:50:58 -0400600 if (!blk_queue_init_done(q)) {
601 queue_flag_set_unlocked(QUEUE_FLAG_INIT_DONE, q);
602 blk_queue_bypass_end(q);
Tejun Heo17497ac2014-09-24 13:31:50 -0400603 if (q->mq_ops)
604 blk_mq_finish_init(q);
Alan Sterndf35c7c2014-09-09 11:50:58 -0400605 }
Tejun Heo749fefe2012-09-20 14:08:52 -0700606
Li Zefan1d54ad62009-04-14 14:00:05 +0800607 ret = blk_trace_init_sysfs(dev);
608 if (ret)
609 return ret;
610
Linus Torvaldsc9059592009-06-11 10:52:27 -0700611 ret = kobject_add(&q->kobj, kobject_get(&dev->kobj), "%s", "queue");
Liu Yuaned5302d2011-04-19 13:47:58 +0200612 if (ret < 0) {
613 blk_trace_remove_sysfs(dev);
Jens Axboe8324aa92008-01-29 14:51:59 +0100614 return ret;
Liu Yuaned5302d2011-04-19 13:47:58 +0200615 }
Jens Axboe8324aa92008-01-29 14:51:59 +0100616
617 kobject_uevent(&q->kobj, KOBJ_ADD);
618
Jens Axboe320ae512013-10-24 09:20:05 +0100619 if (q->mq_ops)
620 blk_mq_register_disk(disk);
621
Martin K. Petersencd43e262009-05-22 17:17:52 -0400622 if (!q->request_fn)
623 return 0;
624
Jens Axboe8324aa92008-01-29 14:51:59 +0100625 ret = elv_register_queue(q);
626 if (ret) {
627 kobject_uevent(&q->kobj, KOBJ_REMOVE);
628 kobject_del(&q->kobj);
Liu Yuan80656b62011-04-13 22:14:54 +0200629 blk_trace_remove_sysfs(dev);
Xiaotian Fengc87ffbb2010-08-23 12:30:29 +0200630 kobject_put(&dev->kobj);
Jens Axboe8324aa92008-01-29 14:51:59 +0100631 return ret;
632 }
633
634 return 0;
635}
636
637void blk_unregister_queue(struct gendisk *disk)
638{
639 struct request_queue *q = disk->queue;
640
Akinobu Mitafb199742008-04-21 09:51:06 +0200641 if (WARN_ON(!q))
642 return;
643
Jens Axboe320ae512013-10-24 09:20:05 +0100644 if (q->mq_ops)
645 blk_mq_unregister_disk(disk);
646
Zdenek Kabelac48c0d4d2009-09-25 06:19:26 +0200647 if (q->request_fn)
Jens Axboe8324aa92008-01-29 14:51:59 +0100648 elv_unregister_queue(q);
649
Zdenek Kabelac48c0d4d2009-09-25 06:19:26 +0200650 kobject_uevent(&q->kobj, KOBJ_REMOVE);
651 kobject_del(&q->kobj);
652 blk_trace_remove_sysfs(disk_to_dev(disk));
653 kobject_put(&disk_to_dev(disk)->kobj);
Jens Axboe8324aa92008-01-29 14:51:59 +0100654}