blob: 6264b382d4d1ba8765dc3b22cead4fd9bf384d99 [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
148static ssize_t queue_discard_max_show(struct request_queue *q, char *page)
149{
Martin K. Petersena934a002011-05-18 10:37:35 +0200150 return sprintf(page, "%llu\n",
151 (unsigned long long)q->limits.max_discard_sectors << 9);
Martin K. Petersen86b37282009-11-10 11:50:21 +0100152}
153
Martin K. Petersen98262f22009-12-03 09:24:48 +0100154static ssize_t queue_discard_zeroes_data_show(struct request_queue *q, char *page)
155{
156 return queue_var_show(queue_discard_zeroes_data(q), page);
157}
158
Martin K. Petersen4363ac72012-09-18 12:19:27 -0400159static ssize_t queue_write_same_max_show(struct request_queue *q, char *page)
160{
161 return sprintf(page, "%llu\n",
162 (unsigned long long)q->limits.max_write_same_sectors << 9);
163}
164
165
Jens Axboe8324aa92008-01-29 14:51:59 +0100166static ssize_t
167queue_max_sectors_store(struct request_queue *q, const char *page, size_t count)
168{
169 unsigned long max_sectors_kb,
Martin K. Petersenae03bf62009-05-22 17:17:50 -0400170 max_hw_sectors_kb = queue_max_hw_sectors(q) >> 1,
Jens Axboe8324aa92008-01-29 14:51:59 +0100171 page_kb = 1 << (PAGE_CACHE_SHIFT - 10);
172 ssize_t ret = queue_var_store(&max_sectors_kb, page, count);
173
Dave Reisnerb1f3b642012-09-08 11:55:45 -0400174 if (ret < 0)
175 return ret;
176
Jens Axboe8324aa92008-01-29 14:51:59 +0100177 if (max_sectors_kb > max_hw_sectors_kb || max_sectors_kb < page_kb)
178 return -EINVAL;
Wu Fengguang7c239512008-11-25 09:08:39 +0100179
Jens Axboe8324aa92008-01-29 14:51:59 +0100180 spin_lock_irq(q->queue_lock);
Nikanth Karthikesanc295fc02009-09-01 22:40:15 +0200181 q->limits.max_sectors = max_sectors_kb << 1;
Jens Axboe8324aa92008-01-29 14:51:59 +0100182 spin_unlock_irq(q->queue_lock);
183
184 return ret;
185}
186
187static ssize_t queue_max_hw_sectors_show(struct request_queue *q, char *page)
188{
Martin K. Petersenae03bf62009-05-22 17:17:50 -0400189 int max_hw_sectors_kb = queue_max_hw_sectors(q) >> 1;
Jens Axboe8324aa92008-01-29 14:51:59 +0100190
191 return queue_var_show(max_hw_sectors_kb, (page));
192}
193
Jens Axboe956bcb72010-08-07 18:13:50 +0200194#define QUEUE_SYSFS_BIT_FNS(name, flag, neg) \
195static ssize_t \
196queue_show_##name(struct request_queue *q, char *page) \
197{ \
198 int bit; \
199 bit = test_bit(QUEUE_FLAG_##flag, &q->queue_flags); \
200 return queue_var_show(neg ? !bit : bit, page); \
201} \
202static ssize_t \
203queue_store_##name(struct request_queue *q, const char *page, size_t count) \
204{ \
205 unsigned long val; \
206 ssize_t ret; \
207 ret = queue_var_store(&val, page, count); \
Arnd Bergmannc678ef52013-04-03 21:53:57 +0200208 if (ret < 0) \
209 return ret; \
Jens Axboe956bcb72010-08-07 18:13:50 +0200210 if (neg) \
211 val = !val; \
212 \
213 spin_lock_irq(q->queue_lock); \
214 if (val) \
215 queue_flag_set(QUEUE_FLAG_##flag, q); \
216 else \
217 queue_flag_clear(QUEUE_FLAG_##flag, q); \
218 spin_unlock_irq(q->queue_lock); \
219 return ret; \
Bartlomiej Zolnierkiewicz1308835f2009-01-07 12:22:39 +0100220}
221
Jens Axboe956bcb72010-08-07 18:13:50 +0200222QUEUE_SYSFS_BIT_FNS(nonrot, NONROT, 1);
223QUEUE_SYSFS_BIT_FNS(random, ADD_RANDOM, 0);
224QUEUE_SYSFS_BIT_FNS(iostats, IO_STAT, 0);
225#undef QUEUE_SYSFS_BIT_FNS
Bartlomiej Zolnierkiewicz1308835f2009-01-07 12:22:39 +0100226
Alan D. Brunelleac9fafa2008-04-29 14:44:19 +0200227static ssize_t queue_nomerges_show(struct request_queue *q, char *page)
228{
Alan D. Brunelle488991e2010-01-29 09:04:08 +0100229 return queue_var_show((blk_queue_nomerges(q) << 1) |
230 blk_queue_noxmerges(q), page);
Alan D. Brunelleac9fafa2008-04-29 14:44:19 +0200231}
232
233static ssize_t queue_nomerges_store(struct request_queue *q, const char *page,
234 size_t count)
235{
236 unsigned long nm;
237 ssize_t ret = queue_var_store(&nm, page, count);
238
Dave Reisnerb1f3b642012-09-08 11:55:45 -0400239 if (ret < 0)
240 return ret;
241
Jens Axboebf0f9702008-05-07 09:09:39 +0200242 spin_lock_irq(q->queue_lock);
Alan D. Brunelle488991e2010-01-29 09:04:08 +0100243 queue_flag_clear(QUEUE_FLAG_NOMERGES, q);
244 queue_flag_clear(QUEUE_FLAG_NOXMERGES, q);
245 if (nm == 2)
Jens Axboebf0f9702008-05-07 09:09:39 +0200246 queue_flag_set(QUEUE_FLAG_NOMERGES, q);
Alan D. Brunelle488991e2010-01-29 09:04:08 +0100247 else if (nm)
248 queue_flag_set(QUEUE_FLAG_NOXMERGES, q);
Jens Axboebf0f9702008-05-07 09:09:39 +0200249 spin_unlock_irq(q->queue_lock);
Bartlomiej Zolnierkiewicz1308835f2009-01-07 12:22:39 +0100250
Alan D. Brunelleac9fafa2008-04-29 14:44:19 +0200251 return ret;
252}
253
Jens Axboec7c22e42008-09-13 20:26:01 +0200254static ssize_t queue_rq_affinity_show(struct request_queue *q, char *page)
255{
Xiaotian Feng9cb308c2009-07-17 15:26:26 +0800256 bool set = test_bit(QUEUE_FLAG_SAME_COMP, &q->queue_flags);
Dan Williams5757a6d2011-07-23 20:44:25 +0200257 bool force = test_bit(QUEUE_FLAG_SAME_FORCE, &q->queue_flags);
Jens Axboec7c22e42008-09-13 20:26:01 +0200258
Dan Williams5757a6d2011-07-23 20:44:25 +0200259 return queue_var_show(set << force, page);
Jens Axboec7c22e42008-09-13 20:26:01 +0200260}
261
262static ssize_t
263queue_rq_affinity_store(struct request_queue *q, const char *page, size_t count)
264{
265 ssize_t ret = -EINVAL;
Christoph Hellwig0a06ff02013-11-14 14:32:07 -0800266#ifdef CONFIG_SMP
Jens Axboec7c22e42008-09-13 20:26:01 +0200267 unsigned long val;
268
269 ret = queue_var_store(&val, page, count);
Dave Reisnerb1f3b642012-09-08 11:55:45 -0400270 if (ret < 0)
271 return ret;
272
Jens Axboec7c22e42008-09-13 20:26:01 +0200273 spin_lock_irq(q->queue_lock);
Eric Seppanene8037d42011-08-23 21:25:12 +0200274 if (val == 2) {
Jens Axboec7c22e42008-09-13 20:26:01 +0200275 queue_flag_set(QUEUE_FLAG_SAME_COMP, q);
Eric Seppanene8037d42011-08-23 21:25:12 +0200276 queue_flag_set(QUEUE_FLAG_SAME_FORCE, q);
277 } else if (val == 1) {
278 queue_flag_set(QUEUE_FLAG_SAME_COMP, q);
279 queue_flag_clear(QUEUE_FLAG_SAME_FORCE, q);
280 } else if (val == 0) {
Dan Williams5757a6d2011-07-23 20:44:25 +0200281 queue_flag_clear(QUEUE_FLAG_SAME_COMP, q);
282 queue_flag_clear(QUEUE_FLAG_SAME_FORCE, q);
283 }
Jens Axboec7c22e42008-09-13 20:26:01 +0200284 spin_unlock_irq(q->queue_lock);
285#endif
286 return ret;
287}
Jens Axboe8324aa92008-01-29 14:51:59 +0100288
289static struct queue_sysfs_entry queue_requests_entry = {
290 .attr = {.name = "nr_requests", .mode = S_IRUGO | S_IWUSR },
291 .show = queue_requests_show,
292 .store = queue_requests_store,
293};
294
295static struct queue_sysfs_entry queue_ra_entry = {
296 .attr = {.name = "read_ahead_kb", .mode = S_IRUGO | S_IWUSR },
297 .show = queue_ra_show,
298 .store = queue_ra_store,
299};
300
301static struct queue_sysfs_entry queue_max_sectors_entry = {
302 .attr = {.name = "max_sectors_kb", .mode = S_IRUGO | S_IWUSR },
303 .show = queue_max_sectors_show,
304 .store = queue_max_sectors_store,
305};
306
307static struct queue_sysfs_entry queue_max_hw_sectors_entry = {
308 .attr = {.name = "max_hw_sectors_kb", .mode = S_IRUGO },
309 .show = queue_max_hw_sectors_show,
310};
311
Martin K. Petersenc77a5712010-03-10 00:48:33 -0500312static struct queue_sysfs_entry queue_max_segments_entry = {
313 .attr = {.name = "max_segments", .mode = S_IRUGO },
314 .show = queue_max_segments_show,
315};
316
Martin K. Petersen13f05c82010-09-10 20:50:10 +0200317static struct queue_sysfs_entry queue_max_integrity_segments_entry = {
318 .attr = {.name = "max_integrity_segments", .mode = S_IRUGO },
319 .show = queue_max_integrity_segments_show,
320};
321
Martin K. Petersenc77a5712010-03-10 00:48:33 -0500322static struct queue_sysfs_entry queue_max_segment_size_entry = {
323 .attr = {.name = "max_segment_size", .mode = S_IRUGO },
324 .show = queue_max_segment_size_show,
325};
326
Jens Axboe8324aa92008-01-29 14:51:59 +0100327static struct queue_sysfs_entry queue_iosched_entry = {
328 .attr = {.name = "scheduler", .mode = S_IRUGO | S_IWUSR },
329 .show = elv_iosched_show,
330 .store = elv_iosched_store,
331};
332
Martin K. Petersene68b9032008-01-29 19:14:08 +0100333static struct queue_sysfs_entry queue_hw_sector_size_entry = {
334 .attr = {.name = "hw_sector_size", .mode = S_IRUGO },
Martin K. Petersene1defc42009-05-22 17:17:49 -0400335 .show = queue_logical_block_size_show,
336};
337
338static struct queue_sysfs_entry queue_logical_block_size_entry = {
339 .attr = {.name = "logical_block_size", .mode = S_IRUGO },
340 .show = queue_logical_block_size_show,
Martin K. Petersene68b9032008-01-29 19:14:08 +0100341};
342
Martin K. Petersenc72758f2009-05-22 17:17:53 -0400343static struct queue_sysfs_entry queue_physical_block_size_entry = {
344 .attr = {.name = "physical_block_size", .mode = S_IRUGO },
345 .show = queue_physical_block_size_show,
346};
347
348static struct queue_sysfs_entry queue_io_min_entry = {
349 .attr = {.name = "minimum_io_size", .mode = S_IRUGO },
350 .show = queue_io_min_show,
351};
352
353static struct queue_sysfs_entry queue_io_opt_entry = {
354 .attr = {.name = "optimal_io_size", .mode = S_IRUGO },
355 .show = queue_io_opt_show,
Jens Axboe8324aa92008-01-29 14:51:59 +0100356};
357
Martin K. Petersen86b37282009-11-10 11:50:21 +0100358static struct queue_sysfs_entry queue_discard_granularity_entry = {
359 .attr = {.name = "discard_granularity", .mode = S_IRUGO },
360 .show = queue_discard_granularity_show,
361};
362
363static struct queue_sysfs_entry queue_discard_max_entry = {
364 .attr = {.name = "discard_max_bytes", .mode = S_IRUGO },
365 .show = queue_discard_max_show,
366};
367
Martin K. Petersen98262f22009-12-03 09:24:48 +0100368static struct queue_sysfs_entry queue_discard_zeroes_data_entry = {
369 .attr = {.name = "discard_zeroes_data", .mode = S_IRUGO },
370 .show = queue_discard_zeroes_data_show,
371};
372
Martin K. Petersen4363ac72012-09-18 12:19:27 -0400373static struct queue_sysfs_entry queue_write_same_max_entry = {
374 .attr = {.name = "write_same_max_bytes", .mode = S_IRUGO },
375 .show = queue_write_same_max_show,
376};
377
Bartlomiej Zolnierkiewicz1308835f2009-01-07 12:22:39 +0100378static struct queue_sysfs_entry queue_nonrot_entry = {
379 .attr = {.name = "rotational", .mode = S_IRUGO | S_IWUSR },
Jens Axboe956bcb72010-08-07 18:13:50 +0200380 .show = queue_show_nonrot,
381 .store = queue_store_nonrot,
Bartlomiej Zolnierkiewicz1308835f2009-01-07 12:22:39 +0100382};
383
Alan D. Brunelleac9fafa2008-04-29 14:44:19 +0200384static struct queue_sysfs_entry queue_nomerges_entry = {
385 .attr = {.name = "nomerges", .mode = S_IRUGO | S_IWUSR },
386 .show = queue_nomerges_show,
387 .store = queue_nomerges_store,
388};
389
Jens Axboec7c22e42008-09-13 20:26:01 +0200390static struct queue_sysfs_entry queue_rq_affinity_entry = {
391 .attr = {.name = "rq_affinity", .mode = S_IRUGO | S_IWUSR },
392 .show = queue_rq_affinity_show,
393 .store = queue_rq_affinity_store,
394};
395
Jens Axboebc58ba92009-01-23 10:54:44 +0100396static struct queue_sysfs_entry queue_iostats_entry = {
397 .attr = {.name = "iostats", .mode = S_IRUGO | S_IWUSR },
Jens Axboe956bcb72010-08-07 18:13:50 +0200398 .show = queue_show_iostats,
399 .store = queue_store_iostats,
Jens Axboebc58ba92009-01-23 10:54:44 +0100400};
401
Jens Axboee2e1a142010-06-09 10:42:09 +0200402static struct queue_sysfs_entry queue_random_entry = {
403 .attr = {.name = "add_random", .mode = S_IRUGO | S_IWUSR },
Jens Axboe956bcb72010-08-07 18:13:50 +0200404 .show = queue_show_random,
405 .store = queue_store_random,
Jens Axboee2e1a142010-06-09 10:42:09 +0200406};
407
Jens Axboe8324aa92008-01-29 14:51:59 +0100408static struct attribute *default_attrs[] = {
409 &queue_requests_entry.attr,
410 &queue_ra_entry.attr,
411 &queue_max_hw_sectors_entry.attr,
412 &queue_max_sectors_entry.attr,
Martin K. Petersenc77a5712010-03-10 00:48:33 -0500413 &queue_max_segments_entry.attr,
Martin K. Petersen13f05c82010-09-10 20:50:10 +0200414 &queue_max_integrity_segments_entry.attr,
Martin K. Petersenc77a5712010-03-10 00:48:33 -0500415 &queue_max_segment_size_entry.attr,
Jens Axboe8324aa92008-01-29 14:51:59 +0100416 &queue_iosched_entry.attr,
Martin K. Petersene68b9032008-01-29 19:14:08 +0100417 &queue_hw_sector_size_entry.attr,
Martin K. Petersene1defc42009-05-22 17:17:49 -0400418 &queue_logical_block_size_entry.attr,
Martin K. Petersenc72758f2009-05-22 17:17:53 -0400419 &queue_physical_block_size_entry.attr,
420 &queue_io_min_entry.attr,
421 &queue_io_opt_entry.attr,
Martin K. Petersen86b37282009-11-10 11:50:21 +0100422 &queue_discard_granularity_entry.attr,
423 &queue_discard_max_entry.attr,
Martin K. Petersen98262f22009-12-03 09:24:48 +0100424 &queue_discard_zeroes_data_entry.attr,
Martin K. Petersen4363ac72012-09-18 12:19:27 -0400425 &queue_write_same_max_entry.attr,
Bartlomiej Zolnierkiewicz1308835f2009-01-07 12:22:39 +0100426 &queue_nonrot_entry.attr,
Alan D. Brunelleac9fafa2008-04-29 14:44:19 +0200427 &queue_nomerges_entry.attr,
Jens Axboec7c22e42008-09-13 20:26:01 +0200428 &queue_rq_affinity_entry.attr,
Jens Axboebc58ba92009-01-23 10:54:44 +0100429 &queue_iostats_entry.attr,
Jens Axboee2e1a142010-06-09 10:42:09 +0200430 &queue_random_entry.attr,
Jens Axboe8324aa92008-01-29 14:51:59 +0100431 NULL,
432};
433
434#define to_queue(atr) container_of((atr), struct queue_sysfs_entry, attr)
435
436static ssize_t
437queue_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
438{
439 struct queue_sysfs_entry *entry = to_queue(attr);
440 struct request_queue *q =
441 container_of(kobj, struct request_queue, kobj);
442 ssize_t res;
443
444 if (!entry->show)
445 return -EIO;
446 mutex_lock(&q->sysfs_lock);
Bart Van Assche3f3299d2012-11-28 13:42:38 +0100447 if (blk_queue_dying(q)) {
Jens Axboe8324aa92008-01-29 14:51:59 +0100448 mutex_unlock(&q->sysfs_lock);
449 return -ENOENT;
450 }
451 res = entry->show(q, page);
452 mutex_unlock(&q->sysfs_lock);
453 return res;
454}
455
456static ssize_t
457queue_attr_store(struct kobject *kobj, struct attribute *attr,
458 const char *page, size_t length)
459{
460 struct queue_sysfs_entry *entry = to_queue(attr);
Jens Axboe6728cb02008-01-31 13:03:55 +0100461 struct request_queue *q;
Jens Axboe8324aa92008-01-29 14:51:59 +0100462 ssize_t res;
463
464 if (!entry->store)
465 return -EIO;
Jens Axboe6728cb02008-01-31 13:03:55 +0100466
467 q = container_of(kobj, struct request_queue, kobj);
Jens Axboe8324aa92008-01-29 14:51:59 +0100468 mutex_lock(&q->sysfs_lock);
Bart Van Assche3f3299d2012-11-28 13:42:38 +0100469 if (blk_queue_dying(q)) {
Jens Axboe8324aa92008-01-29 14:51:59 +0100470 mutex_unlock(&q->sysfs_lock);
471 return -ENOENT;
472 }
473 res = entry->store(q, page, length);
474 mutex_unlock(&q->sysfs_lock);
475 return res;
476}
477
Tejun Heo548bc8e2013-01-09 08:05:13 -0800478static void blk_free_queue_rcu(struct rcu_head *rcu_head)
479{
480 struct request_queue *q = container_of(rcu_head, struct request_queue,
481 rcu_head);
482 kmem_cache_free(blk_requestq_cachep, q);
483}
484
Jens Axboe8324aa92008-01-29 14:51:59 +0100485/**
Andrew Morton499337b2011-09-21 10:01:22 +0200486 * blk_release_queue: - release a &struct request_queue when it is no longer needed
487 * @kobj: the kobj belonging to the request queue to be released
Jens Axboe8324aa92008-01-29 14:51:59 +0100488 *
489 * Description:
Andrew Morton499337b2011-09-21 10:01:22 +0200490 * blk_release_queue is the pair to blk_init_queue() or
Jens Axboe8324aa92008-01-29 14:51:59 +0100491 * blk_queue_make_request(). It should be called when a request queue is
492 * being released; typically when a block device is being de-registered.
493 * Currently, its primary task it to free all the &struct request
494 * structures that were allocated to the queue and the queue itself.
495 *
Bart Van Assche45a9c9d2014-12-09 16:57:48 +0100496 * Note:
497 * The low level driver must have finished any outstanding requests first
498 * via blk_cleanup_queue().
Jens Axboe8324aa92008-01-29 14:51:59 +0100499 **/
500static void blk_release_queue(struct kobject *kobj)
501{
502 struct request_queue *q =
503 container_of(kobj, struct request_queue, kobj);
Jens Axboe8324aa92008-01-29 14:51:59 +0100504
Tejun Heoe8989fa2012-03-05 13:15:20 -0800505 blkcg_exit_queue(q);
506
Tejun Heo7e5a8792011-12-14 00:33:42 +0100507 if (q->elevator) {
508 spin_lock_irq(q->queue_lock);
509 ioc_clear_queue(q);
510 spin_unlock_irq(q->queue_lock);
Hannes Reinecke777eb1b2011-09-28 08:07:01 -0600511 elevator_exit(q->elevator);
Tejun Heo7e5a8792011-12-14 00:33:42 +0100512 }
Hannes Reinecke777eb1b2011-09-28 08:07:01 -0600513
Tejun Heoa0516612012-06-26 15:05:44 -0700514 blk_exit_rl(&q->root_rl);
Jens Axboe8324aa92008-01-29 14:51:59 +0100515
516 if (q->queue_tags)
517 __blk_queue_free_tags(q);
518
Bart Van Assche45a9c9d2014-12-09 16:57:48 +0100519 if (!q->mq_ops)
Ming Leif70ced02014-09-25 23:23:47 +0800520 blk_free_flush_queue(q->fq);
Ming Leie09aae72015-01-29 20:17:27 +0800521 else
522 blk_mq_release(q);
Christoph Hellwig18741982014-02-10 09:29:00 -0700523
Jens Axboe8324aa92008-01-29 14:51:59 +0100524 blk_trace_shutdown(q);
525
Tejun Heoa73f7302011-12-14 00:33:37 +0100526 ida_simple_remove(&blk_queue_ida, q->id);
Tejun Heo548bc8e2013-01-09 08:05:13 -0800527 call_rcu(&q->rcu_head, blk_free_queue_rcu);
Jens Axboe8324aa92008-01-29 14:51:59 +0100528}
529
Emese Revfy52cf25d2010-01-19 02:58:23 +0100530static const struct sysfs_ops queue_sysfs_ops = {
Jens Axboe8324aa92008-01-29 14:51:59 +0100531 .show = queue_attr_show,
532 .store = queue_attr_store,
533};
534
535struct kobj_type blk_queue_ktype = {
536 .sysfs_ops = &queue_sysfs_ops,
537 .default_attrs = default_attrs,
538 .release = blk_release_queue,
539};
540
541int blk_register_queue(struct gendisk *disk)
542{
543 int ret;
Li Zefan1d54ad62009-04-14 14:00:05 +0800544 struct device *dev = disk_to_dev(disk);
Jens Axboe8324aa92008-01-29 14:51:59 +0100545 struct request_queue *q = disk->queue;
546
Akinobu Mitafb199742008-04-21 09:51:06 +0200547 if (WARN_ON(!q))
Jens Axboe8324aa92008-01-29 14:51:59 +0100548 return -ENXIO;
549
Tejun Heo749fefe2012-09-20 14:08:52 -0700550 /*
Tejun Heo17497ac2014-09-24 13:31:50 -0400551 * SCSI probing may synchronously create and destroy a lot of
552 * request_queues for non-existent devices. Shutting down a fully
553 * functional queue takes measureable wallclock time as RCU grace
554 * periods are involved. To avoid excessive latency in these
555 * cases, a request_queue starts out in a degraded mode which is
556 * faster to shut down and is made fully functional here as
557 * request_queues for non-existent devices never get registered.
Tejun Heo749fefe2012-09-20 14:08:52 -0700558 */
Alan Sterndf35c7c2014-09-09 11:50:58 -0400559 if (!blk_queue_init_done(q)) {
560 queue_flag_set_unlocked(QUEUE_FLAG_INIT_DONE, q);
561 blk_queue_bypass_end(q);
Tejun Heo17497ac2014-09-24 13:31:50 -0400562 if (q->mq_ops)
563 blk_mq_finish_init(q);
Alan Sterndf35c7c2014-09-09 11:50:58 -0400564 }
Tejun Heo749fefe2012-09-20 14:08:52 -0700565
Li Zefan1d54ad62009-04-14 14:00:05 +0800566 ret = blk_trace_init_sysfs(dev);
567 if (ret)
568 return ret;
569
Linus Torvaldsc9059592009-06-11 10:52:27 -0700570 ret = kobject_add(&q->kobj, kobject_get(&dev->kobj), "%s", "queue");
Liu Yuaned5302d2011-04-19 13:47:58 +0200571 if (ret < 0) {
572 blk_trace_remove_sysfs(dev);
Jens Axboe8324aa92008-01-29 14:51:59 +0100573 return ret;
Liu Yuaned5302d2011-04-19 13:47:58 +0200574 }
Jens Axboe8324aa92008-01-29 14:51:59 +0100575
576 kobject_uevent(&q->kobj, KOBJ_ADD);
577
Jens Axboe320ae512013-10-24 09:20:05 +0100578 if (q->mq_ops)
579 blk_mq_register_disk(disk);
580
Martin K. Petersencd43e262009-05-22 17:17:52 -0400581 if (!q->request_fn)
582 return 0;
583
Jens Axboe8324aa92008-01-29 14:51:59 +0100584 ret = elv_register_queue(q);
585 if (ret) {
586 kobject_uevent(&q->kobj, KOBJ_REMOVE);
587 kobject_del(&q->kobj);
Liu Yuan80656b62011-04-13 22:14:54 +0200588 blk_trace_remove_sysfs(dev);
Xiaotian Fengc87ffbb2010-08-23 12:30:29 +0200589 kobject_put(&dev->kobj);
Jens Axboe8324aa92008-01-29 14:51:59 +0100590 return ret;
591 }
592
593 return 0;
594}
595
596void blk_unregister_queue(struct gendisk *disk)
597{
598 struct request_queue *q = disk->queue;
599
Akinobu Mitafb199742008-04-21 09:51:06 +0200600 if (WARN_ON(!q))
601 return;
602
Jens Axboe320ae512013-10-24 09:20:05 +0100603 if (q->mq_ops)
604 blk_mq_unregister_disk(disk);
605
Zdenek Kabelac48c0d4d2009-09-25 06:19:26 +0200606 if (q->request_fn)
Jens Axboe8324aa92008-01-29 14:51:59 +0100607 elv_unregister_queue(q);
608
Zdenek Kabelac48c0d4d2009-09-25 06:19:26 +0200609 kobject_uevent(&q->kobj, KOBJ_REMOVE);
610 kobject_del(&q->kobj);
611 blk_trace_remove_sysfs(disk_to_dev(disk));
612 kobject_put(&disk_to_dev(disk)->kobj);
Jens Axboe8324aa92008-01-29 14:51:59 +0100613}