blk-sysfs.c 17.4 KB
Newer Older
1 2 3 4
/*
 * Functions related to sysfs handling
 */
#include <linux/kernel.h>
5
#include <linux/slab.h>
6 7 8
#include <linux/module.h>
#include <linux/bio.h>
#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>
13 14

#include "blk.h"
15
#include "blk-mq.h"
16 17 18 19 20 21 22 23

struct queue_sysfs_entry {
	struct attribute attr;
	ssize_t (*show)(struct request_queue *, char *);
	ssize_t (*store)(struct request_queue *, const char *, size_t);
};

static ssize_t
24
queue_var_show(unsigned long var, char *page)
25
{
26
	return sprintf(page, "%lu\n", var);
27 28 29 30 31
}

static ssize_t
queue_var_store(unsigned long *var, const char *page, size_t count)
{
32 33 34
	int err;
	unsigned long v;

35
	err = kstrtoul(page, 10, &v);
36 37 38 39
	if (err || v > UINT_MAX)
		return -EINVAL;

	*var = v;
40 41 42 43 44 45 46 47 48 49 50 51 52

	return count;
}

static ssize_t queue_requests_show(struct request_queue *q, char *page)
{
	return queue_var_show(q->nr_requests, (page));
}

static ssize_t
queue_requests_store(struct request_queue *q, const char *page, size_t count)
{
	unsigned long nr;
53
	int ret, err;
54

55
	if (!q->request_fn && !q->mq_ops)
56 57 58
		return -EINVAL;

	ret = queue_var_store(&nr, page, count);
59 60 61
	if (ret < 0)
		return ret;

62 63 64
	if (nr < BLKDEV_MIN_RQ)
		nr = BLKDEV_MIN_RQ;

65 66 67 68 69 70 71 72
	if (q->request_fn)
		err = blk_update_nr_requests(q, nr);
	else
		err = blk_mq_update_nr_requests(q, nr);

	if (err)
		return err;

73 74 75 76 77
	return ret;
}

static ssize_t queue_ra_show(struct request_queue *q, char *page)
{
78
	unsigned long ra_kb = q->backing_dev_info.ra_pages <<
79
					(PAGE_SHIFT - 10);
80 81 82 83 84 85 86 87 88 89

	return queue_var_show(ra_kb, (page));
}

static ssize_t
queue_ra_store(struct request_queue *q, const char *page, size_t count)
{
	unsigned long ra_kb;
	ssize_t ret = queue_var_store(&ra_kb, page, count);

90 91 92
	if (ret < 0)
		return ret;

93
	q->backing_dev_info.ra_pages = ra_kb >> (PAGE_SHIFT - 10);
94 95 96 97 98 99

	return ret;
}

static ssize_t queue_max_sectors_show(struct request_queue *q, char *page)
{
100
	int max_sectors_kb = queue_max_sectors(q) >> 1;
101 102 103 104

	return queue_var_show(max_sectors_kb, (page));
}

105 106 107 108 109
static ssize_t queue_max_segments_show(struct request_queue *q, char *page)
{
	return queue_var_show(queue_max_segments(q), (page));
}

110 111 112 113 114
static ssize_t queue_max_integrity_segments_show(struct request_queue *q, char *page)
{
	return queue_var_show(q->limits.max_integrity_segments, (page));
}

115 116
static ssize_t queue_max_segment_size_show(struct request_queue *q, char *page)
{
117
	if (blk_queue_cluster(q))
118 119
		return queue_var_show(queue_max_segment_size(q), (page));

120
	return queue_var_show(PAGE_SIZE, (page));
121 122
}

123
static ssize_t queue_logical_block_size_show(struct request_queue *q, char *page)
124
{
125
	return queue_var_show(queue_logical_block_size(q), page);
126 127
}

128 129 130 131 132 133 134 135 136 137 138 139 140
static ssize_t queue_physical_block_size_show(struct request_queue *q, char *page)
{
	return queue_var_show(queue_physical_block_size(q), page);
}

static ssize_t queue_io_min_show(struct request_queue *q, char *page)
{
	return queue_var_show(queue_io_min(q), page);
}

static ssize_t queue_io_opt_show(struct request_queue *q, char *page)
{
	return queue_var_show(queue_io_opt(q), page);
141 142
}

