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(u64
*var
, const char *page
)
50 err
= kstrtou64(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_integrity_segments_show(struct request_queue
*q
, char *page
)
126 return queue_var_show(q
->limits
.max_integrity_segments
, (page
));
129 static ssize_t
queue_max_segment_size_show(struct request_queue
*q
, char *page
)
131 if (blk_queue_cluster(q
))
132 return queue_var_show(queue_max_segment_size(q
), (page
));
134 return queue_var_show(PAGE_SIZE
, (page
));
137 static ssize_t
queue_logical_block_size_show(struct request_queue
*q
, char *page
)
139 return queue_var_show(queue_logical_block_size(q
), page
);
142 static ssize_t
queue_physical_block_size_show(struct request_queue
*q
, char *page
)
144 return queue_var_show(queue_physical_block_size(q
), page
);
147 static ssize_t
queue_chunk_sectors_show(struct request_queue
*q
, char *page
)
149 return queue_var_show(q
->limits
.chunk_sectors
, page
);
152 static ssize_t
queue_io_min_show(struct request_queue
*q
, char *page
)
154 return queue_var_show(queue_io_min(q
), page
);
157 static ssize_t
queue_io_opt_show(struct request_queue
*q
, char *page
)
159 return queue_var_show(queue_io_opt(q
), page
);
162 static ssize_t
queue_discard_granularity_show(struct request_queue
*q
, char *page
)
164 return queue_var_show(q
->limits
.discard_granularity
, page
);
167 static ssize_t
queue_discard_max_hw_show(struct request_queue
*q
, char *page
)
170 return sprintf(page
, "%llu\n",
171 (unsigned long long)q
->limits
.max_hw_discard_sectors
<< 9);
174 static ssize_t
queue_discard_max_show(struct request_queue
*q
, char *page
)
176 return sprintf(page
, "%llu\n",
177 (unsigned long long)q
->limits
.max_discard_sectors
<< 9);
180 static ssize_t
queue_discard_max_store(struct request_queue
*q
,
181 const char *page
, size_t count
)
183 unsigned long max_discard
;
184 ssize_t ret
= queue_var_store(&max_discard
, page
, count
);
189 if (max_discard
& (q
->limits
.discard_granularity
- 1))
193 if (max_discard
> UINT_MAX
)
196 if (max_discard
> q
->limits
.max_hw_discard_sectors
)
197 max_discard
= q
->limits
.max_hw_discard_sectors
;
199 q
->limits
.max_discard_sectors
= max_discard
;
203 static ssize_t
queue_discard_zeroes_data_show(struct request_queue
*q
, char *page
)
205 return queue_var_show(queue_discard_zeroes_data(q
), page
);
208 static ssize_t
queue_write_same_max_show(struct request_queue
*q
, char *page
)
210 return sprintf(page
, "%llu\n",
211 (unsigned long long)q
->limits
.max_write_same_sectors
<< 9);
216 queue_max_sectors_store(struct request_queue
*q
, const char *page
, size_t count
)
218 unsigned long max_sectors_kb
,
219 max_hw_sectors_kb
= queue_max_hw_sectors(q
) >> 1,
220 page_kb
= 1 << (PAGE_SHIFT
- 10);
221 ssize_t ret
= queue_var_store(&max_sectors_kb
, page
, count
);
226 max_hw_sectors_kb
= min_not_zero(max_hw_sectors_kb
, (unsigned long)
227 q
->limits
.max_dev_sectors
>> 1);
229 if (max_sectors_kb
> max_hw_sectors_kb
|| max_sectors_kb
< page_kb
)
232 spin_lock_irq(q
->queue_lock
);
233 q
->limits
.max_sectors
= max_sectors_kb
<< 1;
234 spin_unlock_irq(q
->queue_lock
);
239 static ssize_t
queue_max_hw_sectors_show(struct request_queue
*q
, char *page
)
241 int max_hw_sectors_kb
= queue_max_hw_sectors(q
) >> 1;
243 return queue_var_show(max_hw_sectors_kb
, (page
));
246 #define QUEUE_SYSFS_BIT_FNS(name, flag, neg) \
248 queue_show_##name(struct request_queue *q, char *page) \
251 bit = test_bit(QUEUE_FLAG_##flag, &q->queue_flags); \
252 return queue_var_show(neg ? !bit : bit, page); \
255 queue_store_##name(struct request_queue *q, const char *page, size_t count) \
259 ret = queue_var_store(&val, page, count); \
265 spin_lock_irq(q->queue_lock); \
267 queue_flag_set(QUEUE_FLAG_##flag, q); \
269 queue_flag_clear(QUEUE_FLAG_##flag, q); \
270 spin_unlock_irq(q->queue_lock); \
274 QUEUE_SYSFS_BIT_FNS(nonrot
, NONROT
, 1);
275 QUEUE_SYSFS_BIT_FNS(random
, ADD_RANDOM
, 0);
276 QUEUE_SYSFS_BIT_FNS(iostats
, IO_STAT
, 0);
277 #undef QUEUE_SYSFS_BIT_FNS
279 static ssize_t
queue_zoned_show(struct request_queue
*q
, char *page
)
281 switch (blk_queue_zoned_model(q
)) {
283 return sprintf(page
, "host-aware\n");
285 return sprintf(page
, "host-managed\n");
287 return sprintf(page
, "none\n");
291 static ssize_t
queue_nomerges_show(struct request_queue
*q
, char *page
)
293 return queue_var_show((blk_queue_nomerges(q
) << 1) |
294 blk_queue_noxmerges(q
), page
);
297 static ssize_t
queue_nomerges_store(struct request_queue
*q
, const char *page
,
301 ssize_t ret
= queue_var_store(&nm
, page
, count
);
306 spin_lock_irq(q
->queue_lock
);
307 queue_flag_clear(QUEUE_FLAG_NOMERGES
, q
);
308 queue_flag_clear(QUEUE_FLAG_NOXMERGES
, q
);
310 queue_flag_set(QUEUE_FLAG_NOMERGES
, q
);
312 queue_flag_set(QUEUE_FLAG_NOXMERGES
, q
);
313 spin_unlock_irq(q
->queue_lock
);
318 static ssize_t
queue_rq_affinity_show(struct request_queue
*q
, char *page
)
320 bool set
= test_bit(QUEUE_FLAG_SAME_COMP
, &q
->queue_flags
);
321 bool force
= test_bit(QUEUE_FLAG_SAME_FORCE
, &q
->queue_flags
);
323 return queue_var_show(set
<< force
, page
);
327 queue_rq_affinity_store(struct request_queue
*q
, const char *page
, size_t count
)
329 ssize_t ret
= -EINVAL
;
333 ret
= queue_var_store(&val
, page
, count
);
337 spin_lock_irq(q
->queue_lock
);
339 queue_flag_set(QUEUE_FLAG_SAME_COMP
, q
);
340 queue_flag_set(QUEUE_FLAG_SAME_FORCE
, q
);
341 } else if (val
== 1) {
342 queue_flag_set(QUEUE_FLAG_SAME_COMP
, q
);
343 queue_flag_clear(QUEUE_FLAG_SAME_FORCE
, q
);
344 } else if (val
== 0) {
345 queue_flag_clear(QUEUE_FLAG_SAME_COMP
, q
);
346 queue_flag_clear(QUEUE_FLAG_SAME_FORCE
, q
);
348 spin_unlock_irq(q
->queue_lock
);
353 static ssize_t
queue_poll_show(struct request_queue
*q
, char *page
)
355 return queue_var_show(test_bit(QUEUE_FLAG_POLL
, &q
->queue_flags
), page
);
358 static ssize_t
queue_poll_store(struct request_queue
*q
, const char *page
,
361 unsigned long poll_on
;
364 if (!q
->mq_ops
|| !q
->mq_ops
->poll
)
367 ret
= queue_var_store(&poll_on
, page
, count
);
371 spin_lock_irq(q
->queue_lock
);
373 queue_flag_set(QUEUE_FLAG_POLL
, q
);
375 queue_flag_clear(QUEUE_FLAG_POLL
, q
);
376 spin_unlock_irq(q
->queue_lock
);
381 static ssize_t
queue_wb_lat_show(struct request_queue
*q
, char *page
)
386 return sprintf(page
, "%llu\n", div_u64(q
->rq_wb
->min_lat_nsec
, 1000));
389 static ssize_t
queue_wb_lat_store(struct request_queue
*q
, const char *page
,
398 ret
= queue_var_store64(&val
, page
);
402 q
->rq_wb
->min_lat_nsec
= val
* 1000ULL;
403 wbt_update_limits(q
->rq_wb
);
407 static ssize_t
queue_wc_show(struct request_queue
*q
, char *page
)
409 if (test_bit(QUEUE_FLAG_WC
, &q
->queue_flags
))
410 return sprintf(page
, "write back\n");
412 return sprintf(page
, "write through\n");
415 static ssize_t
queue_wc_store(struct request_queue
*q
, const char *page
,
420 if (!strncmp(page
, "write back", 10))
422 else if (!strncmp(page
, "write through", 13) ||
423 !strncmp(page
, "none", 4))
429 spin_lock_irq(q
->queue_lock
);
431 queue_flag_set(QUEUE_FLAG_WC
, q
);
433 queue_flag_clear(QUEUE_FLAG_WC
, q
);
434 spin_unlock_irq(q
->queue_lock
);
439 static ssize_t
queue_dax_show(struct request_queue
*q
, char *page
)
441 return queue_var_show(blk_queue_dax(q
), page
);
444 static ssize_t
print_stat(char *page
, struct blk_rq_stat
*stat
, const char *pre
)
446 return sprintf(page
, "%s samples=%llu, mean=%lld, min=%lld, max=%lld\n",
447 pre
, (long long) stat
->nr_samples
,
448 (long long) stat
->mean
, (long long) stat
->min
,
449 (long long) stat
->max
);
452 static ssize_t
queue_stats_show(struct request_queue
*q
, char *page
)
454 struct blk_rq_stat stat
[2];
457 blk_queue_stat_get(q
, stat
);
459 ret
= print_stat(page
, &stat
[BLK_STAT_READ
], "read :");
460 ret
+= print_stat(page
+ ret
, &stat
[BLK_STAT_WRITE
], "write:");
464 static struct queue_sysfs_entry queue_requests_entry
= {
465 .attr
= {.name
= "nr_requests", .mode
= S_IRUGO
| S_IWUSR
},
466 .show
= queue_requests_show
,
467 .store
= queue_requests_store
,
470 static struct queue_sysfs_entry queue_ra_entry
= {
471 .attr
= {.name
= "read_ahead_kb", .mode
= S_IRUGO
| S_IWUSR
},
472 .show
= queue_ra_show
,
473 .store
= queue_ra_store
,
476 static struct queue_sysfs_entry queue_max_sectors_entry
= {
477 .attr
= {.name
= "max_sectors_kb", .mode
= S_IRUGO
| S_IWUSR
},
478 .show
= queue_max_sectors_show
,
479 .store
= queue_max_sectors_store
,
482 static struct queue_sysfs_entry queue_max_hw_sectors_entry
= {
483 .attr
= {.name
= "max_hw_sectors_kb", .mode
= S_IRUGO
},
484 .show
= queue_max_hw_sectors_show
,
487 static struct queue_sysfs_entry queue_max_segments_entry
= {
488 .attr
= {.name
= "max_segments", .mode
= S_IRUGO
},
489 .show
= queue_max_segments_show
,
492 static struct queue_sysfs_entry queue_max_integrity_segments_entry
= {
493 .attr
= {.name
= "max_integrity_segments", .mode
= S_IRUGO
},
494 .show
= queue_max_integrity_segments_show
,
497 static struct queue_sysfs_entry queue_max_segment_size_entry
= {
498 .attr
= {.name
= "max_segment_size", .mode
= S_IRUGO
},
499 .show
= queue_max_segment_size_show
,
502 static struct queue_sysfs_entry queue_iosched_entry
= {
503 .attr
= {.name
= "scheduler", .mode
= S_IRUGO
| S_IWUSR
},
504 .show
= elv_iosched_show
,
505 .store
= elv_iosched_store
,
508 static struct queue_sysfs_entry queue_hw_sector_size_entry
= {
509 .attr
= {.name
= "hw_sector_size", .mode
= S_IRUGO
},
510 .show
= queue_logical_block_size_show
,
513 static struct queue_sysfs_entry queue_logical_block_size_entry
= {
514 .attr
= {.name
= "logical_block_size", .mode
= S_IRUGO
},
515 .show
= queue_logical_block_size_show
,
518 static struct queue_sysfs_entry queue_physical_block_size_entry
= {
519 .attr
= {.name
= "physical_block_size", .mode
= S_IRUGO
},
520 .show
= queue_physical_block_size_show
,
523 static struct queue_sysfs_entry queue_chunk_sectors_entry
= {
524 .attr
= {.name
= "chunk_sectors", .mode
= S_IRUGO
},
525 .show
= queue_chunk_sectors_show
,
528 static struct queue_sysfs_entry queue_io_min_entry
= {
529 .attr
= {.name
= "minimum_io_size", .mode
= S_IRUGO
},
530 .show
= queue_io_min_show
,
533 static struct queue_sysfs_entry queue_io_opt_entry
= {
534 .attr
= {.name
= "optimal_io_size", .mode
= S_IRUGO
},
535 .show
= queue_io_opt_show
,
538 static struct queue_sysfs_entry queue_discard_granularity_entry
= {
539 .attr
= {.name
= "discard_granularity", .mode
= S_IRUGO
},
540 .show
= queue_discard_granularity_show
,
543 static struct queue_sysfs_entry queue_discard_max_hw_entry
= {
544 .attr
= {.name
= "discard_max_hw_bytes", .mode
= S_IRUGO
},
545 .show
= queue_discard_max_hw_show
,
548 static struct queue_sysfs_entry queue_discard_max_entry
= {
549 .attr
= {.name
= "discard_max_bytes", .mode
= S_IRUGO
| S_IWUSR
},
550 .show
= queue_discard_max_show
,
551 .store
= queue_discard_max_store
,
554 static struct queue_sysfs_entry queue_discard_zeroes_data_entry
= {
555 .attr
= {.name
= "discard_zeroes_data", .mode
= S_IRUGO
},
556 .show
= queue_discard_zeroes_data_show
,
559 static struct queue_sysfs_entry queue_write_same_max_entry
= {
560 .attr
= {.name
= "write_same_max_bytes", .mode
= S_IRUGO
},
561 .show
= queue_write_same_max_show
,
564 static struct queue_sysfs_entry queue_nonrot_entry
= {
565 .attr
= {.name
= "rotational", .mode
= S_IRUGO
| S_IWUSR
},
566 .show
= queue_show_nonrot
,
567 .store
= queue_store_nonrot
,
570 static struct queue_sysfs_entry queue_zoned_entry
= {
571 .attr
= {.name
= "zoned", .mode
= S_IRUGO
},
572 .show
= queue_zoned_show
,
575 static struct queue_sysfs_entry queue_nomerges_entry
= {
576 .attr
= {.name
= "nomerges", .mode
= S_IRUGO
| S_IWUSR
},
577 .show
= queue_nomerges_show
,
578 .store
= queue_nomerges_store
,
581 static struct queue_sysfs_entry queue_rq_affinity_entry
= {
582 .attr
= {.name
= "rq_affinity", .mode
= S_IRUGO
| S_IWUSR
},
583 .show
= queue_rq_affinity_show
,
584 .store
= queue_rq_affinity_store
,
587 static struct queue_sysfs_entry queue_iostats_entry
= {
588 .attr
= {.name
= "iostats", .mode
= S_IRUGO
| S_IWUSR
},
589 .show
= queue_show_iostats
,
590 .store
= queue_store_iostats
,
593 static struct queue_sysfs_entry queue_random_entry
= {
594 .attr
= {.name
= "add_random", .mode
= S_IRUGO
| S_IWUSR
},
595 .show
= queue_show_random
,
596 .store
= queue_store_random
,
599 static struct queue_sysfs_entry queue_poll_entry
= {
600 .attr
= {.name
= "io_poll", .mode
= S_IRUGO
| S_IWUSR
},
601 .show
= queue_poll_show
,
602 .store
= queue_poll_store
,
605 static struct queue_sysfs_entry queue_wc_entry
= {
606 .attr
= {.name
= "write_cache", .mode
= S_IRUGO
| S_IWUSR
},
607 .show
= queue_wc_show
,
608 .store
= queue_wc_store
,
611 static struct queue_sysfs_entry queue_dax_entry
= {
612 .attr
= {.name
= "dax", .mode
= S_IRUGO
},
613 .show
= queue_dax_show
,
616 static struct queue_sysfs_entry queue_stats_entry
= {
617 .attr
= {.name
= "stats", .mode
= S_IRUGO
},
618 .show
= queue_stats_show
,
621 static struct queue_sysfs_entry queue_wb_lat_entry
= {
622 .attr
= {.name
= "wbt_lat_usec", .mode
= S_IRUGO
| S_IWUSR
},
623 .show
= queue_wb_lat_show
,
624 .store
= queue_wb_lat_store
,
627 static struct attribute
*default_attrs
[] = {
628 &queue_requests_entry
.attr
,
629 &queue_ra_entry
.attr
,
630 &queue_max_hw_sectors_entry
.attr
,
631 &queue_max_sectors_entry
.attr
,
632 &queue_max_segments_entry
.attr
,
633 &queue_max_integrity_segments_entry
.attr
,
634 &queue_max_segment_size_entry
.attr
,
635 &queue_iosched_entry
.attr
,
636 &queue_hw_sector_size_entry
.attr
,
637 &queue_logical_block_size_entry
.attr
,
638 &queue_physical_block_size_entry
.attr
,
639 &queue_chunk_sectors_entry
.attr
,
640 &queue_io_min_entry
.attr
,
641 &queue_io_opt_entry
.attr
,
642 &queue_discard_granularity_entry
.attr
,
643 &queue_discard_max_entry
.attr
,
644 &queue_discard_max_hw_entry
.attr
,
645 &queue_discard_zeroes_data_entry
.attr
,
646 &queue_write_same_max_entry
.attr
,
647 &queue_nonrot_entry
.attr
,
648 &queue_zoned_entry
.attr
,
649 &queue_nomerges_entry
.attr
,
650 &queue_rq_affinity_entry
.attr
,
651 &queue_iostats_entry
.attr
,
652 &queue_random_entry
.attr
,
653 &queue_poll_entry
.attr
,
654 &queue_wc_entry
.attr
,
655 &queue_dax_entry
.attr
,
656 &queue_stats_entry
.attr
,
657 &queue_wb_lat_entry
.attr
,
661 #define to_queue(atr) container_of((atr), struct queue_sysfs_entry, attr)
664 queue_attr_show(struct kobject
*kobj
, struct attribute
*attr
, char *page
)
666 struct queue_sysfs_entry
*entry
= to_queue(attr
);
667 struct request_queue
*q
=
668 container_of(kobj
, struct request_queue
, kobj
);
673 mutex_lock(&q
->sysfs_lock
);
674 if (blk_queue_dying(q
)) {
675 mutex_unlock(&q
->sysfs_lock
);
678 res
= entry
->show(q
, page
);
679 mutex_unlock(&q
->sysfs_lock
);
684 queue_attr_store(struct kobject
*kobj
, struct attribute
*attr
,
685 const char *page
, size_t length
)
687 struct queue_sysfs_entry
*entry
= to_queue(attr
);
688 struct request_queue
*q
;
694 q
= container_of(kobj
, struct request_queue
, kobj
);
695 mutex_lock(&q
->sysfs_lock
);
696 if (blk_queue_dying(q
)) {
697 mutex_unlock(&q
->sysfs_lock
);
700 res
= entry
->store(q
, page
, length
);
701 mutex_unlock(&q
->sysfs_lock
);
705 static void blk_free_queue_rcu(struct rcu_head
*rcu_head
)
707 struct request_queue
*q
= container_of(rcu_head
, struct request_queue
,
709 kmem_cache_free(blk_requestq_cachep
, q
);
713 * blk_release_queue: - release a &struct request_queue when it is no longer needed
714 * @kobj: the kobj belonging to the request queue to be released
717 * blk_release_queue is the pair to blk_init_queue() or
718 * blk_queue_make_request(). It should be called when a request queue is
719 * being released; typically when a block device is being de-registered.
720 * Currently, its primary task it to free all the &struct request
721 * structures that were allocated to the queue and the queue itself.
724 * The low level driver must have finished any outstanding requests first
725 * via blk_cleanup_queue().
727 static void blk_release_queue(struct kobject
*kobj
)
729 struct request_queue
*q
=
730 container_of(kobj
, struct request_queue
, kobj
);
733 bdi_exit(&q
->backing_dev_info
);
737 spin_lock_irq(q
->queue_lock
);
739 spin_unlock_irq(q
->queue_lock
);
740 elevator_exit(q
->elevator
);
743 blk_exit_rl(&q
->root_rl
);
746 __blk_queue_free_tags(q
);
749 blk_free_flush_queue(q
->fq
);
753 blk_trace_shutdown(q
);
756 bioset_free(q
->bio_split
);
758 ida_simple_remove(&blk_queue_ida
, q
->id
);
759 call_rcu(&q
->rcu_head
, blk_free_queue_rcu
);
762 static const struct sysfs_ops queue_sysfs_ops
= {
763 .show
= queue_attr_show
,
764 .store
= queue_attr_store
,
767 struct kobj_type blk_queue_ktype
= {
768 .sysfs_ops
= &queue_sysfs_ops
,
769 .default_attrs
= default_attrs
,
770 .release
= blk_release_queue
,
773 static void blk_wb_init(struct request_queue
*q
)
775 #ifndef CONFIG_BLK_WBT_MQ
779 #ifndef CONFIG_BLK_WBT_SQ
785 * If this fails, we don't get throttling
790 int blk_register_queue(struct gendisk
*disk
)
793 struct device
*dev
= disk_to_dev(disk
);
794 struct request_queue
*q
= disk
->queue
;
800 * SCSI probing may synchronously create and destroy a lot of
801 * request_queues for non-existent devices. Shutting down a fully
802 * functional queue takes measureable wallclock time as RCU grace
803 * periods are involved. To avoid excessive latency in these
804 * cases, a request_queue starts out in a degraded mode which is
805 * faster to shut down and is made fully functional here as
806 * request_queues for non-existent devices never get registered.
808 if (!blk_queue_init_done(q
)) {
809 queue_flag_set_unlocked(QUEUE_FLAG_INIT_DONE
, q
);
810 percpu_ref_switch_to_percpu(&q
->q_usage_counter
);
811 blk_queue_bypass_end(q
);
814 ret
= blk_trace_init_sysfs(dev
);
818 ret
= kobject_add(&q
->kobj
, kobject_get(&dev
->kobj
), "%s", "queue");
820 blk_trace_remove_sysfs(dev
);
824 kobject_uevent(&q
->kobj
, KOBJ_ADD
);
827 blk_mq_register_dev(dev
, q
);
834 ret
= elv_register_queue(q
);
836 kobject_uevent(&q
->kobj
, KOBJ_REMOVE
);
837 kobject_del(&q
->kobj
);
838 blk_trace_remove_sysfs(dev
);
839 kobject_put(&dev
->kobj
);
846 void blk_unregister_queue(struct gendisk
*disk
)
848 struct request_queue
*q
= disk
->queue
;
854 blk_mq_unregister_dev(disk_to_dev(disk
), q
);
857 elv_unregister_queue(q
);
859 kobject_uevent(&q
->kobj
, KOBJ_REMOVE
);
860 kobject_del(&q
->kobj
);
861 blk_trace_remove_sysfs(disk_to_dev(disk
));
862 kobject_put(&disk_to_dev(disk
)->kobj
);