1 /* 2 * Functions related to sysfs handling 3 */ 4 #include <linux/kernel.h> 5 #include <linux/slab.h> 6 #include <linux/module.h> 7 #include <linux/bio.h> 8 #include <linux/blkdev.h> 9 #include <linux/blktrace_api.h> 10 #include <linux/blk-mq.h> 11 12 #include "blk.h" 13 #include "blk-cgroup.h" 14 #include "blk-mq.h" 15 16 struct queue_sysfs_entry { 17 struct attribute attr; 18 ssize_t (*show)(struct request_queue *, char *); 19 ssize_t (*store)(struct request_queue *, const char *, size_t); 20 }; 21 22 static ssize_t 23 queue_var_show(unsigned long var, char *page) 24 { 25 return sprintf(page, "%lu\n", var); 26 } 27 28 static ssize_t 29 queue_var_store(unsigned long *var, const char *page, size_t count) 30 { 31 int err; 32 unsigned long v; 33 34 err = kstrtoul(page, 10, &v); 35 if (err || v > UINT_MAX) 36 return -EINVAL; 37 38 *var = v; 39 40 return count; 41 } 42 43 static ssize_t queue_requests_show(struct request_queue *q, char *page) 44 { 45 return queue_var_show(q->nr_requests, (page)); 46 } 47 48 static ssize_t 49 queue_requests_store(struct request_queue *q, const char *page, size_t count) 50 { 51 struct request_list *rl; 52 unsigned long nr; 53 int ret; 54 55 if (!q->request_fn) 56 return -EINVAL; 57 58 ret = queue_var_store(&nr, page, count); 59 if (ret < 0) 60 return ret; 61 62 if (nr < BLKDEV_MIN_RQ) 63 nr = BLKDEV_MIN_RQ; 64 65 spin_lock_irq(q->queue_lock); 66 q->nr_requests = nr; 67 blk_queue_congestion_threshold(q); 68 69 /* congestion isn't cgroup aware and follows root blkcg for now */ 70 rl = &q->root_rl; 71 72 if (rl->count[BLK_RW_SYNC] >= queue_congestion_on_threshold(q)) 73 blk_set_queue_congested(q, BLK_RW_SYNC); 74 else if (rl->count[BLK_RW_SYNC] < queue_congestion_off_threshold(q)) 75 blk_clear_queue_congested(q, BLK_RW_SYNC); 76 77 if (rl->count[BLK_RW_ASYNC] >= queue_congestion_on_threshold(q)) 78 blk_set_queue_congested(q, BLK_RW_ASYNC); 79 else if (rl->count[BLK_RW_ASYNC] < queue_congestion_off_threshold(q)) 80 blk_clear_queue_congested(q, BLK_RW_ASYNC); 81 82 blk_queue_for_each_rl(rl, q) { 83 if (rl->count[BLK_RW_SYNC] >= q->nr_requests) { 84 blk_set_rl_full(rl, BLK_RW_SYNC); 85 } else { 86 blk_clear_rl_full(rl, BLK_RW_SYNC); 87 wake_up(&rl->wait[BLK_RW_SYNC]); 88 } 89 90 if (rl->count[BLK_RW_ASYNC] >= q->nr_requests) { 91 blk_set_rl_full(rl, BLK_RW_ASYNC); 92 } else { 93 blk_clear_rl_full(rl, BLK_RW_ASYNC); 94 wake_up(&rl->wait[BLK_RW_ASYNC]); 95 } 96 } 97 98 spin_unlock_irq(q->queue_lock); 99 return ret; 100 } 101 102 static ssize_t queue_ra_show(struct request_queue *q, char *page) 103 { 104 unsigned long ra_kb = q->backing_dev_info.ra_pages << 105 (PAGE_CACHE_SHIFT - 10); 106 107 return queue_var_show(ra_kb, (page)); 108 } 109 110 static ssize_t 111 queue_ra_store(struct request_queue *q, const char *page, size_t count) 112 { 113 unsigned long ra_kb; 114 ssize_t ret = queue_var_store(&ra_kb, page, count); 115 116 if (ret < 0) 117 return ret; 118 119 q->backing_dev_info.ra_pages = ra_kb >> (PAGE_CACHE_SHIFT - 10); 120 121 return ret; 122 } 123 124 static ssize_t queue_max_sectors_show(struct request_queue *q, char *page) 125 { 126 int max_sectors_kb = queue_max_sectors(q) >> 1; 127 128 return queue_var_show(max_sectors_kb, (page)); 129 } 130 131 static ssize_t queue_max_segments_show(struct request_queue *q, char *page) 132 { 133 return queue_var_show(queue_max_segments(q), (page)); 134 } 135 136 static ssize_t queue_max_integrity_segments_show(struct request_queue *q, char *page) 137 { 138 return queue_var_show(q->limits.max_integrity_segments, (page)); 139 } 140 141 static ssize_t queue_max_segment_size_show(struct request_queue *q, char *page) 142 { 143 if (blk_queue_cluster(q)) 144 return queue_var_show(queue_max_segment_size(q), (page)); 145 146 return queue_var_show(PAGE_CACHE_SIZE, (page)); 147 } 148 149 static ssize_t queue_logical_block_size_show(struct request_queue *q, char *page) 150 { 151 return queue_var_show(queue_logical_block_size(q), page); 152 } 153 154 static ssize_t queue_physical_block_size_show(struct request_queue *q, char *page) 155 { 156 return queue_var_show(queue_physical_block_size(q), page); 157 } 158 159 static 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 164 static 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 169 static 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 174 static ssize_t queue_discard_max_show(struct request_queue *q, char *page) 175 { 176 return sprintf(page, "%llu\n", 177 (unsigned long long)q->limits.max_discard_sectors << 9); 178 } 179 180 static ssize_t queue_discard_zeroes_data_show(struct request_queue *q, char *page) 181 { 182 return queue_var_show(queue_discard_zeroes_data(q), page); 183 } 184 185 static ssize_t queue_write_same_max_show(struct request_queue *q, char *page) 186 { 187 return sprintf(page, "%llu\n", 188 (unsigned long long)q->limits.max_write_same_sectors << 9); 189 } 190 191 192 static ssize_t 193 queue_max_sectors_store(struct request_queue *q, const char *page, size_t count) 194 { 195 unsigned long max_sectors_kb, 196 max_hw_sectors_kb = queue_max_hw_sectors(q) >> 1, 197 page_kb = 1 << (PAGE_CACHE_SHIFT - 10); 198 ssize_t ret = queue_var_store(&max_sectors_kb, page, count); 199 200 if (ret < 0) 201 return ret; 202 203 if (max_sectors_kb > max_hw_sectors_kb || max_sectors_kb < page_kb) 204 return -EINVAL; 205 206 spin_lock_irq(q->queue_lock); 207 q->limits.max_sectors = max_sectors_kb << 1; 208 spin_unlock_irq(q->queue_lock); 209 210 return ret; 211 } 212 213 static ssize_t queue_max_hw_sectors_show(struct request_queue *q, char *page) 214 { 215 int max_hw_sectors_kb = queue_max_hw_sectors(q) >> 1; 216 217 return queue_var_show(max_hw_sectors_kb, (page)); 218 } 219 220 #define QUEUE_SYSFS_BIT_FNS(name, flag, neg) \ 221 static ssize_t \ 222 queue_show_##name(struct request_queue *q, char *page) \ 223 { \ 224 int bit; \ 225 bit = test_bit(QUEUE_FLAG_##flag, &q->queue_flags); \ 226 return queue_var_show(neg ? !bit : bit, page); \ 227 } \ 228 static ssize_t \ 229 queue_store_##name(struct request_queue *q, const char *page, size_t count) \ 230 { \ 231 unsigned long val; \ 232 ssize_t ret; \ 233 ret = queue_var_store(&val, page, count); \ 234 if (ret < 0) \ 235 return ret; \ 236 if (neg) \ 237 val = !val; \ 238 \ 239 spin_lock_irq(q->queue_lock); \ 240 if (val) \ 241 queue_flag_set(QUEUE_FLAG_##flag, q); \ 242 else \ 243 queue_flag_clear(QUEUE_FLAG_##flag, q); \ 244 spin_unlock_irq(q->queue_lock); \ 245 return ret; \ 246 } 247 248 QUEUE_SYSFS_BIT_FNS(nonrot, NONROT, 1); 249 QUEUE_SYSFS_BIT_FNS(random, ADD_RANDOM, 0); 250 QUEUE_SYSFS_BIT_FNS(iostats, IO_STAT, 0); 251 #undef QUEUE_SYSFS_BIT_FNS 252 253 static ssize_t queue_nomerges_show(struct request_queue *q, char *page) 254 { 255 return queue_var_show((blk_queue_nomerges(q) << 1) | 256 blk_queue_noxmerges(q), page); 257 } 258 259 static ssize_t queue_nomerges_store(struct request_queue *q, const char *page, 260 size_t count) 261 { 262 unsigned long nm; 263 ssize_t ret = queue_var_store(&nm, page, count); 264 265 if (ret < 0) 266 return ret; 267 268 spin_lock_irq(q->queue_lock); 269 queue_flag_clear(QUEUE_FLAG_NOMERGES, q); 270 queue_flag_clear(QUEUE_FLAG_NOXMERGES, q); 271 if (nm == 2) 272 queue_flag_set(QUEUE_FLAG_NOMERGES, q); 273 else if (nm) 274 queue_flag_set(QUEUE_FLAG_NOXMERGES, q); 275 spin_unlock_irq(q->queue_lock); 276 277 return ret; 278 } 279 280 static ssize_t queue_rq_affinity_show(struct request_queue *q, char *page) 281 { 282 bool set = test_bit(QUEUE_FLAG_SAME_COMP, &q->queue_flags); 283 bool force = test_bit(QUEUE_FLAG_SAME_FORCE, &q->queue_flags); 284 285 return queue_var_show(set << force, page); 286 } 287 288 static ssize_t 289 queue_rq_affinity_store(struct request_queue *q, const char *page, size_t count) 290 { 291 ssize_t ret = -EINVAL; 292 #ifdef CONFIG_SMP 293 unsigned long val; 294 295 ret = queue_var_store(&val, page, count); 296 if (ret < 0) 297 return ret; 298 299 spin_lock_irq(q->queue_lock); 300 if (val == 2) { 301 queue_flag_set(QUEUE_FLAG_SAME_COMP, q); 302 queue_flag_set(QUEUE_FLAG_SAME_FORCE, q); 303 } else if (val == 1) { 304 queue_flag_set(QUEUE_FLAG_SAME_COMP, q); 305 queue_flag_clear(QUEUE_FLAG_SAME_FORCE, q); 306 } else if (val == 0) { 307 queue_flag_clear(QUEUE_FLAG_SAME_COMP, q); 308 queue_flag_clear(QUEUE_FLAG_SAME_FORCE, q); 309 } 310 spin_unlock_irq(q->queue_lock); 311 #endif 312 return ret; 313 } 314 315 static struct queue_sysfs_entry queue_requests_entry = { 316 .attr = {.name = "nr_requests", .mode = S_IRUGO | S_IWUSR }, 317 .show = queue_requests_show, 318 .store = queue_requests_store, 319 }; 320 321 static struct queue_sysfs_entry queue_ra_entry = { 322 .attr = {.name = "read_ahead_kb", .mode = S_IRUGO | S_IWUSR }, 323 .show = queue_ra_show, 324 .store = queue_ra_store, 325 }; 326 327 static struct queue_sysfs_entry queue_max_sectors_entry = { 328 .attr = {.name = "max_sectors_kb", .mode = S_IRUGO | S_IWUSR }, 329 .show = queue_max_sectors_show, 330 .store = queue_max_sectors_store, 331 }; 332 333 static struct queue_sysfs_entry queue_max_hw_sectors_entry = { 334 .attr = {.name = "max_hw_sectors_kb", .mode = S_IRUGO }, 335 .show = queue_max_hw_sectors_show, 336 }; 337 338 static struct queue_sysfs_entry queue_max_segments_entry = { 339 .attr = {.name = "max_segments", .mode = S_IRUGO }, 340 .show = queue_max_segments_show, 341 }; 342 343 static struct queue_sysfs_entry queue_max_integrity_segments_entry = { 344 .attr = {.name = "max_integrity_segments", .mode = S_IRUGO }, 345 .show = queue_max_integrity_segments_show, 346 }; 347 348 static struct queue_sysfs_entry queue_max_segment_size_entry = { 349 .attr = {.name = "max_segment_size", .mode = S_IRUGO }, 350 .show = queue_max_segment_size_show, 351 }; 352 353 static struct queue_sysfs_entry queue_iosched_entry = { 354 .attr = {.name = "scheduler", .mode = S_IRUGO | S_IWUSR }, 355 .show = elv_iosched_show, 356 .store = elv_iosched_store, 357 }; 358 359 static struct queue_sysfs_entry queue_hw_sector_size_entry = { 360 .attr = {.name = "hw_sector_size", .mode = S_IRUGO }, 361 .show = queue_logical_block_size_show, 362 }; 363 364 static struct queue_sysfs_entry queue_logical_block_size_entry = { 365 .attr = {.name = "logical_block_size", .mode = S_IRUGO }, 366 .show = queue_logical_block_size_show, 367 }; 368 369 static struct queue_sysfs_entry queue_physical_block_size_entry = { 370 .attr = {.name = "physical_block_size", .mode = S_IRUGO }, 371 .show = queue_physical_block_size_show, 372 }; 373 374 static struct queue_sysfs_entry queue_io_min_entry = { 375 .attr = {.name = "minimum_io_size", .mode = S_IRUGO }, 376 .show = queue_io_min_show, 377 }; 378 379 static struct queue_sysfs_entry queue_io_opt_entry = { 380 .attr = {.name = "optimal_io_size", .mode = S_IRUGO }, 381 .show = queue_io_opt_show, 382 }; 383 384 static struct queue_sysfs_entry queue_discard_granularity_entry = { 385 .attr = {.name = "discard_granularity", .mode = S_IRUGO }, 386 .show = queue_discard_granularity_show, 387 }; 388 389 static struct queue_sysfs_entry queue_discard_max_entry = { 390 .attr = {.name = "discard_max_bytes", .mode = S_IRUGO }, 391 .show = queue_discard_max_show, 392 }; 393 394 static struct queue_sysfs_entry queue_discard_zeroes_data_entry = { 395 .attr = {.name = "discard_zeroes_data", .mode = S_IRUGO }, 396 .show = queue_discard_zeroes_data_show, 397 }; 398 399 static struct queue_sysfs_entry queue_write_same_max_entry = { 400 .attr = {.name = "write_same_max_bytes", .mode = S_IRUGO }, 401 .show = queue_write_same_max_show, 402 }; 403 404 static struct queue_sysfs_entry queue_nonrot_entry = { 405 .attr = {.name = "rotational", .mode = S_IRUGO | S_IWUSR }, 406 .show = queue_show_nonrot, 407 .store = queue_store_nonrot, 408 }; 409 410 static struct queue_sysfs_entry queue_nomerges_entry = { 411 .attr = {.name = "nomerges", .mode = S_IRUGO | S_IWUSR }, 412 .show = queue_nomerges_show, 413 .store = queue_nomerges_store, 414 }; 415 416 static struct queue_sysfs_entry queue_rq_affinity_entry = { 417 .attr = {.name = "rq_affinity", .mode = S_IRUGO | S_IWUSR }, 418 .show = queue_rq_affinity_show, 419 .store = queue_rq_affinity_store, 420 }; 421 422 static struct queue_sysfs_entry queue_iostats_entry = { 423 .attr = {.name = "iostats", .mode = S_IRUGO | S_IWUSR }, 424 .show = queue_show_iostats, 425 .store = queue_store_iostats, 426 }; 427 428 static struct queue_sysfs_entry queue_random_entry = { 429 .attr = {.name = "add_random", .mode = S_IRUGO | S_IWUSR }, 430 .show = queue_show_random, 431 .store = queue_store_random, 432 }; 433 434 static struct attribute *default_attrs[] = { 435 &queue_requests_entry.attr, 436 &queue_ra_entry.attr, 437 &queue_max_hw_sectors_entry.attr, 438 &queue_max_sectors_entry.attr, 439 &queue_max_segments_entry.attr, 440 &queue_max_integrity_segments_entry.attr, 441 &queue_max_segment_size_entry.attr, 442 &queue_iosched_entry.attr, 443 &queue_hw_sector_size_entry.attr, 444 &queue_logical_block_size_entry.attr, 445 &queue_physical_block_size_entry.attr, 446 &queue_io_min_entry.attr, 447 &queue_io_opt_entry.attr, 448 &queue_discard_granularity_entry.attr, 449 &queue_discard_max_entry.attr, 450 &queue_discard_zeroes_data_entry.attr, 451 &queue_write_same_max_entry.attr, 452 &queue_nonrot_entry.attr, 453 &queue_nomerges_entry.attr, 454 &queue_rq_affinity_entry.attr, 455 &queue_iostats_entry.attr, 456 &queue_random_entry.attr, 457 NULL, 458 }; 459 460 #define to_queue(atr) container_of((atr), struct queue_sysfs_entry, attr) 461 462 static ssize_t 463 queue_attr_show(struct kobject *kobj, struct attribute *attr, char *page) 464 { 465 struct queue_sysfs_entry *entry = to_queue(attr); 466 struct request_queue *q = 467 container_of(kobj, struct request_queue, kobj); 468 ssize_t res; 469 470 if (!entry->show) 471 return -EIO; 472 mutex_lock(&q->sysfs_lock); 473 if (blk_queue_dying(q)) { 474 mutex_unlock(&q->sysfs_lock); 475 return -ENOENT; 476 } 477 res = entry->show(q, page); 478 mutex_unlock(&q->sysfs_lock); 479 return res; 480 } 481 482 static ssize_t 483 queue_attr_store(struct kobject *kobj, struct attribute *attr, 484 const char *page, size_t length) 485 { 486 struct queue_sysfs_entry *entry = to_queue(attr); 487 struct request_queue *q; 488 ssize_t res; 489 490 if (!entry->store) 491 return -EIO; 492 493 q = container_of(kobj, struct request_queue, kobj); 494 mutex_lock(&q->sysfs_lock); 495 if (blk_queue_dying(q)) { 496 mutex_unlock(&q->sysfs_lock); 497 return -ENOENT; 498 } 499 res = entry->store(q, page, length); 500 mutex_unlock(&q->sysfs_lock); 501 return res; 502 } 503 504 static void blk_free_queue_rcu(struct rcu_head *rcu_head) 505 { 506 struct request_queue *q = container_of(rcu_head, struct request_queue, 507 rcu_head); 508 kmem_cache_free(blk_requestq_cachep, q); 509 } 510 511 /** 512 * blk_release_queue: - release a &struct request_queue when it is no longer needed 513 * @kobj: the kobj belonging to the request queue to be released 514 * 515 * Description: 516 * blk_release_queue is the pair to blk_init_queue() or 517 * blk_queue_make_request(). It should be called when a request queue is 518 * being released; typically when a block device is being de-registered. 519 * Currently, its primary task it to free all the &struct request 520 * structures that were allocated to the queue and the queue itself. 521 * 522 * Caveat: 523 * Hopefully the low level driver will have finished any 524 * outstanding requests first... 525 **/ 526 static void blk_release_queue(struct kobject *kobj) 527 { 528 struct request_queue *q = 529 container_of(kobj, struct request_queue, kobj); 530 531 blk_sync_queue(q); 532 533 blkcg_exit_queue(q); 534 535 if (q->elevator) { 536 spin_lock_irq(q->queue_lock); 537 ioc_clear_queue(q); 538 spin_unlock_irq(q->queue_lock); 539 elevator_exit(q->elevator); 540 } 541 542 blk_exit_rl(&q->root_rl); 543 544 if (q->queue_tags) 545 __blk_queue_free_tags(q); 546 547 percpu_counter_destroy(&q->mq_usage_counter); 548 549 if (q->mq_ops) 550 blk_mq_free_queue(q); 551 552 kfree(q->flush_rq); 553 554 blk_trace_shutdown(q); 555 556 bdi_destroy(&q->backing_dev_info); 557 558 ida_simple_remove(&blk_queue_ida, q->id); 559 call_rcu(&q->rcu_head, blk_free_queue_rcu); 560 } 561 562 static const struct sysfs_ops queue_sysfs_ops = { 563 .show = queue_attr_show, 564 .store = queue_attr_store, 565 }; 566 567 struct kobj_type blk_queue_ktype = { 568 .sysfs_ops = &queue_sysfs_ops, 569 .default_attrs = default_attrs, 570 .release = blk_release_queue, 571 }; 572 573 int blk_register_queue(struct gendisk *disk) 574 { 575 int ret; 576 struct device *dev = disk_to_dev(disk); 577 struct request_queue *q = disk->queue; 578 579 if (WARN_ON(!q)) 580 return -ENXIO; 581 582 /* 583 * Initialization must be complete by now. Finish the initial 584 * bypass from queue allocation. 585 */ 586 blk_queue_bypass_end(q); 587 queue_flag_set_unlocked(QUEUE_FLAG_INIT_DONE, q); 588 589 ret = blk_trace_init_sysfs(dev); 590 if (ret) 591 return ret; 592 593 ret = kobject_add(&q->kobj, kobject_get(&dev->kobj), "%s", "queue"); 594 if (ret < 0) { 595 blk_trace_remove_sysfs(dev); 596 return ret; 597 } 598 599 kobject_uevent(&q->kobj, KOBJ_ADD); 600 601 if (q->mq_ops) 602 blk_mq_register_disk(disk); 603 604 if (!q->request_fn) 605 return 0; 606 607 ret = elv_register_queue(q); 608 if (ret) { 609 kobject_uevent(&q->kobj, KOBJ_REMOVE); 610 kobject_del(&q->kobj); 611 blk_trace_remove_sysfs(dev); 612 kobject_put(&dev->kobj); 613 return ret; 614 } 615 616 return 0; 617 } 618 619 void blk_unregister_queue(struct gendisk *disk) 620 { 621 struct request_queue *q = disk->queue; 622 623 if (WARN_ON(!q)) 624 return; 625 626 if (q->mq_ops) 627 blk_mq_unregister_disk(disk); 628 629 if (q->request_fn) 630 elv_unregister_queue(q); 631 632 kobject_uevent(&q->kobj, KOBJ_REMOVE); 633 kobject_del(&q->kobj); 634 blk_trace_remove_sysfs(disk_to_dev(disk)); 635 kobject_put(&disk_to_dev(disk)->kobj); 636 } 637