143 144 145 146 147
static ssize_t queue_discard_granularity_show(struct request_queue *q, char *page)
{
	return queue_var_show(q->limits.discard_granularity, page);
}

148 149 150
static ssize_t queue_discard_max_hw_show(struct request_queue *q, char *page)
{

151 152
	return sprintf(page, "%llu\n",
		(unsigned long long)q->limits.max_hw_discard_sectors << 9);
153 154
}

155 156
static ssize_t queue_discard_max_show(struct request_queue *q, char *page)
{
157 158
	return sprintf(page, "%llu\n",
		       (unsigned long long)q->limits.max_discard_sectors << 9);
159 160
}

161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183
static ssize_t queue_discard_max_store(struct request_queue *q,
				       const char *page, size_t count)
{
	unsigned long max_discard;
	ssize_t ret = queue_var_store(&max_discard, page, count);

	if (ret < 0)
		return ret;

	if (max_discard & (q->limits.discard_granularity - 1))
		return -EINVAL;

	max_discard >>= 9;
	if (max_discard > UINT_MAX)
		return -EINVAL;

	if (max_discard > q->limits.max_hw_discard_sectors)
		max_discard = q->limits.max_hw_discard_sectors;

	q->limits.max_discard_sectors = max_discard;
	return ret;
}

184 185 186 187 188
static ssize_t queue_discard_zeroes_data_show(struct request_queue *q, char *page)
{
	return queue_var_show(queue_discard_zeroes_data(q), page);
}

189 190 191 192 193 194 195
static ssize_t queue_write_same_max_show(struct request_queue *q, char *page)
{
	return sprintf(page, "%llu\n",
		(unsigned long long)q->limits.max_write_same_sectors << 9);
}


196 197 198 199
static ssize_t
queue_max_sectors_store(struct request_queue *q, const char *page, size_t count)
{
	unsigned long max_sectors_kb,
200
		max_hw_sectors_kb = queue_max_hw_sectors(q) >> 1,
201
			page_kb = 1 << (PAGE_SHIFT - 10);
202 203
	ssize_t ret = queue_var_store(&max_sectors_kb, page, count);

204 205 206
	if (ret < 0)
		return ret;

207 208 209
	max_hw_sectors_kb = min_not_zero(max_hw_sectors_kb, (unsigned long)
					 q->limits.max_dev_sectors >> 1);

210 211
	if (max_sectors_kb > max_hw_sectors_kb || max_sectors_kb < page_kb)
		return -EINVAL;
212

213
	spin_lock_irq(q->queue_lock);
214
	q->limits.max_sectors = max_sectors_kb << 1;
215 216 217 218 219 220 221
	spin_unlock_irq(q->queue_lock);

	return ret;
}

static ssize_t queue_max_hw_sectors_show(struct request_queue *q, char *page)
{
222
	int max_hw_sectors_kb = queue_max_hw_sectors(q) >> 1;
223 224 225 226

	return queue_var_show(max_hw_sectors_kb, (page));
}

