blob: 8095c4a21fc0f53e6e46ff191de283500dcc97de [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>
9#include <linux/blktrace_api.h>
Jens Axboe320ae512013-10-24 09:20:05 +010010#include <linux/blk-mq.h>
Jens Axboe8324aa92008-01-29 14:51:59 +010011
12#include "blk.h"
Tejun Heo5efd6112012-03-05 13:15:12 -080013#include "blk-cgroup.h"
Ming Lei3edcc0c2013-12-26 21:31:38 +080014#include "blk-mq.h"
Jens Axboe8324aa92008-01-29 14:51:59 +010015
16struct queue_sysfs_entry {
17 struct attribute attr;
18 ssize_t (*show)(struct request_queue *, char *);
19 ssize_t (*store)(struct request_queue *, const char *, size_t);
20};
21
22static ssize_t
Xiaotian Feng9cb308c2009-07-17 15:26:26 +080023queue_var_show(unsigned long var, char *page)
Jens Axboe8324aa92008-01-29 14:51:59 +010024{
Xiaotian Feng9cb308c2009-07-17 15:26:26 +080025 return sprintf(page, "%lu\n", var);
Jens Axboe8324aa92008-01-29 14:51:59 +010026}
27
28static ssize_t
29queue_var_store(unsigned long *var, const char *page, size_t count)
30{
Dave Reisnerb1f3b642012-09-08 11:55:45 -040031 int err;
32 unsigned long v;
Jens Axboe8324aa92008-01-29 14:51:59 +010033
Jingoo Haned751e62013-09-11 14:20:08 -070034 err = kstrtoul(page, 10, &v);
Dave Reisnerb1f3b642012-09-08 11:55:45 -040035 if (err || v > UINT_MAX)
36 return -EINVAL;
37
38 *var = v;
39
Jens Axboe8324aa92008-01-29 14:51:59 +010040 return count;
41}
42
43static ssize_t queue_requests_show(struct request_queue *q, char *page)
44{
45 return queue_var_show(q->nr_requests, (page));
46}
47
48static ssize_t
49queue_requests_store(struct request_queue *q, const char *page, size_t count)
50{
Tejun Heoa0516612012-06-26 15:05:44 -070051 struct request_list *rl;
Jens Axboe8324aa92008-01-29 14:51:59 +010052 unsigned long nr;
Jens Axboeb8a9ae72009-09-11 22:44:29 +020053 int ret;
54
55 if (!q->request_fn)
56 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
65 spin_lock_irq(q->queue_lock);
66 q->nr_requests = nr;
67 blk_queue_congestion_threshold(q);
68
Tejun Heoa0516612012-06-26 15:05:44 -070069 /* congestion isn't cgroup aware and follows root blkcg for now */
70 rl = &q->root_rl;
71
Jens Axboe1faa16d2009-04-06 14:48:01 +020072 if (rl->count[BLK_RW_SYNC] >= queue_congestion_on_threshold(q))
73 blk_set_queue_congested(q, BLK_RW_SYNC);
74 else if (rl->count[BLK_RW_SYNC] < queue_congestion_off_threshold(q))
75 blk_clear_queue_congested(q, BLK_RW_SYNC);
Jens Axboe8324aa92008-01-29 14:51:59 +010076
Jens Axboe1faa16d2009-04-06 14:48:01 +020077 if (rl->count[BLK_RW_ASYNC] >= queue_congestion_on_threshold(q))
78 blk_set_queue_congested(q, BLK_RW_ASYNC);
79 else if (rl->count[BLK_RW_ASYNC] < queue_congestion_off_threshold(q))
80 blk_clear_queue_congested(q, BLK_RW_ASYNC);
Jens Axboe8324aa92008-01-29 14:51:59 +010081
Tejun Heoa0516612012-06-26 15:05:44 -070082 blk_queue_for_each_rl(rl, q) {
83 if (rl->count[BLK_RW_SYNC] >= q->nr_requests) {
84 blk_set_rl_full(rl, BLK_RW_SYNC);
85 } else {
86 blk_clear_rl_full(rl, BLK_RW_SYNC);
87 wake_up(&rl->wait[BLK_RW_SYNC]);
88 }
89
90 if (rl->count[BLK_RW_ASYNC] >= q->nr_requests) {
91 blk_set_rl_full(rl, BLK_RW_ASYNC);
92 } else {
93 blk_clear_rl_full(rl, BLK_RW_ASYNC);
94 wake_up(&rl->wait[BLK_RW_ASYNC]);
95 }
Jens Axboe8324aa92008-01-29 14:51:59 +010096 }
97
Jens Axboe8324aa92008-01-29 14:51:59 +010098 spin_unlock_irq(q->queue_lock);
99 return ret;
100}
101
102static ssize_t queue_ra_show(struct request_queue *q, char *page)
103{
Xiaotian Feng9cb308c2009-07-17 15:26:26 +0800104 unsigned long ra_kb = q->backing_dev_info.ra_pages <<
105 (PAGE_CACHE_SHIFT - 10);
Jens Axboe8324aa92008-01-29 14:51:59 +0100106
107 return queue_var_show(ra_kb, (page));
108}
109
110static ssize_t
111queue_ra_store(struct request_queue *q, const char *page, size_t count)
112{
113 unsigned long ra_kb;
114 ssize_t ret = queue_var_store(&ra_kb, page, count);
115
Dave Reisnerb1f3b642012-09-08 11:55:45 -0400116 if (ret < 0)
117 return ret;
118
Jens Axboe8324aa92008-01-29 14:51:59 +0100119 q->backing_dev_info.ra_pages = ra_kb >> (PAGE_CACHE_SHIFT - 10);
Jens Axboe8324aa92008-01-29 14:51:59 +0100120
121 return ret;
122}
123
124static ssize_t queue_max_sectors_show(struct request_queue *q, char *page)
125{
Martin K. Petersenae03bf62009-05-22 17:17:50 -0400126 int max_sectors_kb = queue_max_sectors(q) >> 1;
Jens Axboe8324aa92008-01-29 14:51:59 +0100127
128 return queue_var_show(max_sectors_kb, (page));
129}
130
Martin K. Petersenc77a5712010-03-10 00:48:33 -0500131static ssize_t queue_max_segments_show(struct request_queue *q, char *page)
132{
133 return queue_var_show(queue_max_segments(q), (page));
134}
135
Martin K. Petersen13f05c82010-09-10 20:50:10 +0200136static ssize_t queue_max_integrity_segments_show(struct request_queue *q, char *page)
137{
138 return queue_var_show(q->limits.max_integrity_segments, (page));
139}
140
Martin K. Petersenc77a5712010-03-10 00:48:33 -0500141static ssize_t queue_max_segment_size_show(struct request_queue *q, char *page)
142{
Martin K. Petersene692cb62010-12-01 19:41:49 +0100143 if (blk_queue_cluster(q))
Martin K. Petersenc77a5712010-03-10 00:48:33 -0500144 return queue_var_show(queue_max_segment_size(q), (page));
145
146 return queue_var_show(PAGE_CACHE_SIZE, (page));
147}
148
Martin K. Petersene1defc42009-05-22 17:17:49 -0400149static ssize_t queue_logical_block_size_show(struct request_queue *q, char *page)
Martin K. Petersene68b9032008-01-29 19:14:08 +0100150{
Martin K. Petersene1defc42009-05-22 17:17:49 -0400151 return queue_var_show(queue_logical_block_size(q), page);
Martin K. Petersene68b9032008-01-29 19:14:08 +0100152}
153
Martin K. Petersenc72758f2009-05-22 17:17:53 -0400154static ssize_t queue_physical_block_size_show(struct request_queue *q, char *page)
155{
156 return queue_var_show(queue_physical_block_size(q), page);
157}
158
159static ssize_t queue_io_min_show(struct request_queue *q, char *page)
160{
161 return queue_var_show(queue_io_min(q), page);
162}
163
164static ssize_t queue_io_opt_show(struct request_queue *q, char *page)
165{
166 return queue_var_show(queue_io_opt(q), page);
Jens Axboe8324aa92008-01-29 14:51:59 +0100167}
168
Martin K. Petersen86b37282009-11-10 11:50:21 +0100169static ssize_t queue_discard_granularity_show(struct request_queue *q, char *page)
170{
171 return queue_var_show(q->limits.discard_granularity, page);
172}
173
174static ssize_t queue_discard_max_show(struct request_queue *q, char *page)
175{
Martin K. Petersena934a002011-05-18 10:37:35 +0200176 return sprintf(page, "%llu\n",
177 (unsigned long long)q->limits.max_discard_sectors << 9);
Martin K. Petersen86b37282009-11-10 11:50:21 +0100178}
179
Martin K. Petersen98262f22009-12-03 09:24:48 +0100180static ssize_t queue_discard_zeroes_data_show(struct request_queue *q, char *page)
181{
182 return queue_var_show(queue_discard_zeroes_data(q), page);
183}
184
Martin K. Petersen4363ac72012-09-18 12:19:27 -0400185static ssize_t queue_write_same_max_show(struct request_queue *q, char *page)
186{
187 return sprintf(page, "%llu\n",
188 (unsigned long long)q->limits.max_write_same_sectors << 9);
189}
190
191
Jens Axboe8324aa92008-01-29 14:51:59 +0100192static ssize_t
193queue_max_sectors_store(struct request_queue *q, const char *page, size_t count)
194{
195 unsigned long max_sectors_kb,
Martin K. Petersenae03bf62009-05-22 17:17:50 -0400196 max_hw_sectors_kb = queue_max_hw_sectors(q) >> 1,
Jens Axboe8324aa92008-01-29 14:51:59 +0100197 page_kb = 1 << (PAGE_CACHE_SHIFT - 10);
198 ssize_t ret = queue_var_store(&max_sectors_kb, page, count);
199
Dave Reisnerb1f3b642012-09-08 11:55:45 -0400200 if (ret < 0)
201 return ret;
202
Jens Axboe8324aa92008-01-29 14:51:59 +0100203 if (max_sectors_kb > max_hw_sectors_kb || max_sectors_kb < page_kb)
204 return -EINVAL;
Wu Fengguang7c239512008-11-25 09:08:39 +0100205
Jens Axboe8324aa92008-01-29 14:51:59 +0100206 spin_lock_irq(q->queue_lock);
Nikanth Karthikesanc295fc02009-09-01 22:40:15 +0200207 q->limits.max_sectors = max_sectors_kb << 1;
Jens Axboe8324aa92008-01-29 14:51:59 +0100208 spin_unlock_irq(q->queue_lock);
209
210 return ret;
211}
212
213static ssize_t queue_max_hw_sectors_show(struct request_queue *q, char *page)
214{
Martin K. Petersenae03bf62009-05-22 17:17:50 -0400215 int max_hw_sectors_kb = queue_max_hw_sectors(q) >> 1;
Jens Axboe8324aa92008-01-29 14:51:59 +0100216
217 return queue_var_show(max_hw_sectors_kb, (page));
218}
219
Jens Axboe956bcb72010-08-07 18:13:50 +0200220#define QUEUE_SYSFS_BIT_FNS(name, flag, neg) \
221static ssize_t \
222queue_show_##name(struct request_queue *q, char *page) \
223{ \
224 int bit; \
225 bit = test_bit(QUEUE_FLAG_##flag, &q->queue_flags); \
226 return queue_var_show(neg ? !bit : bit, page); \
227} \
228static ssize_t \
229queue_store_##name(struct request_queue *q, const char *page, size_t count) \
230{ \
231 unsigned long val; \
232 ssize_t ret; \
233 ret = queue_var_store(&val, page, count); \
Arnd Bergmannc678ef52013-04-03 21:53:57 +0200234 if (ret < 0) \
235 return ret; \
Jens Axboe956bcb72010-08-07 18:13:50 +0200236 if (neg) \
237 val = !val; \
238 \
239 spin_lock_irq(q->queue_lock); \
240 if (val) \
241 queue_flag_set(QUEUE_FLAG_##flag, q); \
242 else \
243 queue_flag_clear(QUEUE_FLAG_##flag, q); \
244 spin_unlock_irq(q->queue_lock); \
245 return ret; \
Bartlomiej Zolnierkiewicz1308835f2009-01-07 12:22:39 +0100246}
247
Jens Axboe956bcb72010-08-07 18:13:50 +0200248QUEUE_SYSFS_BIT_FNS(nonrot, NONROT, 1);
249QUEUE_SYSFS_BIT_FNS(random, ADD_RANDOM, 0);
250QUEUE_SYSFS_BIT_FNS(iostats, IO_STAT, 0);
251#undef QUEUE_SYSFS_BIT_FNS
Bartlomiej Zolnierkiewicz1308835f2009-01-07 12:22:39 +0100252
Alan D. Brunelleac9fafa2008-04-29 14:44:19 +0200253static ssize_t queue_nomerges_show(struct request_queue *q, char *page)
254{
Alan D. Brunelle488991e2010-01-29 09:04:08 +0100255 return queue_var_show((blk_queue_nomerges(q) << 1) |
256 blk_queue_noxmerges(q), page);
Alan D. Brunelleac9fafa2008-04-29 14:44:19 +0200257}
258
259static ssize_t queue_nomerges_store(struct request_queue *q, const char *page,
260 size_t count)
261{
262 unsigned long nm;
263 ssize_t ret = queue_var_store(&nm, page, count);
264
Dave Reisnerb1f3b642012-09-08 11:55:45 -0400265 if (ret < 0)
266 return ret;
267
Jens Axboebf0f9702008-05-07 09:09:39 +0200268 spin_lock_irq(q->queue_lock);
Alan D. Brunelle488991e2010-01-29 09:04:08 +0100269 queue_flag_clear(QUEUE_FLAG_NOMERGES, q);
270 queue_flag_clear(QUEUE_FLAG_NOXMERGES, q);
271 if (nm == 2)
Jens Axboebf0f9702008-05-07 09:09:39 +0200272 queue_flag_set(QUEUE_FLAG_NOMERGES, q);
Alan D. Brunelle488991e2010-01-29 09:04:08 +0100273 else if (nm)
274 queue_flag_set(QUEUE_FLAG_NOXMERGES, q);
Jens Axboebf0f9702008-05-07 09:09:39 +0200275 spin_unlock_irq(q->queue_lock);
Bartlomiej Zolnierkiewicz1308835f2009-01-07 12:22:39 +0100276
Alan D. Brunelleac9fafa2008-04-29 14:44:19 +0200277 return ret;
278}
279
Jens Axboec7c22e42008-09-13 20:26:01 +0200280static ssize_t queue_rq_affinity_show(struct request_queue *q, char *page)
281{
Xiaotian Feng9cb308c2009-07-17 15:26:26 +0800282 bool set = test_bit(QUEUE_FLAG_SAME_COMP, &q->queue_flags);
Dan Williams5757a6d2011-07-23 20:44:25 +0200283 bool force = test_bit(QUEUE_FLAG_SAME_FORCE, &q->queue_flags);
Jens Axboec7c22e42008-09-13 20:26:01 +0200284
Dan Williams5757a6d2011-07-23 20:44:25 +0200285 return queue_var_show(set << force, page);
Jens Axboec7c22e42008-09-13 20:26:01 +0200286}
287
288static ssize_t
289queue_rq_affinity_store(struct request_queue *q, const char *page, size_t count)
290{
291 ssize_t ret = -EINVAL;
Christoph Hellwig0a06ff02013-11-14 14:32:07 -0800292#ifdef CONFIG_SMP
Jens Axboec7c22e42008-09-13 20:26:01 +0200293 unsigned long val;
294
295 ret = queue_var_store(&val, page, count);
Dave Reisnerb1f3b642012-09-08 11:55:45 -0400296 if (ret < 0)
297 return ret;
298
Jens Axboec7c22e42008-09-13 20:26:01 +0200299 spin_lock_irq(q->queue_lock);
Eric Seppanene8037d42011-08-23 21:25:12 +0200300 if (val == 2) {
Jens Axboec7c22e42008-09-13 20:26:01 +0200301 queue_flag_set(QUEUE_FLAG_SAME_COMP, q);
Eric Seppanene8037d42011-08-23 21:25:12 +0200302 queue_flag_set(QUEUE_FLAG_SAME_FORCE, q);
303 } else if (val == 1) {
304 queue_flag_set(QUEUE_FLAG_SAME_COMP, q);
305 queue_flag_clear(QUEUE_FLAG_SAME_FORCE, q);
306 } else if (val == 0) {
Dan Williams5757a6d2011-07-23 20:44:25 +0200307 queue_flag_clear(QUEUE_FLAG_SAME_COMP, q);
308 queue_flag_clear(QUEUE_FLAG_SAME_FORCE, q);
309 }
Jens Axboec7c22e42008-09-13 20:26:01 +0200310 spin_unlock_irq(q->queue_lock);
311#endif
312 return ret;
313}
Jens Axboe8324aa92008-01-29 14:51:59 +0100314
315static struct queue_sysfs_entry queue_requests_entry = {
316 .attr = {.name = "nr_requests", .mode = S_IRUGO | S_IWUSR },
317 .show = queue_requests_show,
318 .store = queue_requests_store,
319};
320
321static struct queue_sysfs_entry queue_ra_entry = {
322 .attr = {.name = "read_ahead_kb", .mode = S_IRUGO | S_IWUSR },
323 .show = queue_ra_show,
324 .store = queue_ra_store,
325};
326
327static struct queue_sysfs_entry queue_max_sectors_entry = {
328 .attr = {.name = "max_sectors_kb", .mode = S_IRUGO | S_IWUSR },
329 .show = queue_max_sectors_show,
330 .store = queue_max_sectors_store,
331};
332
333static struct queue_sysfs_entry queue_max_hw_sectors_entry = {
334 .attr = {.name = "max_hw_sectors_kb", .mode = S_IRUGO },
335 .show = queue_max_hw_sectors_show,
336};
337
Martin K. Petersenc77a5712010-03-10 00:48:33 -0500338static struct queue_sysfs_entry queue_max_segments_entry = {
339 .attr = {.name = "max_segments", .mode = S_IRUGO },
340 .show = queue_max_segments_show,
341};
342
Martin K. Petersen13f05c82010-09-10 20:50:10 +0200343static struct queue_sysfs_entry queue_max_integrity_segments_entry = {
344 .attr = {.name = "max_integrity_segments", .mode = S_IRUGO },
345 .show = queue_max_integrity_segments_show,
346};
347
Martin K. Petersenc77a5712010-03-10 00:48:33 -0500348static struct queue_sysfs_entry queue_max_segment_size_entry = {
349 .attr = {.name = "max_segment_size", .mode = S_IRUGO },
350 .show = queue_max_segment_size_show,
351};
352
Jens Axboe8324aa92008-01-29 14:51:59 +0100353static struct queue_sysfs_entry queue_iosched_entry = {
354 .attr = {.name = "scheduler", .mode = S_IRUGO | S_IWUSR },
355 .show = elv_iosched_show,
356 .store = elv_iosched_store,
357};
358
Martin K. Petersene68b9032008-01-29 19:14:08 +0100359static struct queue_sysfs_entry queue_hw_sector_size_entry = {
360 .attr = {.name = "hw_sector_size", .mode = S_IRUGO },
Martin K. Petersene1defc42009-05-22 17:17:49 -0400361 .show = queue_logical_block_size_show,
362};
363
364static struct queue_sysfs_entry queue_logical_block_size_entry = {
365 .attr = {.name = "logical_block_size", .mode = S_IRUGO },
366 .show = queue_logical_block_size_show,
Martin K. Petersene68b9032008-01-29 19:14:08 +0100367};
368
Martin K. Petersenc72758f2009-05-22 17:17:53 -0400369static struct queue_sysfs_entry queue_physical_block_size_entry = {
370 .attr = {.name = "physical_block_size", .mode = S_IRUGO },
371 .show = queue_physical_block_size_show,
372};
373
374static struct queue_sysfs_entry queue_io_min_entry = {
375 .attr = {.name = "minimum_io_size", .mode = S_IRUGO },
376 .show = queue_io_min_show,
377};
378
379static struct queue_sysfs_entry queue_io_opt_entry = {
380 .attr = {.name = "optimal_io_size", .mode = S_IRUGO },
381 .show = queue_io_opt_show,
Jens Axboe8324aa92008-01-29 14:51:59 +0100382};
383
Martin K. Petersen86b37282009-11-10 11:50:21 +0100384static struct queue_sysfs_entry queue_discard_granularity_entry = {
385 .attr = {.name = "discard_granularity", .mode = S_IRUGO },
386 .show = queue_discard_granularity_show,
387};
388
389static struct queue_sysfs_entry queue_discard_max_entry = {
390 .attr = {.name = "discard_max_bytes", .mode = S_IRUGO },
391 .show = queue_discard_max_show,
392};
393
Martin K. Petersen98262f22009-12-03 09:24:48 +0100394static struct queue_sysfs_entry queue_discard_zeroes_data_entry = {
395 .attr = {.name = "discard_zeroes_data", .mode = S_IRUGO },
396 .show = queue_discard_zeroes_data_show,
397};
398
Martin K. Petersen4363ac72012-09-18 12:19:27 -0400399static struct queue_sysfs_entry queue_write_same_max_entry = {
400 .attr = {.name = "write_same_max_bytes", .mode = S_IRUGO },
401 .show = queue_write_same_max_show,
402};
403
Bartlomiej Zolnierkiewicz1308835f2009-01-07 12:22:39 +0100404static struct queue_sysfs_entry queue_nonrot_entry = {
405 .attr = {.name = "rotational", .mode = S_IRUGO | S_IWUSR },
Jens Axboe956bcb72010-08-07 18:13:50 +0200406 .show = queue_show_nonrot,
407 .store = queue_store_nonrot,
Bartlomiej Zolnierkiewicz1308835f2009-01-07 12:22:39 +0100408};
409
Alan D. Brunelleac9fafa2008-04-29 14:44:19 +0200410static struct queue_sysfs_entry queue_nomerges_entry = {
411 .attr = {.name = "nomerges", .mode = S_IRUGO | S_IWUSR },
412 .show = queue_nomerges_show,
413 .store = queue_nomerges_store,
414};
415
Jens Axboec7c22e42008-09-13 20:26:01 +0200416static struct queue_sysfs_entry queue_rq_affinity_entry = {
417 .attr = {.name = "rq_affinity", .mode = S_IRUGO | S_IWUSR },
418 .show = queue_rq_affinity_show,
419 .store = queue_rq_affinity_store,
420};
421
Jens Axboebc58ba92009-01-23 10:54:44 +0100422static struct queue_sysfs_entry queue_iostats_entry = {
423 .attr = {.name = "iostats", .mode = S_IRUGO | S_IWUSR },
Jens Axboe956bcb72010-08-07 18:13:50 +0200424 .show = queue_show_iostats,
425 .store = queue_store_iostats,
Jens Axboebc58ba92009-01-23 10:54:44 +0100426};
427
Jens Axboee2e1a142010-06-09 10:42:09 +0200428static struct queue_sysfs_entry queue_random_entry = {
429 .attr = {.name = "add_random", .mode = S_IRUGO | S_IWUSR },
Jens Axboe956bcb72010-08-07 18:13:50 +0200430 .show = queue_show_random,
431 .store = queue_store_random,
Jens Axboee2e1a142010-06-09 10:42:09 +0200432};
433
Jens Axboe8324aa92008-01-29 14:51:59 +0100434static struct attribute *default_attrs[] = {
435 &queue_requests_entry.attr,
436 &queue_ra_entry.attr,
437 &queue_max_hw_sectors_entry.attr,
438 &queue_max_sectors_entry.attr,
Martin K. Petersenc77a5712010-03-10 00:48:33 -0500439 &queue_max_segments_entry.attr,
Martin K. Petersen13f05c82010-09-10 20:50:10 +0200440 &queue_max_integrity_segments_entry.attr,
Martin K. Petersenc77a5712010-03-10 00:48:33 -0500441 &queue_max_segment_size_entry.attr,
Jens Axboe8324aa92008-01-29 14:51:59 +0100442 &queue_iosched_entry.attr,
Martin K. Petersene68b9032008-01-29 19:14:08 +0100443 &queue_hw_sector_size_entry.attr,
Martin K. Petersene1defc42009-05-22 17:17:49 -0400444 &queue_logical_block_size_entry.attr,
Martin K. Petersenc72758f2009-05-22 17:17:53 -0400445 &queue_physical_block_size_entry.attr,
446 &queue_io_min_entry.attr,
447 &queue_io_opt_entry.attr,
Martin K. Petersen86b37282009-11-10 11:50:21 +0100448 &queue_discard_granularity_entry.attr,
449 &queue_discard_max_entry.attr,
Martin K. Petersen98262f22009-12-03 09:24:48 +0100450 &queue_discard_zeroes_data_entry.attr,
Martin K. Petersen4363ac72012-09-18 12:19:27 -0400451 &queue_write_same_max_entry.attr,
Bartlomiej Zolnierkiewicz1308835f2009-01-07 12:22:39 +0100452 &queue_nonrot_entry.attr,
Alan D. Brunelleac9fafa2008-04-29 14:44:19 +0200453 &queue_nomerges_entry.attr,
Jens Axboec7c22e42008-09-13 20:26:01 +0200454 &queue_rq_affinity_entry.attr,
Jens Axboebc58ba92009-01-23 10:54:44 +0100455 &queue_iostats_entry.attr,
Jens Axboee2e1a142010-06-09 10:42:09 +0200456 &queue_random_entry.attr,
Jens Axboe8324aa92008-01-29 14:51:59 +0100457 NULL,
458};
459
460#define to_queue(atr) container_of((atr), struct queue_sysfs_entry, attr)
461
462static ssize_t
463queue_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
464{
465 struct queue_sysfs_entry *entry = to_queue(attr);
466 struct request_queue *q =
467 container_of(kobj, struct request_queue, kobj);
468 ssize_t res;
469
470 if (!entry->show)
471 return -EIO;
472 mutex_lock(&q->sysfs_lock);
Bart Van Assche3f3299d2012-11-28 13:42:38 +0100473 if (blk_queue_dying(q)) {
Jens Axboe8324aa92008-01-29 14:51:59 +0100474 mutex_unlock(&q->sysfs_lock);
475 return -ENOENT;
476 }
477 res = entry->show(q, page);
478 mutex_unlock(&q->sysfs_lock);
479 return res;
480}
481
482static ssize_t
483queue_attr_store(struct kobject *kobj, struct attribute *attr,
484 const char *page, size_t length)
485{
486 struct queue_sysfs_entry *entry = to_queue(attr);
Jens Axboe6728cb02008-01-31 13:03:55 +0100487 struct request_queue *q;
Jens Axboe8324aa92008-01-29 14:51:59 +0100488 ssize_t res;
489
490 if (!entry->store)
491 return -EIO;
Jens Axboe6728cb02008-01-31 13:03:55 +0100492
493 q = container_of(kobj, struct request_queue, kobj);
Jens Axboe8324aa92008-01-29 14:51:59 +0100494 mutex_lock(&q->sysfs_lock);
Bart Van Assche3f3299d2012-11-28 13:42:38 +0100495 if (blk_queue_dying(q)) {
Jens Axboe8324aa92008-01-29 14:51:59 +0100496 mutex_unlock(&q->sysfs_lock);
497 return -ENOENT;
498 }
499 res = entry->store(q, page, length);
500 mutex_unlock(&q->sysfs_lock);
501 return res;
502}
503
Tejun Heo548bc8e2013-01-09 08:05:13 -0800504static void blk_free_queue_rcu(struct rcu_head *rcu_head)
505{
506 struct request_queue *q = container_of(rcu_head, struct request_queue,
507 rcu_head);
508 kmem_cache_free(blk_requestq_cachep, q);
509}
510
Jens Axboe8324aa92008-01-29 14:51:59 +0100511/**
Andrew Morton499337b2011-09-21 10:01:22 +0200512 * blk_release_queue: - release a &struct request_queue when it is no longer needed
513 * @kobj: the kobj belonging to the request queue to be released
Jens Axboe8324aa92008-01-29 14:51:59 +0100514 *
515 * Description:
Andrew Morton499337b2011-09-21 10:01:22 +0200516 * blk_release_queue is the pair to blk_init_queue() or
Jens Axboe8324aa92008-01-29 14:51:59 +0100517 * blk_queue_make_request(). It should be called when a request queue is
518 * being released; typically when a block device is being de-registered.
519 * Currently, its primary task it to free all the &struct request
520 * structures that were allocated to the queue and the queue itself.
521 *
522 * Caveat:
523 * Hopefully the low level driver will have finished any
524 * outstanding requests first...
525 **/
526static void blk_release_queue(struct kobject *kobj)
527{
528 struct request_queue *q =
529 container_of(kobj, struct request_queue, kobj);
Jens Axboe8324aa92008-01-29 14:51:59 +0100530
531 blk_sync_queue(q);
532
Tejun Heoe8989fa2012-03-05 13:15:20 -0800533 blkcg_exit_queue(q);
534
Tejun Heo7e5a8792011-12-14 00:33:42 +0100535 if (q->elevator) {
536 spin_lock_irq(q->queue_lock);
537 ioc_clear_queue(q);
538 spin_unlock_irq(q->queue_lock);
Hannes Reinecke777eb1b2011-09-28 08:07:01 -0600539 elevator_exit(q->elevator);
Tejun Heo7e5a8792011-12-14 00:33:42 +0100540 }
Hannes Reinecke777eb1b2011-09-28 08:07:01 -0600541
Tejun Heoa0516612012-06-26 15:05:44 -0700542 blk_exit_rl(&q->root_rl);
Jens Axboe8324aa92008-01-29 14:51:59 +0100543
544 if (q->queue_tags)
545 __blk_queue_free_tags(q);
546
Jens Axboe320ae512013-10-24 09:20:05 +0100547 percpu_counter_destroy(&q->mq_usage_counter);
548
549 if (q->mq_ops)
550 blk_mq_free_queue(q);
551
Jens Axboe8324aa92008-01-29 14:51:59 +0100552 blk_trace_shutdown(q);
553
554 bdi_destroy(&q->backing_dev_info);
Tejun Heoa73f7302011-12-14 00:33:37 +0100555
556 ida_simple_remove(&blk_queue_ida, q->id);
Tejun Heo548bc8e2013-01-09 08:05:13 -0800557 call_rcu(&q->rcu_head, blk_free_queue_rcu);
Jens Axboe8324aa92008-01-29 14:51:59 +0100558}
559
Emese Revfy52cf25d2010-01-19 02:58:23 +0100560static const struct sysfs_ops queue_sysfs_ops = {
Jens Axboe8324aa92008-01-29 14:51:59 +0100561 .show = queue_attr_show,
562 .store = queue_attr_store,
563};
564
565struct kobj_type blk_queue_ktype = {
566 .sysfs_ops = &queue_sysfs_ops,
567 .default_attrs = default_attrs,
568 .release = blk_release_queue,
569};
570
571int blk_register_queue(struct gendisk *disk)
572{
573 int ret;
Li Zefan1d54ad62009-04-14 14:00:05 +0800574 struct device *dev = disk_to_dev(disk);
Jens Axboe8324aa92008-01-29 14:51:59 +0100575 struct request_queue *q = disk->queue;
576
Akinobu Mitafb199742008-04-21 09:51:06 +0200577 if (WARN_ON(!q))
Jens Axboe8324aa92008-01-29 14:51:59 +0100578 return -ENXIO;
579
Tejun Heo749fefe2012-09-20 14:08:52 -0700580 /*
581 * Initialization must be complete by now. Finish the initial
582 * bypass from queue allocation.
583 */
584 blk_queue_bypass_end(q);
Jens Axboe320ae512013-10-24 09:20:05 +0100585 queue_flag_set_unlocked(QUEUE_FLAG_INIT_DONE, q);
Tejun Heo749fefe2012-09-20 14:08:52 -0700586
Li Zefan1d54ad62009-04-14 14:00:05 +0800587 ret = blk_trace_init_sysfs(dev);
588 if (ret)
589 return ret;
590
Linus Torvaldsc9059592009-06-11 10:52:27 -0700591 ret = kobject_add(&q->kobj, kobject_get(&dev->kobj), "%s", "queue");
Liu Yuaned5302d2011-04-19 13:47:58 +0200592 if (ret < 0) {
593 blk_trace_remove_sysfs(dev);
Jens Axboe8324aa92008-01-29 14:51:59 +0100594 return ret;
Liu Yuaned5302d2011-04-19 13:47:58 +0200595 }
Jens Axboe8324aa92008-01-29 14:51:59 +0100596
597 kobject_uevent(&q->kobj, KOBJ_ADD);
598
Jens Axboe320ae512013-10-24 09:20:05 +0100599 if (q->mq_ops)
600 blk_mq_register_disk(disk);
601
Martin K. Petersencd43e262009-05-22 17:17:52 -0400602 if (!q->request_fn)
603 return 0;
604
Jens Axboe8324aa92008-01-29 14:51:59 +0100605 ret = elv_register_queue(q);
606 if (ret) {
607 kobject_uevent(&q->kobj, KOBJ_REMOVE);
608 kobject_del(&q->kobj);
Liu Yuan80656b62011-04-13 22:14:54 +0200609 blk_trace_remove_sysfs(dev);
Xiaotian Fengc87ffbb2010-08-23 12:30:29 +0200610 kobject_put(&dev->kobj);
Jens Axboe8324aa92008-01-29 14:51:59 +0100611 return ret;
612 }
613
614 return 0;
615}
616
617void blk_unregister_queue(struct gendisk *disk)
618{
619 struct request_queue *q = disk->queue;
620
Akinobu Mitafb199742008-04-21 09:51:06 +0200621 if (WARN_ON(!q))
622 return;
623
Jens Axboe320ae512013-10-24 09:20:05 +0100624 if (q->mq_ops)
625 blk_mq_unregister_disk(disk);
626
Zdenek Kabelac48c0d4d2009-09-25 06:19:26 +0200627 if (q->request_fn)
Jens Axboe8324aa92008-01-29 14:51:59 +0100628 elv_unregister_queue(q);
629
Zdenek Kabelac48c0d4d2009-09-25 06:19:26 +0200630 kobject_uevent(&q->kobj, KOBJ_REMOVE);
631 kobject_del(&q->kobj);
632 blk_trace_remove_sysfs(disk_to_dev(disk));
633 kobject_put(&disk_to_dev(disk)->kobj);
Jens Axboe8324aa92008-01-29 14:51:59 +0100634}