2 * Functions related to sysfs handling
4 #include <linux/kernel.h>
5 #include <linux/slab.h>
6 #include <linux/module.h>
8 #include <linux/blkdev.h>
9 #include <linux/backing-dev.h>
10 #include <linux/blktrace_api.h>
11 #include <linux/blk-mq.h>
12 #include <linux/blk-cgroup.h>
18 struct queue_sysfs_entry
{
19 struct attribute attr
;
20 ssize_t (*show
)(struct request_queue
*, char *);
21 ssize_t (*store
)(struct request_queue
*, const char *, size_t);
25 queue_var_show(unsigned long var
, char *page
)
27 return sprintf(page
, "%lu\n", var
);
31 queue_var_store(unsigned long *var
, const char *page
, size_t count
)
36 err
= kstrtoul(page
, 10, &v
);
37 if (err
|| v
> UINT_MAX
)
45 static ssize_t
queue_var_store64(s64
*var
, const char *page
)
50 err
= kstrtos64(page
, 10, &v
);
58 static ssize_t
queue_requests_show(struct request_queue
*q
, char *page
)
60 return queue_var_show(q
->nr_requests
, (page
));
64 queue_requests_store(struct request_queue
*q
, const char *page
, size_t count
)
69 if (!q
->request_fn
&& !q
->mq_ops
)
72 ret
= queue_var_store(&nr
, page
, count
);
76 if (nr
< BLKDEV_MIN_RQ
)
80 err
= blk_update_nr_requests(q
, nr
);
82 err
= blk_mq_update_nr_requests(q
, nr
);
90 static ssize_t
queue_ra_show(struct request_queue
*q
, char *page
)
92 unsigned long ra_kb
= q
->backing_dev_info
->ra_pages
<<
95 return queue_var_show(ra_kb
, (page
));
99 queue_ra_store(struct request_queue
*q
, const char *page
, size_t count
)
102 ssize_t ret
= queue_var_store(&ra_kb
, page
, count
);
107 q
->backing_dev_info
->ra_pages
= ra_kb
>> (PAGE_SHIFT
- 10);
112 static ssize_t
queue_max_sectors_show(struct request_queue
*q
, char *page
)
114 int max_sectors_kb
= queue_max_sectors(q
) >> 1;
116 return queue_var_show(max_sectors_kb
, (page
));
119 static ssize_t
queue_max_segments_show(struct request_queue
*q
, char *page
)
121 return queue_var_show(queue_max_segments(q
), (page
));
124 static ssize_t
queue_max_discard_segments_show(struct request_queue
*q
,
127 return queue_var_show(queue_max_discard_segments(q
), (page
));
130 static ssize_t
queue_max_integrity_segments_show(struct request_queue
*q
, char *page
)
132 return queue_var_show(q
->limits
.max_integrity_segments
, (page
));
135 static ssize_t
queue_max_segment_size_show(struct request_queue
*q
, char *page
)
137 if (blk_queue_cluster(q
))
138 return queue_var_show(queue_max_segment_size(q
), (page
));
140 return queue_var_show(PAGE_SIZE
, (page
));
143 static ssize_t
queue_logical_block_size_show(struct request_queue
*q
, char *page
)
145 return queue_var_show(queue_logical_block_size(q
), page
);
148 static ssize_t
queue_physical_block_size_show(struct request_queue
*q
, char *page
)
150 return queue_var_show(queue_physical_block_size(q
), page
);
153 static ssize_t
queue_chunk_sectors_show(struct request_queue
*q
, char *page
)
155 return queue_var_show(q
->limits
.chunk_sectors
, page
);
158 static ssize_t
queue_io_min_show(struct request_queue
*q
, char *page
)
160 return queue_var_show(queue_io_min(q
), page
);
163 static ssize_t
queue_io_opt_show(struct request_queue
*q
, char *page
)
165 return queue_var_show(queue_io_opt(q
), page
);
168 static ssize_t
queue_discard_granularity_show(struct request_queue
*q
, char *page
)
170 return queue_var_show(q
->limits
.discard_granularity
, page
);
173 static ssize_t
queue_discard_max_hw_show(struct request_queue
*q
, char *page
)
176 return sprintf(page
, "%llu\n",
177 (unsigned long long)q
->limits
.max_hw_discard_sectors
<< 9);
180 static ssize_t
queue_discard_max_show(struct request_queue
*q
, char *page
)
182 return sprintf(page
, "%llu\n",
183 (unsigned long long)q
->limits
.max_discard_sectors
<< 9);
186 static ssize_t
queue_discard_max_store(struct request_queue
*q
,
187 const char *page
, size_t count
)
189 unsigned long max_discard
;
190 ssize_t ret
= queue_var_store(&max_discard
, page
, count
);
195 if (max_discard
& (q
->limits
.discard_granularity
- 1))
199 if (max_discard
> UINT_MAX
)
202 if (max_discard
> q
->limits
.max_hw_discard_sectors
)
203 max_discard
= q
->limits
.max_hw_discard_sectors
;
205 q
->limits
.max_discard_sectors
= max_discard
;
209 static ssize_t
queue_discard_zeroes_data_show(struct request_queue
*q
, char *page
)
211 return queue_var_show(0, page
);
214 static ssize_t
queue_write_same_max_show(struct request_queue
*q
, char *page
)
216 return sprintf(page
, "%llu\n",
217 (unsigned long long)q
->limits
.max_write_same_sectors
<< 9);
220 static ssize_t
queue_write_zeroes_max_show(struct request_queue
*q
, char *page
)
222 return sprintf(page
, "%llu\n",
223 (unsigned long long)q
->limits
.max_write_zeroes_sectors
<< 9);
227 queue_max_sectors_store(struct request_queue
*q
, const char *page
, size_t count
)
229 unsigned long max_sectors_kb
,
230 max_hw_sectors_kb
= queue_max_hw_sectors(q
) >> 1,
231 page_kb
= 1 << (PAGE_SHIFT
- 10);
232 ssize_t ret
= queue_var_store(&max_sectors_kb
, page
, count
);
237 max_hw_sectors_kb
= min_not_zero(max_hw_sectors_kb
, (unsigned long)
238 q
->limits
.max_dev_sectors
>> 1);
240 if (max_sectors_kb
> max_hw_sectors_kb
|| max_sectors_kb
< page_kb
)
243 spin_lock_irq(q
->queue_lock
);
244 q
->limits
.max_sectors
= max_sectors_kb
<< 1;
245 q
->backing_dev_info
->io_pages
= max_sectors_kb
>> (PAGE_SHIFT
- 10);
246 spin_unlock_irq(q
->queue_lock
);
251 static ssize_t
queue_max_hw_sectors_show(struct request_queue
*q
, char *page
)
253 int max_hw_sectors_kb
= queue_max_hw_sectors(q
) >> 1;
255 return queue_var_show(max_hw_sectors_kb
, (page
));
258 #define QUEUE_SYSFS_BIT_FNS(name, flag, neg) \
260 queue_show_##name(struct request_queue *q, char *page) \
263 bit = test_bit(QUEUE_FLAG_##flag, &q->queue_flags); \
264 return queue_var_show(neg ? !bit : bit, page); \
267 queue_store_##name(struct request_queue *q, const char *page, size_t count) \
271 ret = queue_var_store(&val, page, count); \
277 spin_lock_irq(q->queue_lock); \
279 queue_flag_set(QUEUE_FLAG_##flag, q); \
281 queue_flag_clear(QUEUE_FLAG_##flag, q); \
282 spin_unlock_irq(q->queue_lock); \
286 QUEUE_SYSFS_BIT_FNS(nonrot
, NONROT
, 1);
287 QUEUE_SYSFS_BIT_FNS(random
, ADD_RANDOM
, 0);
288 QUEUE_SYSFS_BIT_FNS(iostats
, IO_STAT
, 0);
289 #undef QUEUE_SYSFS_BIT_FNS
291 static ssize_t
queue_zoned_show(struct request_queue
*q
, char *page
)
293 switch (blk_queue_zoned_model(q
)) {
295 return sprintf(page
, "host-aware\n");
297 return sprintf(page
, "host-managed\n");
299 return sprintf(page
, "none\n");
303 static ssize_t
queue_nomerges_show(struct request_queue
*q
, char *page
)
305 return queue_var_show((blk_queue_nomerges(q
) << 1) |
306 blk_queue_noxmerges(q
), page
);
309 static ssize_t
queue_nomerges_store(struct request_queue
*q
, const char *page
,
313 ssize_t ret
= queue_var_store(&nm
, page
, count
);
318 spin_lock_irq(q
->queue_lock
);
319 queue_flag_clear(QUEUE_FLAG_NOMERGES
, q
);
320 queue_flag_clear(QUEUE_FLAG_NOXMERGES
, q
);
322 queue_flag_set(QUEUE_FLAG_NOMERGES
, q
);
324 queue_flag_set(QUEUE_FLAG_NOXMERGES
, q
);
325 spin_unlock_irq(q
->queue_lock
);
330 static ssize_t
queue_rq_affinity_show(struct request_queue
*q
, char *page
)
332 bool set
= test_bit(QUEUE_FLAG_SAME_COMP
, &q
->queue_flags
);
333 bool force
= test_bit(QUEUE_FLAG_SAME_FORCE
, &q
->queue_flags
);
335 return queue_var_show(set
<< force
, page
);
339 queue_rq_affinity_store(struct request_queue
*q
, const char *page
, size_t count
)
341 ssize_t ret
= -EINVAL
;
345 ret
= queue_var_store(&val
, page
, count
);
349 spin_lock_irq(q
->queue_lock
);
351 queue_flag_set(QUEUE_FLAG_SAME_COMP
, q
);
352 queue_flag_set(QUEUE_FLAG_SAME_FORCE
, q
);
353 } else if (val
== 1) {
354 queue_flag_set(QUEUE_FLAG_SAME_COMP
, q
);
355 queue_flag_clear(QUEUE_FLAG_SAME_FORCE
, q
);
356 } else if (val
== 0) {
357 queue_flag_clear(QUEUE_FLAG_SAME_COMP
, q
);
358 queue_flag_clear(QUEUE_FLAG_SAME_FORCE
, q
);
360 spin_unlock_irq(q
->queue_lock
);
365 static ssize_t
queue_poll_delay_show(struct request_queue
*q
, char *page
)
369 if (q
->poll_nsec
== -1)
372 val
= q
->poll_nsec
/ 1000;
374 return sprintf(page
, "%d\n", val
);
377 static ssize_t
queue_poll_delay_store(struct request_queue
*q
, const char *page
,
382 if (!q
->mq_ops
|| !q
->mq_ops
->poll
)
385 err
= kstrtoint(page
, 10, &val
);
392 q
->poll_nsec
= val
* 1000;
397 static ssize_t
queue_poll_show(struct request_queue
*q
, char *page
)
399 return queue_var_show(test_bit(QUEUE_FLAG_POLL
, &q
->queue_flags
), page
);
402 static ssize_t
queue_poll_store(struct request_queue
*q
, const char *page
,
405 unsigned long poll_on
;
408 if (!q
->mq_ops
|| !q
->mq_ops
->poll
)
411 ret
= queue_var_store(&poll_on
, page
, count
);
415 spin_lock_irq(q
->queue_lock
);
417 queue_flag_set(QUEUE_FLAG_POLL
, q
);
419 queue_flag_clear(QUEUE_FLAG_POLL
, q
);
420 spin_unlock_irq(q
->queue_lock
);
425 static ssize_t
queue_wb_lat_show(struct request_queue
*q
, char *page
)
430 return sprintf(page
, "%llu\n", div_u64(q
->rq_wb
->min_lat_nsec
, 1000));
433 static ssize_t
queue_wb_lat_store(struct request_queue
*q
, const char *page
,
440 ret
= queue_var_store64(&val
, page
);
458 rwb
->min_lat_nsec
= wbt_default_latency_nsec(q
);
460 rwb
->min_lat_nsec
= val
* 1000ULL;
462 if (rwb
->enable_state
== WBT_STATE_ON_DEFAULT
)
463 rwb
->enable_state
= WBT_STATE_ON_MANUAL
;
465 wbt_update_limits(rwb
);
469 static ssize_t
queue_wc_show(struct request_queue
*q
, char *page
)
471 if (test_bit(QUEUE_FLAG_WC
, &q
->queue_flags
))
472 return sprintf(page
, "write back\n");
474 return sprintf(page
, "write through\n");
477 static ssize_t
queue_wc_store(struct request_queue
*q
, const char *page
,
482 if (!strncmp(page
, "write back", 10))
484 else if (!strncmp(page
, "write through", 13) ||
485 !strncmp(page
, "none", 4))
491 spin_lock_irq(q
->queue_lock
);
493 queue_flag_set(QUEUE_FLAG_WC
, q
);
495 queue_flag_clear(QUEUE_FLAG_WC
, q
);
496 spin_unlock_irq(q
->queue_lock
);
501 static ssize_t
queue_dax_show(struct request_queue
*q
, char *page
)
503 return queue_var_show(blk_queue_dax(q
), page
);
506 static struct queue_sysfs_entry queue_requests_entry
= {
507 .attr
= {.name
= "nr_requests", .mode
= S_IRUGO
| S_IWUSR
},
508 .show
= queue_requests_show
,
509 .store
= queue_requests_store
,
512 static struct queue_sysfs_entry queue_ra_entry
= {
513 .attr
= {.name
= "read_ahead_kb", .mode
= S_IRUGO
| S_IWUSR
},
514 .show
= queue_ra_show
,
515 .store
= queue_ra_store
,
518 static struct queue_sysfs_entry queue_max_sectors_entry
= {
519 .attr
= {.name
= "max_sectors_kb", .mode
= S_IRUGO
| S_IWUSR
},
520 .show
= queue_max_sectors_show
,
521 .store
= queue_max_sectors_store
,
524 static struct queue_sysfs_entry queue_max_hw_sectors_entry
= {
525 .attr
= {.name
= "max_hw_sectors_kb", .mode
= S_IRUGO
},
526 .show
= queue_max_hw_sectors_show
,
529 static struct queue_sysfs_entry queue_max_segments_entry
= {
530 .attr
= {.name
= "max_segments", .mode
= S_IRUGO
},
531 .show
= queue_max_segments_show
,
534 static struct queue_sysfs_entry queue_max_discard_segments_entry
= {
535 .attr
= {.name
= "max_discard_segments", .mode
= S_IRUGO
},
536 .show
= queue_max_discard_segments_show
,
539 static struct queue_sysfs_entry queue_max_integrity_segments_entry
= {
540 .attr
= {.name
= "max_integrity_segments", .mode
= S_IRUGO
},
541 .show
= queue_max_integrity_segments_show
,
544 static struct queue_sysfs_entry queue_max_segment_size_entry
= {
545 .attr
= {.name
= "max_segment_size", .mode
= S_IRUGO
},
546 .show
= queue_max_segment_size_show
,
549 static struct queue_sysfs_entry queue_iosched_entry
= {
550 .attr
= {.name
= "scheduler", .mode
= S_IRUGO
| S_IWUSR
},
551 .show
= elv_iosched_show
,
552 .store
= elv_iosched_store
,
555 static struct queue_sysfs_entry queue_hw_sector_size_entry
= {
556 .attr
= {.name
= "hw_sector_size", .mode
= S_IRUGO
},
557 .show
= queue_logical_block_size_show
,
560 static struct queue_sysfs_entry queue_logical_block_size_entry
= {
561 .attr
= {.name
= "logical_block_size", .mode
= S_IRUGO
},
562 .show
= queue_logical_block_size_show
,
565 static struct queue_sysfs_entry queue_physical_block_size_entry
= {
566 .attr
= {.name
= "physical_block_size", .mode
= S_IRUGO
},
567 .show
= queue_physical_block_size_show
,
570 static struct queue_sysfs_entry queue_chunk_sectors_entry
= {
571 .attr
= {.name
= "chunk_sectors", .mode
= S_IRUGO
},
572 .show
= queue_chunk_sectors_show
,
575 static struct queue_sysfs_entry queue_io_min_entry
= {
576 .attr
= {.name
= "minimum_io_size", .mode
= S_IRUGO
},
577 .show
= queue_io_min_show
,
580 static struct queue_sysfs_entry queue_io_opt_entry
= {
581 .attr
= {.name
= "optimal_io_size", .mode
= S_IRUGO
},
582 .show
= queue_io_opt_show
,
585 static struct queue_sysfs_entry queue_discard_granularity_entry
= {
586 .attr
= {.name
= "discard_granularity", .mode
= S_IRUGO
},
587 .show
= queue_discard_granularity_show
,
590 static struct queue_sysfs_entry queue_discard_max_hw_entry
= {
591 .attr
= {.name
= "discard_max_hw_bytes", .mode
= S_IRUGO
},
592 .show
= queue_discard_max_hw_show
,
595 static struct queue_sysfs_entry queue_discard_max_entry
= {
596 .attr
= {.name
= "discard_max_bytes", .mode
= S_IRUGO
| S_IWUSR
},
597 .show
= queue_discard_max_show
,
598 .store
= queue_discard_max_store
,
601 static struct queue_sysfs_entry queue_discard_zeroes_data_entry
= {
602 .attr
= {.name
= "discard_zeroes_data", .mode
= S_IRUGO
},
603 .show
= queue_discard_zeroes_data_show
,
606 static struct queue_sysfs_entry queue_write_same_max_entry
= {
607 .attr
= {.name
= "write_same_max_bytes", .mode
= S_IRUGO
},
608 .show
= queue_write_same_max_show
,
611 static struct queue_sysfs_entry queue_write_zeroes_max_entry
= {
612 .attr
= {.name
= "write_zeroes_max_bytes", .mode
= S_IRUGO
},
613 .show
= queue_write_zeroes_max_show
,
616 static struct queue_sysfs_entry queue_nonrot_entry
= {
617 .attr
= {.name
= "rotational", .mode
= S_IRUGO
| S_IWUSR
},
618 .show
= queue_show_nonrot
,
619 .store
= queue_store_nonrot
,
622 static struct queue_sysfs_entry queue_zoned_entry
= {
623 .attr
= {.name
= "zoned", .mode
= S_IRUGO
},
624 .show
= queue_zoned_show
,
627 static struct queue_sysfs_entry queue_nomerges_entry
= {
628 .attr
= {.name
= "nomerges", .mode
= S_IRUGO
| S_IWUSR
},
629 .show
= queue_nomerges_show
,
630 .store
= queue_nomerges_store
,
633 static struct queue_sysfs_entry queue_rq_affinity_entry
= {
634 .attr
= {.name
= "rq_affinity", .mode
= S_IRUGO
| S_IWUSR
},
635 .show
= queue_rq_affinity_show
,
636 .store
= queue_rq_affinity_store
,
639 static struct queue_sysfs_entry queue_iostats_entry
= {
640 .attr
= {.name
= "iostats", .mode
= S_IRUGO
| S_IWUSR
},
641 .show
= queue_show_iostats
,
642 .store
= queue_store_iostats
,
645 static struct queue_sysfs_entry queue_random_entry
= {
646 .attr
= {.name
= "add_random", .mode
= S_IRUGO
| S_IWUSR
},
647 .show
= queue_show_random
,
648 .store
= queue_store_random
,
651 static struct queue_sysfs_entry queue_poll_entry
= {
652 .attr
= {.name
= "io_poll", .mode
= S_IRUGO
| S_IWUSR
},
653 .show
= queue_poll_show
,
654 .store
= queue_poll_store
,
657 static struct queue_sysfs_entry queue_poll_delay_entry
= {
658 .attr
= {.name
= "io_poll_delay", .mode
= S_IRUGO
| S_IWUSR
},
659 .show
= queue_poll_delay_show
,
660 .store
= queue_poll_delay_store
,
663 static struct queue_sysfs_entry queue_wc_entry
= {
664 .attr
= {.name
= "write_cache", .mode
= S_IRUGO
| S_IWUSR
},
665 .show
= queue_wc_show
,
666 .store
= queue_wc_store
,
669 static struct queue_sysfs_entry queue_dax_entry
= {
670 .attr
= {.name
= "dax", .mode
= S_IRUGO
},
671 .show
= queue_dax_show
,
674 static struct queue_sysfs_entry queue_wb_lat_entry
= {
675 .attr
= {.name
= "wbt_lat_usec", .mode
= S_IRUGO
| S_IWUSR
},
676 .show
= queue_wb_lat_show
,
677 .store
= queue_wb_lat_store
,
680 #ifdef CONFIG_BLK_DEV_THROTTLING_LOW
681 static struct queue_sysfs_entry throtl_sample_time_entry
= {
682 .attr
= {.name
= "throttle_sample_time", .mode
= S_IRUGO
| S_IWUSR
},
683 .show
= blk_throtl_sample_time_show
,
684 .store
= blk_throtl_sample_time_store
,
688 static struct attribute
*default_attrs
[] = {
689 &queue_requests_entry
.attr
,
690 &queue_ra_entry
.attr
,
691 &queue_max_hw_sectors_entry
.attr
,
692 &queue_max_sectors_entry
.attr
,
693 &queue_max_segments_entry
.attr
,
694 &queue_max_discard_segments_entry
.attr
,
695 &queue_max_integrity_segments_entry
.attr
,
696 &queue_max_segment_size_entry
.attr
,
697 &queue_iosched_entry
.attr
,
698 &queue_hw_sector_size_entry
.attr
,
699 &queue_logical_block_size_entry
.attr
,
700 &queue_physical_block_size_entry
.attr
,
701 &queue_chunk_sectors_entry
.attr
,
702 &queue_io_min_entry
.attr
,
703 &queue_io_opt_entry
.attr
,
704 &queue_discard_granularity_entry
.attr
,
705 &queue_discard_max_entry
.attr
,
706 &queue_discard_max_hw_entry
.attr
,
707 &queue_discard_zeroes_data_entry
.attr
,
708 &queue_write_same_max_entry
.attr
,
709 &queue_write_zeroes_max_entry
.attr
,
710 &queue_nonrot_entry
.attr
,
711 &queue_zoned_entry
.attr
,
712 &queue_nomerges_entry
.attr
,
713 &queue_rq_affinity_entry
.attr
,
714 &queue_iostats_entry
.attr
,
715 &queue_random_entry
.attr
,
716 &queue_poll_entry
.attr
,
717 &queue_wc_entry
.attr
,
718 &queue_dax_entry
.attr
,
719 &queue_wb_lat_entry
.attr
,
720 &queue_poll_delay_entry
.attr
,
721 #ifdef CONFIG_BLK_DEV_THROTTLING_LOW
722 &throtl_sample_time_entry
.attr
,
727 #define to_queue(atr) container_of((atr), struct queue_sysfs_entry, attr)
730 queue_attr_show(struct kobject
*kobj
, struct attribute
*attr
, char *page
)
732 struct queue_sysfs_entry
*entry
= to_queue(attr
);
733 struct request_queue
*q
=
734 container_of(kobj
, struct request_queue
, kobj
);
739 mutex_lock(&q
->sysfs_lock
);
740 if (blk_queue_dying(q
)) {
741 mutex_unlock(&q
->sysfs_lock
);
744 res
= entry
->show(q
, page
);
745 mutex_unlock(&q
->sysfs_lock
);
750 queue_attr_store(struct kobject
*kobj
, struct attribute
*attr
,
751 const char *page
, size_t length
)
753 struct queue_sysfs_entry
*entry
= to_queue(attr
);
754 struct request_queue
*q
;
760 q
= container_of(kobj
, struct request_queue
, kobj
);
761 mutex_lock(&q
->sysfs_lock
);
762 if (blk_queue_dying(q
)) {
763 mutex_unlock(&q
->sysfs_lock
);
766 res
= entry
->store(q
, page
, length
);
767 mutex_unlock(&q
->sysfs_lock
);
771 static void blk_free_queue_rcu(struct rcu_head
*rcu_head
)
773 struct request_queue
*q
= container_of(rcu_head
, struct request_queue
,
775 kmem_cache_free(blk_requestq_cachep
, q
);
779 * blk_release_queue: - release a &struct request_queue when it is no longer needed
780 * @kobj: the kobj belonging to the request queue to be released
783 * blk_release_queue is the pair to blk_init_queue() or
784 * blk_queue_make_request(). It should be called when a request queue is
785 * being released; typically when a block device is being de-registered.
786 * Currently, its primary task it to free all the &struct request
787 * structures that were allocated to the queue and the queue itself.
790 * The low level driver must have finished any outstanding requests first
791 * via blk_cleanup_queue().
793 static void blk_release_queue(struct kobject
*kobj
)
795 struct request_queue
*q
=
796 container_of(kobj
, struct request_queue
, kobj
);
798 if (test_bit(QUEUE_FLAG_POLL_STATS
, &q
->queue_flags
))
799 blk_stat_remove_callback(q
, q
->poll_cb
);
800 blk_stat_free_callback(q
->poll_cb
);
801 bdi_put(q
->backing_dev_info
);
806 elevator_exit(q
, q
->elevator
);
809 blk_free_queue_stats(q
->stats
);
811 blk_exit_rl(&q
->root_rl
);
814 __blk_queue_free_tags(q
);
818 q
->exit_rq_fn(q
, q
->fq
->flush_rq
);
819 blk_free_flush_queue(q
->fq
);
824 blk_trace_shutdown(q
);
827 blk_mq_debugfs_unregister(q
);
830 bioset_free(q
->bio_split
);
832 ida_simple_remove(&blk_queue_ida
, q
->id
);
833 call_rcu(&q
->rcu_head
, blk_free_queue_rcu
);
836 static const struct sysfs_ops queue_sysfs_ops
= {
837 .show
= queue_attr_show
,
838 .store
= queue_attr_store
,
841 struct kobj_type blk_queue_ktype
= {
842 .sysfs_ops
= &queue_sysfs_ops
,
843 .default_attrs
= default_attrs
,
844 .release
= blk_release_queue
,
847 int blk_register_queue(struct gendisk
*disk
)
850 struct device
*dev
= disk_to_dev(disk
);
851 struct request_queue
*q
= disk
->queue
;
856 WARN_ONCE(test_bit(QUEUE_FLAG_REGISTERED
, &q
->queue_flags
),
857 "%s is registering an already registered queue\n",
858 kobject_name(&dev
->kobj
));
859 queue_flag_set_unlocked(QUEUE_FLAG_REGISTERED
, q
);
862 * SCSI probing may synchronously create and destroy a lot of
863 * request_queues for non-existent devices. Shutting down a fully
864 * functional queue takes measureable wallclock time as RCU grace
865 * periods are involved. To avoid excessive latency in these
866 * cases, a request_queue starts out in a degraded mode which is
867 * faster to shut down and is made fully functional here as
868 * request_queues for non-existent devices never get registered.
870 if (!blk_queue_init_done(q
)) {
871 queue_flag_set_unlocked(QUEUE_FLAG_INIT_DONE
, q
);
872 percpu_ref_switch_to_percpu(&q
->q_usage_counter
);
873 blk_queue_bypass_end(q
);
876 ret
= blk_trace_init_sysfs(dev
);
880 /* Prevent changes through sysfs until registration is completed. */
881 mutex_lock(&q
->sysfs_lock
);
883 ret
= kobject_add(&q
->kobj
, kobject_get(&dev
->kobj
), "%s", "queue");
885 blk_trace_remove_sysfs(dev
);
890 __blk_mq_register_dev(dev
, q
);
892 kobject_uevent(&q
->kobj
, KOBJ_ADD
);
894 wbt_enable_default(q
);
896 blk_throtl_register_queue(q
);
898 if (q
->request_fn
|| (q
->mq_ops
&& q
->elevator
)) {
899 ret
= elv_register_queue(q
);
901 kobject_uevent(&q
->kobj
, KOBJ_REMOVE
);
902 kobject_del(&q
->kobj
);
903 blk_trace_remove_sysfs(dev
);
904 kobject_put(&dev
->kobj
);
910 mutex_unlock(&q
->sysfs_lock
);
914 void blk_unregister_queue(struct gendisk
*disk
)
916 struct request_queue
*q
= disk
->queue
;
921 queue_flag_clear_unlocked(QUEUE_FLAG_REGISTERED
, q
);
927 blk_mq_unregister_dev(disk_to_dev(disk
), q
);
929 if (q
->request_fn
|| (q
->mq_ops
&& q
->elevator
))
930 elv_unregister_queue(q
);
932 kobject_uevent(&q
->kobj
, KOBJ_REMOVE
);
933 kobject_del(&q
->kobj
);
934 blk_trace_remove_sysfs(disk_to_dev(disk
));
935 kobject_put(&disk_to_dev(disk
)->kobj
);