227 228 229 230 231 232 233 234 235 236 237 238 239 240
#define QUEUE_SYSFS_BIT_FNS(name, flag, neg)				\
static ssize_t								\
queue_show_##name(struct request_queue *q, char *page)			\
{									\
	int bit;							\
	bit = test_bit(QUEUE_FLAG_##flag, &q->queue_flags);		\
	return queue_var_show(neg ? !bit : bit, page);			\
}									\
static ssize_t								\
queue_store_##name(struct request_queue *q, const char *page, size_t count) \
{									\
	unsigned long val;						\
	ssize_t ret;							\
	ret = queue_var_store(&val, page, count);			\
241 242
	if (ret < 0)							\
		 return ret;						\
243 244 245 246 247 248 249 250 251 252
	if (neg)							\
		val = !val;						\
									\
	spin_lock_irq(q->queue_lock);					\
	if (val)							\
		queue_flag_set(QUEUE_FLAG_##flag, q);			\
	else								\
		queue_flag_clear(QUEUE_FLAG_##flag, q);			\
	spin_unlock_irq(q->queue_lock);					\
	return ret;							\
253 254
}

255 256 257 258
QUEUE_SYSFS_BIT_FNS(nonrot, NONROT, 1);
QUEUE_SYSFS_BIT_FNS(random, ADD_RANDOM, 0);
QUEUE_SYSFS_BIT_FNS(iostats, IO_STAT, 0);
#undef QUEUE_SYSFS_BIT_FNS
259

260 261
static ssize_t queue_nomerges_show(struct request_queue *q, char *page)
{
262 263
	return queue_var_show((blk_queue_nomerges(q) << 1) |
			       blk_queue_noxmerges(q), page);
264 265 266 267 268 269 270 271
}

static ssize_t queue_nomerges_store(struct request_queue *q, const char *page,
				    size_t count)
{
	unsigned long nm;
	ssize_t ret = queue_var_store(&nm, page, count);

272 273 274
	if (ret < 0)
		return ret;

275
	spin_lock_irq(q->queue_lock);
276 277 278
	queue_flag_clear(QUEUE_FLAG_NOMERGES, q);
	queue_flag_clear(QUEUE_FLAG_NOXMERGES, q);
	if (nm == 2)
279
		queue_flag_set(QUEUE_FLAG_NOMERGES, q);
280 281
	else if (nm)
		queue_flag_set(QUEUE_FLAG_NOXMERGES, q);
282
	spin_unlock_irq(q->queue_lock);
283

284 285 286
	return ret;
}

287 288
static ssize_t queue_rq_affinity_show(struct request_queue *q, char *page)
{
289
	bool set = test_bit(QUEUE_FLAG_SAME_COMP, &q->queue_flags);
Dan Williams's avatar
Dan Williams committed
290
	bool force = test_bit(QUEUE_FLAG_SAME_FORCE, &q->queue_flags);
291

Dan Williams's avatar
Dan Williams committed
292
	return queue_var_show(set << force, page);
293 294 295 296 297 298
}

static ssize_t
queue_rq_affinity_store(struct request_queue *q, const char *page, size_t count)
{
	ssize_t ret = -EINVAL;
299
#ifdef CONFIG_SMP
300 301 302
	unsigned long val;

	ret = queue_var_store(&val, page, count);
303 304 305
	if (ret < 0)
		return ret;

306
	spin_lock_irq(q->queue_lock);
307
	if (val == 2) {
308
		queue_flag_set(QUEUE_FLAG_SAME_COMP, q);
309 310 311 312 313
		queue_flag_set(QUEUE_FLAG_SAME_FORCE, q);
	} else if (val == 1) {
		queue_flag_set(QUEUE_FLAG_SAME_COMP, q);
		queue_flag_clear(QUEUE_FLAG_SAME_FORCE, q);
	} else if (val == 0) {
Dan Williams's avatar
Dan Williams committed
314 315 316
		queue_flag_clear(QUEUE_FLAG_SAME_COMP, q);
		queue_flag_clear(QUEUE_FLAG_SAME_FORCE, q);
	}
317 318 319 320
	spin_unlock_irq(q->queue_lock);
#endif
	return ret;
}
321

Jens Axboe's avatar
Jens Axboe committed
322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349
static ssize_t queue_poll_show(struct request_queue *q, char *page)
{
	return queue_var_show(test_bit(QUEUE_FLAG_POLL, &q->queue_flags), page);
}

static ssize_t queue_poll_store(struct request_queue *q, const char *page,
				size_t count)
{
	unsigned long poll_on;
	ssize_t ret;

	if (!q->mq_ops || !q->mq_ops->poll)
		return -EINVAL;

	ret = queue_var_store(&poll_on, page, count);
	if (ret < 0)
		return ret;

	spin_lock_irq(q->queue_lock);
	if (poll_on)
		queue_flag_set(QUEUE_FLAG_POLL, q);
	else
		queue_flag_clear(QUEUE_FLAG_POLL, q);
	spin_unlock_irq(q->queue_lock);

	return ret;
}

350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372
static struct queue_sysfs_entry queue_requests_entry = {
	.attr = {.name = "nr_requests", .mode = S_IRUGO | S_IWUSR },
	.show = queue_requests_show,
	.store = queue_requests_store,
};

static struct queue_sysfs_entry queue_ra_entry = {
	.attr = {.name = "read_ahead_kb", .mode = S_IRUGO | S_IWUSR },
	.show = queue_ra_show,
	.store = queue_ra_store,
};

static struct queue_sysfs_entry queue_max_sectors_entry = {
	.attr = {.name = "max_sectors_kb", .mode = S_IRUGO | S_IWUSR },
	.show = queue_max_sectors_show,
	.store = queue_max_sectors_store,
};

static struct queue_sysfs_entry queue_max_hw_sectors_entry = {
	.attr = {.name = "max_hw_sectors_kb", .mode = S_IRUGO },
	.show = queue_max_hw_sectors_show,
};

373 374 375 376 377
static struct queue_sysfs_entry queue_max_segments_entry = {
	.attr = {.name = "max_segments", .mode = S_IRUGO },
	.show = queue_max_segments_show,
};

378 379 380 381 382
static struct queue_sysfs_entry queue_max_integrity_segments_entry = {
	.attr = {.name = "max_integrity_segments", .mode = S_IRUGO },
	.show = queue_max_integrity_segments_show,
};

383 384 385 386 387
static struct queue_sysfs_entry queue_max_segment_size_entry = {
	.attr = {.name = "max_segment_size", .mode = S_IRUGO },
	.show = queue_max_segment_size_show,
};

388 389 390 391 392 393
static struct queue_sysfs_entry queue_iosched_entry = {
	.attr = {.name = "scheduler", .mode = S_IRUGO | S_IWUSR },
	.show = elv_iosched_show,
	.store = elv_iosched_store,
};

394 395
static struct queue_sysfs_entry queue_hw_sector_size_entry = {
	.attr = {.name = "hw_sector_size", .mode = S_IRUGO },
396 397 398 399 400 401
	.show = queue_logical_block_size_show,
};

static struct queue_sysfs_entry queue_logical_block_size_entry = {
	.attr = {.name = "logical_block_size", .mode = S_IRUGO },
	.show = queue_logical_block_size_show,
402 403
};

404 405 406 407 408 409 410 411 412 413 414 415 416
static struct queue_sysfs_entry queue_physical_block_size_entry = {
	.attr = {.name = "physical_block_size", .mode = S_IRUGO },
	.show = queue_physical_block_size_show,
};

static struct queue_sysfs_entry queue_io_min_entry = {
	.attr = {.name = "minimum_io_size", .mode = S_IRUGO },
	.show = queue_io_min_show,
};

static struct queue_sysfs_entry queue_io_opt_entry = {
	.attr = {.name = "optimal_io_size", .mode = S_IRUGO },
	.show = queue_io_opt_show,
417 418
};

419 420 421 422 423
static struct queue_sysfs_entry queue_discard_granularity_entry = {
	.attr = {.name = "discard_granularity", .mode = S_IRUGO },
	.show = queue_discard_granularity_show,
};

424 425 426 427 428
static struct queue_sysfs_entry queue_discard_max_hw_entry = {
	.attr = {.name = "discard_max_hw_bytes", .mode = S_IRUGO },
	.show = queue_discard_max_hw_show,
};

429
static struct queue_sysfs_entry queue_discard_max_entry = {
430
	.attr = {.name = "discard_max_bytes", .mode = S_IRUGO | S_IWUSR },
431
	.show = queue_discard_max_show,
432
	.store = queue_discard_max_store,
433 434
};

435 436 437 438 439
static struct queue_sysfs_entry queue_discard_zeroes_data_entry = {
	.attr = {.name = "discard_zeroes_data", .mode = S_IRUGO },
	.show = queue_discard_zeroes_data_show,
};

440 441 442 443 444
static struct queue_sysfs_entry queue_write_same_max_entry = {
	.attr = {.name = "write_same_max_bytes", .mode = S_IRUGO },
	.show = queue_write_same_max_show,
};

445 446
static struct queue_sysfs_entry queue_nonrot_entry = {
	.attr = {.name = "rotational", .mode = S_IRUGO | S_IWUSR },
447 448
	.show = queue_show_nonrot,
	.store = queue_store_nonrot,
449 450
};

451 452 453 454 455 456
static struct queue_sysfs_entry queue_nomerges_entry = {
	.attr = {.name = "nomerges", .mode = S_IRUGO | S_IWUSR },
	.show = queue_nomerges_show,
	.store = queue_nomerges_store,
};

457 458 459 460 461 462
static struct queue_sysfs_entry queue_rq_affinity_entry = {
	.attr = {.name = "rq_affinity", .mode = S_IRUGO | S_IWUSR },
	.show = queue_rq_affinity_show,
	.store = queue_rq_affinity_store,
};

463 464
static struct queue_sysfs_entry queue_iostats_entry = {
	.attr = {.name = "iostats", .mode = S_IRUGO | S_IWUSR },
465 466
	.show = queue_show_iostats,
	.store = queue_store_iostats,
467 468
};

469 470
static struct queue_sysfs_entry queue_random_entry = {
	.attr = {.name = "add_random", .mode = S_IRUGO | S_IWUSR },
471 472
	.show = queue_show_random,
	.store = queue_store_random,
473 474
};

Jens Axboe's avatar
Jens Axboe committed
475 476 477 478 479 480
static struct queue_sysfs_entry queue_poll_entry = {
	.attr = {.name = "io_poll", .mode = S_IRUGO | S_IWUSR },
	.show = queue_poll_show,
	.store = queue_poll_store,
};

481 482 483 484 485
static struct attribute *default_attrs[] = {
	&queue_requests_entry.attr,
	&queue_ra_entry.attr,
	&queue_max_hw_sectors_entry.attr,
	&queue_max_sectors_entry.attr,
486
	&queue_max_segments_entry.attr,
487
	&queue_max_integrity_segments_entry.attr,
488
	&queue_max_segment_size_entry.attr,
489
	&queue_iosched_entry.attr,
490
	&queue_hw_sector_size_entry.attr,
491
	&queue_logical_block_size_entry.attr,
492 493 494
	&queue_physical_block_size_entry.attr,
	&queue_io_min_entry.attr,
	&queue_io_opt_entry.attr,
495 496
	&queue_discard_granularity_entry.attr,
	&queue_discard_max_entry.attr,
497
	&queue_discard_max_hw_entry.attr,
498
	&queue_discard_zeroes_data_entry.attr,
499
	&queue_write_same_max_entry.attr,
500
	&queue_nonrot_entry.attr,
501
	&queue_nomerges_entry.attr,
502
	&queue_rq_affinity_entry.attr,
503
	&queue_iostats_entry.attr,
504
	&queue_random_entry.attr,
Jens Axboe's avatar
Jens Axboe committed
505
	&queue_poll_entry.attr,
506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521
	NULL,
};

#define to_queue(atr) container_of((atr), struct queue_sysfs_entry, attr)

static ssize_t
queue_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
{
	struct queue_sysfs_entry *entry = to_queue(attr);
	struct request_queue *q =
		container_of(kobj, struct request_queue, kobj);
	ssize_t res;

	if (!entry->show)
		return -EIO;
	mutex_lock(&q->sysfs_lock);
522
	if (blk_queue_dying(q)) {
523 524 525 526 527 528 529 530 531 532 533 534 535
		mutex_unlock(&q->sysfs_lock);
		return -ENOENT;
	}
	res = entry->show(q, page);
	mutex_unlock(&q->sysfs_lock);
	return res;
}

static ssize_t
queue_attr_store(struct kobject *kobj, struct attribute *attr,
		    const char *page, size_t length)
{
	struct queue_sysfs_entry *entry = to_queue(attr);
536
	struct request_queue *q;
537 538 539 540
	ssize_t res;

	if (!entry->store)
		return -EIO;
541 542

	q = container_of(kobj, struct request_queue, kobj);
543
	mutex_lock(&q->sysfs_lock);
544
	if (blk_queue_dying(q)) {
545 546 547 548 549 550 551 552
		mutex_unlock(&q->sysfs_lock);
		return -ENOENT;
	}
	res = entry->store(q, page, length);
	mutex_unlock(&q->sysfs_lock);
	return res;
}

Tejun Heo's avatar
Tejun Heo committed
553 554 555 556 557 558 559
static void blk_free_queue_rcu(struct rcu_head *rcu_head)
{
	struct request_queue *q = container_of(rcu_head, struct request_queue,
					       rcu_head);
	kmem_cache_free(blk_requestq_cachep, q);
}

560
/**
561 562
 * blk_release_queue: - release a &struct request_queue when it is no longer needed
 * @kobj:    the kobj belonging to the request queue to be released
563 564
 *
 * Description:
565
 *     blk_release_queue is the pair to blk_init_queue() or
566 567 568 569 570
 *     blk_queue_make_request().  It should be called when a request queue is
 *     being released; typically when a block device is being de-registered.
 *     Currently, its primary task it to free all the &struct request
 *     structures that were allocated to the queue and the queue itself.
 *
Bart Van Assche's avatar
Bart Van Assche committed
571 572 573
 * Note:
 *     The low level driver must have finished any outstanding requests first
 *     via blk_cleanup_queue().
574 575 576 577 578 579
 **/
static void blk_release_queue(struct kobject *kobj)
{
	struct request_queue *q =
		container_of(kobj, struct request_queue, kobj);

580
	bdi_exit(&q->backing_dev_info);
581 582
	blkcg_exit_queue(q);

583 584 585 586
	if (q->elevator) {
		spin_lock_irq(q->queue_lock);
		ioc_clear_queue(q);
		spin_unlock_irq(q->queue_lock);
587
		elevator_exit(q->elevator);
588
	}
589

590
	blk_exit_rl(&q->root_rl);
591 592 593 594

	if (q->queue_tags)
		__blk_queue_free_tags(q);

Bart Van Assche's avatar
Bart Van Assche committed
595
	if (!q->mq_ops)
596
		blk_free_flush_queue(q->fq);
597 598
	else
		blk_mq_release(q);
599

600 601
	blk_trace_shutdown(q);

602 603 604
	if (q->bio_split)
		bioset_free(q->bio_split);

605
	ida_simple_remove(&blk_queue_ida, q->id);
Tejun Heo's avatar
Tejun Heo committed
606
	call_rcu(&q->rcu_head, blk_free_queue_rcu);
607 608
}

609
static const struct sysfs_ops queue_sysfs_ops = {
610 611 612 613 614 615 616 617 618 619 620 621 622
	.show	= queue_attr_show,
	.store	= queue_attr_store,
};

struct kobj_type blk_queue_ktype = {
	.sysfs_ops	= &queue_sysfs_ops,
	.default_attrs	= default_attrs,
	.release	= blk_release_queue,
};

int blk_register_queue(struct gendisk *disk)
{
	int ret;
623
	struct device *dev = disk_to_dev(disk);
624 625
	struct request_queue *q = disk->queue;

626
	if (WARN_ON(!q))
627 628
		return -ENXIO;

629
	/*
630 631 632 633 634 635 636
	 * SCSI probing may synchronously create and destroy a lot of
	 * request_queues for non-existent devices.  Shutting down a fully
	 * functional queue takes measureable wallclock time as RCU grace
	 * periods are involved.  To avoid excessive latency in these
	 * cases, a request_queue starts out in a degraded mode which is
	 * faster to shut down and is made fully functional here as
	 * request_queues for non-existent devices never get registered.
637
	 */
638 639
	if (!blk_queue_init_done(q)) {
		queue_flag_set_unlocked(QUEUE_FLAG_INIT_DONE, q);
640
		percpu_ref_switch_to_percpu(&q->q_usage_counter);
641 642
		blk_queue_bypass_end(q);
	}
643

644 645 646 647
	ret = blk_trace_init_sysfs(dev);
	if (ret)
		return ret;

648
	ret = kobject_add(&q->kobj, kobject_get(&dev->kobj), "%s", "queue");
649 650
	if (ret < 0) {
		blk_trace_remove_sysfs(dev);
651
		return ret;
652
	}
653 654 655

	kobject_uevent(&q->kobj, KOBJ_ADD);

656 657 658
	if (q->mq_ops)
		blk_mq_register_disk(disk);

659 660 661
	if (!q->request_fn)
		return 0;

662 663 664 665
	ret = elv_register_queue(q);
	if (ret) {
		kobject_uevent(&q->kobj, KOBJ_REMOVE);
		kobject_del(&q->kobj);
666
		blk_trace_remove_sysfs(dev);
667
		kobject_put(&dev->kobj);
668 669 670 671 672 673 674 675 676 677
		return ret;
	}

	return 0;
}

void blk_unregister_queue(struct gendisk *disk)
{
	struct request_queue *q = disk->queue;

678 679 680
	if (WARN_ON(!q))
		return;

681 682 683
	if (q->mq_ops)
		blk_mq_unregister_disk(disk);

684
	if (q->request_fn)
685 686
		elv_unregister_queue(q);

687 688 689 690
	kobject_uevent(&q->kobj, KOBJ_REMOVE);
	kobject_del(&q->kobj);
	blk_trace_remove_sysfs(disk_to_dev(disk));
	kobject_put(&disk_to_dev(disk)->kobj);
691
}