projects / linux-block.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
block: remove blk_queue_zone_sectors
[linux-block.git] / block / blk-sysfs.c
... / ...
CommitLineData
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Functions related to sysfs handling
4 */
5#include <linux/kernel.h>
6#include <linux/slab.h>
7#include <linux/module.h>
8#include <linux/bio.h>
9#include <linux/blkdev.h>
10#include <linux/backing-dev.h>
11#include <linux/blktrace_api.h>
12#include <linux/blk-mq.h>
13#include <linux/debugfs.h>
14
15#include "blk.h"
16#include "blk-mq.h"
17#include "blk-mq-debugfs.h"
18#include "blk-mq-sched.h"
19#include "blk-wbt.h"
20#include "blk-cgroup.h"
21#include "blk-throttle.h"
22
23struct queue_sysfs_entry {
24 struct attribute attr;
25 ssize_t (*show)(struct request_queue *, char *);
26 ssize_t (*store)(struct request_queue *, const char *, size_t);
27};
28
29static ssize_t
30queue_var_show(unsigned long var, char *page)
31{
32 return sprintf(page, "%lu\n", var);
33}
34
35static ssize_t
36queue_var_store(unsigned long *var, const char *page, size_t count)
37{
38 int err;
39 unsigned long v;
40
41 err = kstrtoul(page, 10, &v);
42 if (err || v > UINT_MAX)
43 return -EINVAL;
44
45 *var = v;
46
47 return count;
48}
49
50static ssize_t queue_var_store64(s64 *var, const char *page)
51{
52 int err;
53 s64 v;
54
55 err = kstrtos64(page, 10, &v);
56 if (err < 0)
57 return err;
58
59 *var = v;
60 return 0;
61}
62
63static ssize_t queue_requests_show(struct request_queue *q, char *page)
64{
65 return queue_var_show(q->nr_requests, page);
66}
67
68static ssize_t
69queue_requests_store(struct request_queue *q, const char *page, size_t count)
70{
71 unsigned long nr;
72 int ret, err;
73
74 if (!queue_is_mq(q))
75 return -EINVAL;
76
77 ret = queue_var_store(&nr, page, count);
78 if (ret < 0)
79 return ret;
80
81 if (nr < BLKDEV_MIN_RQ)
82 nr = BLKDEV_MIN_RQ;
83
84 err = blk_mq_update_nr_requests(q, nr);
85 if (err)
86 return err;
87
88 return ret;
89}
90
91static ssize_t queue_ra_show(struct request_queue *q, char *page)
92{
93 unsigned long ra_kb;
94
95 if (!q->disk)
96 return -EINVAL;
97 ra_kb = q->disk->bdi->ra_pages << (PAGE_SHIFT - 10);
98 return queue_var_show(ra_kb, page);
99}
100
101static ssize_t
102queue_ra_store(struct request_queue *q, const char *page, size_t count)
103{
104 unsigned long ra_kb;
105 ssize_t ret;
106
107 if (!q->disk)
108 return -EINVAL;
109 ret = queue_var_store(&ra_kb, page, count);
110 if (ret < 0)
111 return ret;
112 q->disk->bdi->ra_pages = ra_kb >> (PAGE_SHIFT - 10);
113 return ret;
114}
115
116static ssize_t queue_max_sectors_show(struct request_queue *q, char *page)
117{
118 int max_sectors_kb = queue_max_sectors(q) >> 1;
119
120 return queue_var_show(max_sectors_kb, page);
121}
122
123static ssize_t queue_max_segments_show(struct request_queue *q, char *page)
124{
125 return queue_var_show(queue_max_segments(q), page);
126}
127
128static ssize_t queue_max_discard_segments_show(struct request_queue *q,
129 char *page)
130{
131 return queue_var_show(queue_max_discard_segments(q), page);
132}
133
134static ssize_t queue_max_integrity_segments_show(struct request_queue *q, char *page)
135{
136 return queue_var_show(q->limits.max_integrity_segments, page);
137}
138
139static ssize_t queue_max_segment_size_show(struct request_queue *q, char *page)
140{
141 return queue_var_show(queue_max_segment_size(q), page);
142}
143
144static ssize_t queue_logical_block_size_show(struct request_queue *q, char *page)
145{
146 return queue_var_show(queue_logical_block_size(q), page);
147}
148
149static ssize_t queue_physical_block_size_show(struct request_queue *q, char *page)
150{
151 return queue_var_show(queue_physical_block_size(q), page);
152}
153
154static ssize_t queue_chunk_sectors_show(struct request_queue *q, char *page)
155{
156 return queue_var_show(q->limits.chunk_sectors, 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);
167}
168
169static 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_hw_show(struct request_queue *q, char *page)
175{
176
177 return sprintf(page, "%llu\n",
178 (unsigned long long)q->limits.max_hw_discard_sectors << 9);
179}
180
181static ssize_t queue_discard_max_show(struct request_queue *q, char *page)
182{
183 return sprintf(page, "%llu\n",
184 (unsigned long long)q->limits.max_discard_sectors << 9);
185}
186
187static ssize_t queue_discard_max_store(struct request_queue *q,
188 const char *page, size_t count)
189{
190 unsigned long max_discard;
191 ssize_t ret = queue_var_store(&max_discard, page, count);
192
193 if (ret < 0)
194 return ret;
195
196 if (max_discard & (q->limits.discard_granularity - 1))
197 return -EINVAL;
198
199 max_discard >>= 9;
200 if (max_discard > UINT_MAX)
201 return -EINVAL;
202
203 if (max_discard > q->limits.max_hw_discard_sectors)
204 max_discard = q->limits.max_hw_discard_sectors;
205
206 q->limits.max_discard_sectors = max_discard;
207 return ret;
208}
209
210static ssize_t queue_discard_zeroes_data_show(struct request_queue *q, char *page)
211{
212 return queue_var_show(0, page);
213}
214
215static ssize_t queue_write_same_max_show(struct request_queue *q, char *page)
216{
217 return queue_var_show(0, page);
218}
219
220static ssize_t queue_write_zeroes_max_show(struct request_queue *q, char *page)
221{
222 return sprintf(page, "%llu\n",
223 (unsigned long long)q->limits.max_write_zeroes_sectors << 9);
224}
225
226static ssize_t queue_zone_write_granularity_show(struct request_queue *q,
227 char *page)
228{
229 return queue_var_show(queue_zone_write_granularity(q), page);
230}
231
232static ssize_t queue_zone_append_max_show(struct request_queue *q, char *page)
233{
234 unsigned long long max_sectors = q->limits.max_zone_append_sectors;
235
236 return sprintf(page, "%llu\n", max_sectors << SECTOR_SHIFT);
237}
238
239static ssize_t
240queue_max_sectors_store(struct request_queue *q, const char *page, size_t count)
241{
242 unsigned long max_sectors_kb,
243 max_hw_sectors_kb = queue_max_hw_sectors(q) >> 1,
244 page_kb = 1 << (PAGE_SHIFT - 10);
245 ssize_t ret = queue_var_store(&max_sectors_kb, page, count);
246
247 if (ret < 0)
248 return ret;
249
250 max_hw_sectors_kb = min_not_zero(max_hw_sectors_kb, (unsigned long)
251 q->limits.max_dev_sectors >> 1);
252
253 if (max_sectors_kb > max_hw_sectors_kb || max_sectors_kb < page_kb)
254 return -EINVAL;
255
256 spin_lock_irq(&q->queue_lock);
257 q->limits.max_sectors = max_sectors_kb << 1;
258 if (q->disk)
259 q->disk->bdi->io_pages = max_sectors_kb >> (PAGE_SHIFT - 10);
260 spin_unlock_irq(&q->queue_lock);
261
262 return ret;
263}
264
265static ssize_t queue_max_hw_sectors_show(struct request_queue *q, char *page)
266{
267 int max_hw_sectors_kb = queue_max_hw_sectors(q) >> 1;
268
269 return queue_var_show(max_hw_sectors_kb, page);
270}
271
272static ssize_t queue_virt_boundary_mask_show(struct request_queue *q, char *page)
273{
274 return queue_var_show(q->limits.virt_boundary_mask, page);
275}
276
277static ssize_t queue_dma_alignment_show(struct request_queue *q, char *page)
278{
279 return queue_var_show(queue_dma_alignment(q), page);
280}
281
282#define QUEUE_SYSFS_BIT_FNS(name, flag, neg) \
283static ssize_t \
284queue_##name##_show(struct request_queue *q, char *page) \
285{ \
286 int bit; \
287 bit = test_bit(QUEUE_FLAG_##flag, &q->queue_flags); \
288 return queue_var_show(neg ? !bit : bit, page); \
289} \
290static ssize_t \
291queue_##name##_store(struct request_queue *q, const char *page, size_t count) \
292{ \
293 unsigned long val; \
294 ssize_t ret; \
295 ret = queue_var_store(&val, page, count); \
296 if (ret < 0) \
297 return ret; \
298 if (neg) \
299 val = !val; \
300 \
301 if (val) \
302 blk_queue_flag_set(QUEUE_FLAG_##flag, q); \
303 else \
304 blk_queue_flag_clear(QUEUE_FLAG_##flag, q); \
305 return ret; \
306}
307
308QUEUE_SYSFS_BIT_FNS(nonrot, NONROT, 1);
309QUEUE_SYSFS_BIT_FNS(random, ADD_RANDOM, 0);
310QUEUE_SYSFS_BIT_FNS(iostats, IO_STAT, 0);
311QUEUE_SYSFS_BIT_FNS(stable_writes, STABLE_WRITES, 0);
312#undef QUEUE_SYSFS_BIT_FNS
313
314static ssize_t queue_zoned_show(struct request_queue *q, char *page)
315{
316 switch (blk_queue_zoned_model(q)) {
317 case BLK_ZONED_HA:
318 return sprintf(page, "host-aware\n");
319 case BLK_ZONED_HM:
320 return sprintf(page, "host-managed\n");
321 default:
322 return sprintf(page, "none\n");
323 }
324}
325
326static ssize_t queue_nr_zones_show(struct request_queue *q, char *page)
327{
328 return queue_var_show(blk_queue_nr_zones(q), page);
329}
330
331static ssize_t queue_max_open_zones_show(struct request_queue *q, char *page)
332{
333 return queue_var_show(bdev_max_open_zones(q->disk->part0), page);
334}
335
336static ssize_t queue_max_active_zones_show(struct request_queue *q, char *page)
337{
338 return queue_var_show(bdev_max_active_zones(q->disk->part0), page);
339}
340
341static ssize_t queue_nomerges_show(struct request_queue *q, char *page)
342{
343 return queue_var_show((blk_queue_nomerges(q) << 1) |
344 blk_queue_noxmerges(q), page);
345}
346
347static ssize_t queue_nomerges_store(struct request_queue *q, const char *page,
348 size_t count)
349{
350 unsigned long nm;
351 ssize_t ret = queue_var_store(&nm, page, count);
352
353 if (ret < 0)
354 return ret;
355
356 blk_queue_flag_clear(QUEUE_FLAG_NOMERGES, q);
357 blk_queue_flag_clear(QUEUE_FLAG_NOXMERGES, q);
358 if (nm == 2)
359 blk_queue_flag_set(QUEUE_FLAG_NOMERGES, q);
360 else if (nm)
361 blk_queue_flag_set(QUEUE_FLAG_NOXMERGES, q);
362
363 return ret;
364}
365
366static ssize_t queue_rq_affinity_show(struct request_queue *q, char *page)
367{
368 bool set = test_bit(QUEUE_FLAG_SAME_COMP, &q->queue_flags);
369 bool force = test_bit(QUEUE_FLAG_SAME_FORCE, &q->queue_flags);
370
371 return queue_var_show(set << force, page);
372}
373
374static ssize_t
375queue_rq_affinity_store(struct request_queue *q, const char *page, size_t count)
376{
377 ssize_t ret = -EINVAL;
378#ifdef CONFIG_SMP
379 unsigned long val;
380
381 ret = queue_var_store(&val, page, count);
382 if (ret < 0)
383 return ret;
384
385 if (val == 2) {
386 blk_queue_flag_set(QUEUE_FLAG_SAME_COMP, q);
387 blk_queue_flag_set(QUEUE_FLAG_SAME_FORCE, q);
388 } else if (val == 1) {
389 blk_queue_flag_set(QUEUE_FLAG_SAME_COMP, q);
390 blk_queue_flag_clear(QUEUE_FLAG_SAME_FORCE, q);
391 } else if (val == 0) {
392 blk_queue_flag_clear(QUEUE_FLAG_SAME_COMP, q);
393 blk_queue_flag_clear(QUEUE_FLAG_SAME_FORCE, q);
394 }
395#endif
396 return ret;
397}
398
399static ssize_t queue_poll_delay_show(struct request_queue *q, char *page)
400{
401 int val;
402
403 if (q->poll_nsec == BLK_MQ_POLL_CLASSIC)
404 val = BLK_MQ_POLL_CLASSIC;
405 else
406 val = q->poll_nsec / 1000;
407
408 return sprintf(page, "%d\n", val);
409}
410
411static ssize_t queue_poll_delay_store(struct request_queue *q, const char *page,
412 size_t count)
413{
414 int err, val;
415
416 if (!q->mq_ops || !q->mq_ops->poll)
417 return -EINVAL;
418
419 err = kstrtoint(page, 10, &val);
420 if (err < 0)
421 return err;
422
423 if (val == BLK_MQ_POLL_CLASSIC)
424 q->poll_nsec = BLK_MQ_POLL_CLASSIC;
425 else if (val >= 0)
426 q->poll_nsec = val * 1000;
427 else
428 return -EINVAL;
429
430 return count;
431}
432
433static ssize_t queue_poll_show(struct request_queue *q, char *page)
434{
435 return queue_var_show(test_bit(QUEUE_FLAG_POLL, &q->queue_flags), page);
436}
437
438static ssize_t queue_poll_store(struct request_queue *q, const char *page,
439 size_t count)
440{
441 if (!test_bit(QUEUE_FLAG_POLL, &q->queue_flags))
442 return -EINVAL;
443 pr_info_ratelimited("writes to the poll attribute are ignored.\n");
444 pr_info_ratelimited("please use driver specific parameters instead.\n");
445 return count;
446}
447
448static ssize_t queue_io_timeout_show(struct request_queue *q, char *page)
449{
450 return sprintf(page, "%u\n", jiffies_to_msecs(q->rq_timeout));
451}
452
453static ssize_t queue_io_timeout_store(struct request_queue *q, const char *page,
454 size_t count)
455{
456 unsigned int val;
457 int err;
458
459 err = kstrtou32(page, 10, &val);
460 if (err || val == 0)
461 return -EINVAL;
462
463 blk_queue_rq_timeout(q, msecs_to_jiffies(val));
464
465 return count;
466}
467
468static ssize_t queue_wb_lat_show(struct request_queue *q, char *page)
469{
470 if (!wbt_rq_qos(q))
471 return -EINVAL;
472
473 return sprintf(page, "%llu\n", div_u64(wbt_get_min_lat(q), 1000));
474}
475
476static ssize_t queue_wb_lat_store(struct request_queue *q, const char *page,
477 size_t count)
478{
479 struct rq_qos *rqos;
480 ssize_t ret;
481 s64 val;
482
483 ret = queue_var_store64(&val, page);
484 if (ret < 0)
485 return ret;
486 if (val < -1)
487 return -EINVAL;
488
489 rqos = wbt_rq_qos(q);
490 if (!rqos) {
491 ret = wbt_init(q);
492 if (ret)
493 return ret;
494 }
495
496 if (val == -1)
497 val = wbt_default_latency_nsec(q);
498 else if (val >= 0)
499 val *= 1000ULL;
500
501 if (wbt_get_min_lat(q) == val)
502 return count;
503
504 /*
505 * Ensure that the queue is idled, in case the latency update
506 * ends up either enabling or disabling wbt completely. We can't
507 * have IO inflight if that happens.
508 */
509 blk_mq_freeze_queue(q);
510 blk_mq_quiesce_queue(q);
511
512 wbt_set_min_lat(q, val);
513
514 blk_mq_unquiesce_queue(q);
515 blk_mq_unfreeze_queue(q);
516
517 return count;
518}
519
520static ssize_t queue_wc_show(struct request_queue *q, char *page)
521{
522 if (test_bit(QUEUE_FLAG_WC, &q->queue_flags))
523 return sprintf(page, "write back\n");
524
525 return sprintf(page, "write through\n");
526}
527
528static ssize_t queue_wc_store(struct request_queue *q, const char *page,
529 size_t count)
530{
531 int set = -1;
532
533 if (!strncmp(page, "write back", 10))
534 set = 1;
535 else if (!strncmp(page, "write through", 13) ||
536 !strncmp(page, "none", 4))
537 set = 0;
538
539 if (set == -1)
540 return -EINVAL;
541
542 if (set)
543 blk_queue_flag_set(QUEUE_FLAG_WC, q);
544 else
545 blk_queue_flag_clear(QUEUE_FLAG_WC, q);
546
547 return count;
548}
549
550static ssize_t queue_fua_show(struct request_queue *q, char *page)
551{
552 return sprintf(page, "%u\n", test_bit(QUEUE_FLAG_FUA, &q->queue_flags));
553}
554
555static ssize_t queue_dax_show(struct request_queue *q, char *page)
556{
557 return queue_var_show(blk_queue_dax(q), page);
558}
559
560#define QUEUE_RO_ENTRY(_prefix, _name) \
561static struct queue_sysfs_entry _prefix##_entry = { \
562 .attr = { .name = _name, .mode = 0444 }, \
563 .show = _prefix##_show, \
564};
565
566#define QUEUE_RW_ENTRY(_prefix, _name) \
567static struct queue_sysfs_entry _prefix##_entry = { \
568 .attr = { .name = _name, .mode = 0644 }, \
569 .show = _prefix##_show, \
570 .store = _prefix##_store, \
571};
572
573QUEUE_RW_ENTRY(queue_requests, "nr_requests");
574QUEUE_RW_ENTRY(queue_ra, "read_ahead_kb");
575QUEUE_RW_ENTRY(queue_max_sectors, "max_sectors_kb");
576QUEUE_RO_ENTRY(queue_max_hw_sectors, "max_hw_sectors_kb");
577QUEUE_RO_ENTRY(queue_max_segments, "max_segments");
578QUEUE_RO_ENTRY(queue_max_integrity_segments, "max_integrity_segments");
579QUEUE_RO_ENTRY(queue_max_segment_size, "max_segment_size");
580QUEUE_RW_ENTRY(elv_iosched, "scheduler");
581
582QUEUE_RO_ENTRY(queue_logical_block_size, "logical_block_size");
583QUEUE_RO_ENTRY(queue_physical_block_size, "physical_block_size");
584QUEUE_RO_ENTRY(queue_chunk_sectors, "chunk_sectors");
585QUEUE_RO_ENTRY(queue_io_min, "minimum_io_size");
586QUEUE_RO_ENTRY(queue_io_opt, "optimal_io_size");
587
588QUEUE_RO_ENTRY(queue_max_discard_segments, "max_discard_segments");
589QUEUE_RO_ENTRY(queue_discard_granularity, "discard_granularity");
590QUEUE_RO_ENTRY(queue_discard_max_hw, "discard_max_hw_bytes");
591QUEUE_RW_ENTRY(queue_discard_max, "discard_max_bytes");
592QUEUE_RO_ENTRY(queue_discard_zeroes_data, "discard_zeroes_data");
593
594QUEUE_RO_ENTRY(queue_write_same_max, "write_same_max_bytes");
595QUEUE_RO_ENTRY(queue_write_zeroes_max, "write_zeroes_max_bytes");
596QUEUE_RO_ENTRY(queue_zone_append_max, "zone_append_max_bytes");
597QUEUE_RO_ENTRY(queue_zone_write_granularity, "zone_write_granularity");
598
599QUEUE_RO_ENTRY(queue_zoned, "zoned");
600QUEUE_RO_ENTRY(queue_nr_zones, "nr_zones");
601QUEUE_RO_ENTRY(queue_max_open_zones, "max_open_zones");
602QUEUE_RO_ENTRY(queue_max_active_zones, "max_active_zones");
603
604QUEUE_RW_ENTRY(queue_nomerges, "nomerges");
605QUEUE_RW_ENTRY(queue_rq_affinity, "rq_affinity");
606QUEUE_RW_ENTRY(queue_poll, "io_poll");
607QUEUE_RW_ENTRY(queue_poll_delay, "io_poll_delay");
608QUEUE_RW_ENTRY(queue_wc, "write_cache");
609QUEUE_RO_ENTRY(queue_fua, "fua");
610QUEUE_RO_ENTRY(queue_dax, "dax");
611QUEUE_RW_ENTRY(queue_io_timeout, "io_timeout");
612QUEUE_RW_ENTRY(queue_wb_lat, "wbt_lat_usec");
613QUEUE_RO_ENTRY(queue_virt_boundary_mask, "virt_boundary_mask");
614QUEUE_RO_ENTRY(queue_dma_alignment, "dma_alignment");
615
616#ifdef CONFIG_BLK_DEV_THROTTLING_LOW
617QUEUE_RW_ENTRY(blk_throtl_sample_time, "throttle_sample_time");
618#endif
619
620/* legacy alias for logical_block_size: */
621static struct queue_sysfs_entry queue_hw_sector_size_entry = {
622 .attr = {.name = "hw_sector_size", .mode = 0444 },
623 .show = queue_logical_block_size_show,
624};
625
626QUEUE_RW_ENTRY(queue_nonrot, "rotational");
627QUEUE_RW_ENTRY(queue_iostats, "iostats");
628QUEUE_RW_ENTRY(queue_random, "add_random");
629QUEUE_RW_ENTRY(queue_stable_writes, "stable_writes");
630
631static struct attribute *queue_attrs[] = {
632 &queue_requests_entry.attr,
633 &queue_ra_entry.attr,
634 &queue_max_hw_sectors_entry.attr,
635 &queue_max_sectors_entry.attr,
636 &queue_max_segments_entry.attr,
637 &queue_max_discard_segments_entry.attr,
638 &queue_max_integrity_segments_entry.attr,
639 &queue_max_segment_size_entry.attr,
640 &elv_iosched_entry.attr,
641 &queue_hw_sector_size_entry.attr,
642 &queue_logical_block_size_entry.attr,
643 &queue_physical_block_size_entry.attr,
644 &queue_chunk_sectors_entry.attr,
645 &queue_io_min_entry.attr,
646 &queue_io_opt_entry.attr,
647 &queue_discard_granularity_entry.attr,
648 &queue_discard_max_entry.attr,
649 &queue_discard_max_hw_entry.attr,
650 &queue_discard_zeroes_data_entry.attr,
651 &queue_write_same_max_entry.attr,
652 &queue_write_zeroes_max_entry.attr,
653 &queue_zone_append_max_entry.attr,
654 &queue_zone_write_granularity_entry.attr,
655 &queue_nonrot_entry.attr,
656 &queue_zoned_entry.attr,
657 &queue_nr_zones_entry.attr,
658 &queue_max_open_zones_entry.attr,
659 &queue_max_active_zones_entry.attr,
660 &queue_nomerges_entry.attr,
661 &queue_rq_affinity_entry.attr,
662 &queue_iostats_entry.attr,
663 &queue_stable_writes_entry.attr,
664 &queue_random_entry.attr,
665 &queue_poll_entry.attr,
666 &queue_wc_entry.attr,
667 &queue_fua_entry.attr,
668 &queue_dax_entry.attr,
669 &queue_wb_lat_entry.attr,
670 &queue_poll_delay_entry.attr,
671 &queue_io_timeout_entry.attr,
672#ifdef CONFIG_BLK_DEV_THROTTLING_LOW
673 &blk_throtl_sample_time_entry.attr,
674#endif
675 &queue_virt_boundary_mask_entry.attr,
676 &queue_dma_alignment_entry.attr,
677 NULL,
678};
679
680static umode_t queue_attr_visible(struct kobject *kobj, struct attribute *attr,
681 int n)
682{
683 struct request_queue *q =
684 container_of(kobj, struct request_queue, kobj);
685
686 if (attr == &queue_io_timeout_entry.attr &&
687 (!q->mq_ops || !q->mq_ops->timeout))
688 return 0;
689
690 if ((attr == &queue_max_open_zones_entry.attr ||
691 attr == &queue_max_active_zones_entry.attr) &&
692 !blk_queue_is_zoned(q))
693 return 0;
694
695 return attr->mode;
696}
697
698static struct attribute_group queue_attr_group = {
699 .attrs = queue_attrs,
700 .is_visible = queue_attr_visible,
701};
702
703
704#define to_queue(atr) container_of((atr), struct queue_sysfs_entry, attr)
705
706static ssize_t
707queue_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
708{
709 struct queue_sysfs_entry *entry = to_queue(attr);
710 struct request_queue *q =
711 container_of(kobj, struct request_queue, kobj);
712 ssize_t res;
713
714 if (!entry->show)
715 return -EIO;
716 mutex_lock(&q->sysfs_lock);
717 res = entry->show(q, page);
718 mutex_unlock(&q->sysfs_lock);
719 return res;
720}
721
722static ssize_t
723queue_attr_store(struct kobject *kobj, struct attribute *attr,
724 const char *page, size_t length)
725{
726 struct queue_sysfs_entry *entry = to_queue(attr);
727 struct request_queue *q;
728 ssize_t res;
729
730 if (!entry->store)
731 return -EIO;
732
733 q = container_of(kobj, struct request_queue, kobj);
734 mutex_lock(&q->sysfs_lock);
735 res = entry->store(q, page, length);
736 mutex_unlock(&q->sysfs_lock);
737 return res;
738}
739
740static void blk_free_queue_rcu(struct rcu_head *rcu_head)
741{
742 struct request_queue *q = container_of(rcu_head, struct request_queue,
743 rcu_head);
744
745 kmem_cache_free(blk_get_queue_kmem_cache(blk_queue_has_srcu(q)), q);
746}
747
748/**
749 * blk_release_queue - releases all allocated resources of the request_queue
750 * @kobj: pointer to a kobject, whose container is a request_queue
751 *
752 * This function releases all allocated resources of the request queue.
753 *
754 * The struct request_queue refcount is incremented with blk_get_queue() and
755 * decremented with blk_put_queue(). Once the refcount reaches 0 this function
756 * is called.
757 *
758 * Drivers exist which depend on the release of the request_queue to be
759 * synchronous, it should not be deferred.
760 *
761 * Context: can sleep
762 */
763static void blk_release_queue(struct kobject *kobj)
764{
765 struct request_queue *q =
766 container_of(kobj, struct request_queue, kobj);
767
768 might_sleep();
769
770 percpu_ref_exit(&q->q_usage_counter);
771
772 if (q->poll_stat)
773 blk_stat_remove_callback(q, q->poll_cb);
774 blk_stat_free_callback(q->poll_cb);
775
776 blk_free_queue_stats(q->stats);
777 kfree(q->poll_stat);
778
779 if (queue_is_mq(q))
780 blk_mq_release(q);
781
782 bioset_exit(&q->bio_split);
783
784 if (blk_queue_has_srcu(q))
785 cleanup_srcu_struct(q->srcu);
786
787 ida_free(&blk_queue_ida, q->id);
788 call_rcu(&q->rcu_head, blk_free_queue_rcu);
789}
790
791static const struct sysfs_ops queue_sysfs_ops = {
792 .show = queue_attr_show,
793 .store = queue_attr_store,
794};
795
796static const struct attribute_group *blk_queue_attr_groups[] = {
797 &queue_attr_group,
798 NULL
799};
800
801struct kobj_type blk_queue_ktype = {
802 .default_groups = blk_queue_attr_groups,
803 .sysfs_ops = &queue_sysfs_ops,
804 .release = blk_release_queue,
805};
806
807/**
808 * blk_register_queue - register a block layer queue with sysfs
809 * @disk: Disk of which the request queue should be registered with sysfs.
810 */
811int blk_register_queue(struct gendisk *disk)
812{
813 struct request_queue *q = disk->queue;
814 int ret;
815
816 mutex_lock(&q->sysfs_dir_lock);
817
818 ret = kobject_add(&q->kobj, &disk_to_dev(disk)->kobj, "queue");
819 if (ret < 0)
820 goto unlock;
821
822 if (queue_is_mq(q))
823 blk_mq_sysfs_register(disk);
824 mutex_lock(&q->sysfs_lock);
825
826 mutex_lock(&q->debugfs_mutex);
827 q->debugfs_dir = debugfs_create_dir(kobject_name(q->kobj.parent),
828 blk_debugfs_root);
829 if (queue_is_mq(q))
830 blk_mq_debugfs_register(q);
831 mutex_unlock(&q->debugfs_mutex);
832
833 ret = disk_register_independent_access_ranges(disk);
834 if (ret)
835 goto put_dev;
836
837 if (q->elevator) {
838 ret = elv_register_queue(q, false);
839 if (ret)
840 goto put_dev;
841 }
842
843 ret = blk_crypto_sysfs_register(q);
844 if (ret)
845 goto put_dev;
846
847 blk_queue_flag_set(QUEUE_FLAG_REGISTERED, q);
848 wbt_enable_default(q);
849 blk_throtl_register_queue(q);
850
851 /* Now everything is ready and send out KOBJ_ADD uevent */
852 kobject_uevent(&q->kobj, KOBJ_ADD);
853 if (q->elevator)
854 kobject_uevent(&q->elevator->kobj, KOBJ_ADD);
855 mutex_unlock(&q->sysfs_lock);
856
857unlock:
858 mutex_unlock(&q->sysfs_dir_lock);
859
860 /*
861 * SCSI probing may synchronously create and destroy a lot of
862 * request_queues for non-existent devices. Shutting down a fully
863 * functional queue takes measureable wallclock time as RCU grace
864 * periods are involved. To avoid excessive latency in these
865 * cases, a request_queue starts out in a degraded mode which is
866 * faster to shut down and is made fully functional here as
867 * request_queues for non-existent devices never get registered.
868 */
869 if (!blk_queue_init_done(q)) {
870 blk_queue_flag_set(QUEUE_FLAG_INIT_DONE, q);
871 percpu_ref_switch_to_percpu(&q->q_usage_counter);
872 }
873
874 return ret;
875
876put_dev:
877 elv_unregister_queue(q);
878 disk_unregister_independent_access_ranges(disk);
879 mutex_unlock(&q->sysfs_lock);
880 mutex_unlock(&q->sysfs_dir_lock);
881 kobject_del(&q->kobj);
882
883 return ret;
884}
885
886/**
887 * blk_unregister_queue - counterpart of blk_register_queue()
888 * @disk: Disk of which the request queue should be unregistered from sysfs.
889 *
890 * Note: the caller is responsible for guaranteeing that this function is called
891 * after blk_register_queue() has finished.
892 */
893void blk_unregister_queue(struct gendisk *disk)
894{
895 struct request_queue *q = disk->queue;
896
897 if (WARN_ON(!q))
898 return;
899
900 /* Return early if disk->queue was never registered. */
901 if (!blk_queue_registered(q))
902 return;
903
904 /*
905 * Since sysfs_remove_dir() prevents adding new directory entries
906 * before removal of existing entries starts, protect against
907 * concurrent elv_iosched_store() calls.
908 */
909 mutex_lock(&q->sysfs_lock);
910 blk_queue_flag_clear(QUEUE_FLAG_REGISTERED, q);
911 mutex_unlock(&q->sysfs_lock);
912
913 mutex_lock(&q->sysfs_dir_lock);
914 /*
915 * Remove the sysfs attributes before unregistering the queue data
916 * structures that can be modified through sysfs.
917 */
918 if (queue_is_mq(q))
919 blk_mq_sysfs_unregister(disk);
920 blk_crypto_sysfs_unregister(q);
921
922 mutex_lock(&q->sysfs_lock);
923 elv_unregister_queue(q);
924 disk_unregister_independent_access_ranges(disk);
925 mutex_unlock(&q->sysfs_lock);
926
927 /* Now that we've deleted all child objects, we can delete the queue. */
928 kobject_uevent(&q->kobj, KOBJ_REMOVE);
929 kobject_del(&q->kobj);
930 mutex_unlock(&q->sysfs_dir_lock);
931
932 mutex_lock(&q->debugfs_mutex);
933 blk_trace_shutdown(q);
934 debugfs_remove_recursive(q->debugfs_dir);
935 q->debugfs_dir = NULL;
936 q->sched_debugfs_dir = NULL;
937 q->rqos_debugfs_dir = NULL;
938 mutex_unlock(&q->debugfs_mutex);
939}
Linux 6.x block layer and io_uring tree(s)