1// SPDX-License-Identifier: GPL-2.0 2/* 3 * gendisk handling 4 */ 5 6#include <linux/module.h> 7#include <linux/ctype.h> 8#include <linux/fs.h> 9#include <linux/genhd.h> 10#include <linux/kdev_t.h> 11#include <linux/kernel.h> 12#include <linux/blkdev.h> 13#include <linux/backing-dev.h> 14#include <linux/init.h> 15#include <linux/spinlock.h> 16#include <linux/proc_fs.h> 17#include <linux/seq_file.h> 18#include <linux/slab.h> 19#include <linux/kmod.h> 20#include <linux/kobj_map.h> 21#include <linux/mutex.h> 22#include <linux/idr.h> 23#include <linux/log2.h> 24#include <linux/pm_runtime.h> 25#include <linux/badblocks.h> 26 27#include "blk.h" 28 29static DEFINE_MUTEX(block_class_lock); 30static struct kobject *block_depr; 31 32/* for extended dynamic devt allocation, currently only one major is used */ 33#define NR_EXT_DEVT (1 << MINORBITS) 34 35/* For extended devt allocation. ext_devt_lock prevents look up 36 * results from going away underneath its user. 37 */ 38static DEFINE_SPINLOCK(ext_devt_lock); 39static DEFINE_IDR(ext_devt_idr); 40 41static void disk_check_events(struct disk_events *ev, 42 unsigned int *clearing_ptr); 43static void disk_alloc_events(struct gendisk *disk); 44static void disk_add_events(struct gendisk *disk); 45static void disk_del_events(struct gendisk *disk); 46static void disk_release_events(struct gendisk *disk); 47 48/* 49 * Set disk capacity and notify if the size is not currently 50 * zero and will not be set to zero 51 */ 52bool set_capacity_revalidate_and_notify(struct gendisk *disk, sector_t size, 53 bool update_bdev) 54{ 55 sector_t capacity = get_capacity(disk); 56 57 set_capacity(disk, size); 58 if (update_bdev) 59 revalidate_disk_size(disk, true); 60 61 if (capacity != size && capacity != 0 && size != 0) { 62 char *envp[] = { "RESIZE=1", NULL }; 63 64 kobject_uevent_env(&disk_to_dev(disk)->kobj, KOBJ_CHANGE, envp); 65 return true; 66 } 67 68 return false; 69} 70 71EXPORT_SYMBOL_GPL(set_capacity_revalidate_and_notify); 72 73/* 74 * Format the device name of the indicated disk into the supplied buffer and 75 * return a pointer to that same buffer for convenience. 76 */ 77char *disk_name(struct gendisk *hd, int partno, char *buf) 78{ 79 if (!partno) 80 snprintf(buf, BDEVNAME_SIZE, "%s", hd->disk_name); 81 else if (isdigit(hd->disk_name[strlen(hd->disk_name)-1])) 82 snprintf(buf, BDEVNAME_SIZE, "%sp%d", hd->disk_name, partno); 83 else 84 snprintf(buf, BDEVNAME_SIZE, "%s%d", hd->disk_name, partno); 85 86 return buf; 87} 88 89const char *bdevname(struct block_device *bdev, char *buf) 90{ 91 return disk_name(bdev->bd_disk, bdev->bd_partno, buf); 92} 93EXPORT_SYMBOL(bdevname); 94 95static void part_stat_read_all(struct hd_struct *part, struct disk_stats *stat) 96{ 97 int cpu; 98 99 memset(stat, 0, sizeof(struct disk_stats)); 100 for_each_possible_cpu(cpu) { 101 struct disk_stats *ptr = per_cpu_ptr(part->dkstats, cpu); 102 int group; 103 104 for (group = 0; group < NR_STAT_GROUPS; group++) { 105 stat->nsecs[group] += ptr->nsecs[group]; 106 stat->sectors[group] += ptr->sectors[group]; 107 stat->ios[group] += ptr->ios[group]; 108 stat->merges[group] += ptr->merges[group]; 109 } 110 111 stat->io_ticks += ptr->io_ticks; 112 } 113} 114 115static unsigned int part_in_flight(struct hd_struct *part) 116{ 117 unsigned int inflight = 0; 118 int cpu; 119 120 for_each_possible_cpu(cpu) { 121 inflight += part_stat_local_read_cpu(part, in_flight[0], cpu) + 122 part_stat_local_read_cpu(part, in_flight[1], cpu); 123 } 124 if ((int)inflight < 0) 125 inflight = 0; 126 127 return inflight; 128} 129 130static void part_in_flight_rw(struct hd_struct *part, unsigned int inflight[2]) 131{ 132 int cpu; 133 134 inflight[0] = 0; 135 inflight[1] = 0; 136 for_each_possible_cpu(cpu) { 137 inflight[0] += part_stat_local_read_cpu(part, in_flight[0], cpu); 138 inflight[1] += part_stat_local_read_cpu(part, in_flight[1], cpu); 139 } 140 if ((int)inflight[0] < 0) 141 inflight[0] = 0; 142 if ((int)inflight[1] < 0) 143 inflight[1] = 0; 144} 145 146struct hd_struct *__disk_get_part(struct gendisk *disk, int partno) 147{ 148 struct disk_part_tbl *ptbl = rcu_dereference(disk->part_tbl); 149 150 if (unlikely(partno < 0 || partno >= ptbl->len)) 151 return NULL; 152 return rcu_dereference(ptbl->part[partno]); 153} 154 155/** 156 * disk_get_part - get partition 157 * @disk: disk to look partition from 158 * @partno: partition number 159 * 160 * Look for partition @partno from @disk. If found, increment 161 * reference count and return it. 162 * 163 * CONTEXT: 164 * Don't care. 165 * 166 * RETURNS: 167 * Pointer to the found partition on success, NULL if not found. 168 */ 169struct hd_struct *disk_get_part(struct gendisk *disk, int partno) 170{ 171 struct hd_struct *part; 172 173 rcu_read_lock(); 174 part = __disk_get_part(disk, partno); 175 if (part) 176 get_device(part_to_dev(part)); 177 rcu_read_unlock(); 178 179 return part; 180} 181 182/** 183 * disk_part_iter_init - initialize partition iterator 184 * @piter: iterator to initialize 185 * @disk: disk to iterate over 186 * @flags: DISK_PITER_* flags 187 * 188 * Initialize @piter so that it iterates over partitions of @disk. 189 * 190 * CONTEXT: 191 * Don't care. 192 */ 193void disk_part_iter_init(struct disk_part_iter *piter, struct gendisk *disk, 194 unsigned int flags) 195{ 196 struct disk_part_tbl *ptbl; 197 198 rcu_read_lock(); 199 ptbl = rcu_dereference(disk->part_tbl); 200 201 piter->disk = disk; 202 piter->part = NULL; 203 204 if (flags & DISK_PITER_REVERSE) 205 piter->idx = ptbl->len - 1; 206 else if (flags & (DISK_PITER_INCL_PART0 | DISK_PITER_INCL_EMPTY_PART0)) 207 piter->idx = 0; 208 else 209 piter->idx = 1; 210 211 piter->flags = flags; 212 213 rcu_read_unlock(); 214} 215EXPORT_SYMBOL_GPL(disk_part_iter_init); 216 217/** 218 * disk_part_iter_next - proceed iterator to the next partition and return it 219 * @piter: iterator of interest 220 * 221 * Proceed @piter to the next partition and return it. 222 * 223 * CONTEXT: 224 * Don't care. 225 */ 226struct hd_struct *disk_part_iter_next(struct disk_part_iter *piter) 227{ 228 struct disk_part_tbl *ptbl; 229 int inc, end; 230 231 /* put the last partition */ 232 disk_put_part(piter->part); 233 piter->part = NULL; 234 235 /* get part_tbl */ 236 rcu_read_lock(); 237 ptbl = rcu_dereference(piter->disk->part_tbl); 238 239 /* determine iteration parameters */ 240 if (piter->flags & DISK_PITER_REVERSE) { 241 inc = -1; 242 if (piter->flags & (DISK_PITER_INCL_PART0 | 243 DISK_PITER_INCL_EMPTY_PART0)) 244 end = -1; 245 else 246 end = 0; 247 } else { 248 inc = 1; 249 end = ptbl->len; 250 } 251 252 /* iterate to the next partition */ 253 for (; piter->idx != end; piter->idx += inc) { 254 struct hd_struct *part; 255 256 part = rcu_dereference(ptbl->part[piter->idx]); 257 if (!part) 258 continue; 259 get_device(part_to_dev(part)); 260 piter->part = part; 261 if (!part_nr_sects_read(part) && 262 !(piter->flags & DISK_PITER_INCL_EMPTY) && 263 !(piter->flags & DISK_PITER_INCL_EMPTY_PART0 && 264 piter->idx == 0)) { 265 put_device(part_to_dev(part)); 266 piter->part = NULL; 267 continue; 268 } 269 270 piter->idx += inc; 271 break; 272 } 273 274 rcu_read_unlock(); 275 276 return piter->part; 277} 278EXPORT_SYMBOL_GPL(disk_part_iter_next); 279 280/** 281 * disk_part_iter_exit - finish up partition iteration 282 * @piter: iter of interest 283 * 284 * Called when iteration is over. Cleans up @piter. 285 * 286 * CONTEXT: 287 * Don't care. 288 */ 289void disk_part_iter_exit(struct disk_part_iter *piter) 290{ 291 disk_put_part(piter->part); 292 piter->part = NULL; 293} 294EXPORT_SYMBOL_GPL(disk_part_iter_exit); 295 296static inline int sector_in_part(struct hd_struct *part, sector_t sector) 297{ 298 return part->start_sect <= sector && 299 sector < part->start_sect + part_nr_sects_read(part); 300} 301 302/** 303 * disk_map_sector_rcu - map sector to partition 304 * @disk: gendisk of interest 305 * @sector: sector to map 306 * 307 * Find out which partition @sector maps to on @disk. This is 308 * primarily used for stats accounting. 309 * 310 * CONTEXT: 311 * RCU read locked. The returned partition pointer is always valid 312 * because its refcount is grabbed except for part0, which lifetime 313 * is same with the disk. 314 * 315 * RETURNS: 316 * Found partition on success, part0 is returned if no partition matches 317 * or the matched partition is being deleted. 318 */ 319struct hd_struct *disk_map_sector_rcu(struct gendisk *disk, sector_t sector) 320{ 321 struct disk_part_tbl *ptbl; 322 struct hd_struct *part; 323 int i; 324 325 rcu_read_lock(); 326 ptbl = rcu_dereference(disk->part_tbl); 327 328 part = rcu_dereference(ptbl->last_lookup); 329 if (part && sector_in_part(part, sector) && hd_struct_try_get(part)) 330 goto out_unlock; 331 332 for (i = 1; i < ptbl->len; i++) { 333 part = rcu_dereference(ptbl->part[i]); 334 335 if (part && sector_in_part(part, sector)) { 336 /* 337 * only live partition can be cached for lookup, 338 * so use-after-free on cached & deleting partition 339 * can be avoided 340 */ 341 if (!hd_struct_try_get(part)) 342 break; 343 rcu_assign_pointer(ptbl->last_lookup, part); 344 goto out_unlock; 345 } 346 } 347 348 part = &disk->part0; 349out_unlock: 350 rcu_read_unlock(); 351 return part; 352} 353 354/** 355 * disk_has_partitions 356 * @disk: gendisk of interest 357 * 358 * Walk through the partition table and check if valid partition exists. 359 * 360 * CONTEXT: 361 * Don't care. 362 * 363 * RETURNS: 364 * True if the gendisk has at least one valid non-zero size partition. 365 * Otherwise false. 366 */ 367bool disk_has_partitions(struct gendisk *disk) 368{ 369 struct disk_part_tbl *ptbl; 370 int i; 371 bool ret = false; 372 373 rcu_read_lock(); 374 ptbl = rcu_dereference(disk->part_tbl); 375 376 /* Iterate partitions skipping the whole device at index 0 */ 377 for (i = 1; i < ptbl->len; i++) { 378 if (rcu_dereference(ptbl->part[i])) { 379 ret = true; 380 break; 381 } 382 } 383 384 rcu_read_unlock(); 385 386 return ret; 387} 388EXPORT_SYMBOL_GPL(disk_has_partitions); 389 390/* 391 * Can be deleted altogether. Later. 392 * 393 */ 394#define BLKDEV_MAJOR_HASH_SIZE 255 395static struct blk_major_name { 396 struct blk_major_name *next; 397 int major; 398 char name[16]; 399} *major_names[BLKDEV_MAJOR_HASH_SIZE]; 400 401/* index in the above - for now: assume no multimajor ranges */ 402static inline int major_to_index(unsigned major) 403{ 404 return major % BLKDEV_MAJOR_HASH_SIZE; 405} 406 407#ifdef CONFIG_PROC_FS 408void blkdev_show(struct seq_file *seqf, off_t offset) 409{ 410 struct blk_major_name *dp; 411 412 mutex_lock(&block_class_lock); 413 for (dp = major_names[major_to_index(offset)]; dp; dp = dp->next) 414 if (dp->major == offset) 415 seq_printf(seqf, "%3d %s\n", dp->major, dp->name); 416 mutex_unlock(&block_class_lock); 417} 418#endif /* CONFIG_PROC_FS */ 419 420/** 421 * register_blkdev - register a new block device 422 * 423 * @major: the requested major device number [1..BLKDEV_MAJOR_MAX-1]. If 424 * @major = 0, try to allocate any unused major number. 425 * @name: the name of the new block device as a zero terminated string 426 * 427 * The @name must be unique within the system. 428 * 429 * The return value depends on the @major input parameter: 430 * 431 * - if a major device number was requested in range [1..BLKDEV_MAJOR_MAX-1] 432 * then the function returns zero on success, or a negative error code 433 * - if any unused major number was requested with @major = 0 parameter 434 * then the return value is the allocated major number in range 435 * [1..BLKDEV_MAJOR_MAX-1] or a negative error code otherwise 436 * 437 * See Documentation/admin-guide/devices.txt for the list of allocated 438 * major numbers. 439 */ 440int register_blkdev(unsigned int major, const char *name) 441{ 442 struct blk_major_name **n, *p; 443 int index, ret = 0; 444 445 mutex_lock(&block_class_lock); 446 447 /* temporary */ 448 if (major == 0) { 449 for (index = ARRAY_SIZE(major_names)-1; index > 0; index--) { 450 if (major_names[index] == NULL) 451 break; 452 } 453 454 if (index == 0) { 455 printk("%s: failed to get major for %s\n", 456 __func__, name); 457 ret = -EBUSY; 458 goto out; 459 } 460 major = index; 461 ret = major; 462 } 463 464 if (major >= BLKDEV_MAJOR_MAX) { 465 pr_err("%s: major requested (%u) is greater than the maximum (%u) for %s\n", 466 __func__, major, BLKDEV_MAJOR_MAX-1, name); 467 468 ret = -EINVAL; 469 goto out; 470 } 471 472 p = kmalloc(sizeof(struct blk_major_name), GFP_KERNEL); 473 if (p == NULL) { 474 ret = -ENOMEM; 475 goto out; 476 } 477 478 p->major = major; 479 strlcpy(p->name, name, sizeof(p->name)); 480 p->next = NULL; 481 index = major_to_index(major); 482 483 for (n = &major_names[index]; *n; n = &(*n)->next) { 484 if ((*n)->major == major) 485 break; 486 } 487 if (!*n) 488 *n = p; 489 else 490 ret = -EBUSY; 491 492 if (ret < 0) { 493 printk("register_blkdev: cannot get major %u for %s\n", 494 major, name); 495 kfree(p); 496 } 497out: 498 mutex_unlock(&block_class_lock); 499 return ret; 500} 501 502EXPORT_SYMBOL(register_blkdev); 503 504void unregister_blkdev(unsigned int major, const char *name) 505{ 506 struct blk_major_name **n; 507 struct blk_major_name *p = NULL; 508 int index = major_to_index(major); 509 510 mutex_lock(&block_class_lock); 511 for (n = &major_names[index]; *n; n = &(*n)->next) 512 if ((*n)->major == major) 513 break; 514 if (!*n || strcmp((*n)->name, name)) { 515 WARN_ON(1); 516 } else { 517 p = *n; 518 *n = p->next; 519 } 520 mutex_unlock(&block_class_lock); 521 kfree(p); 522} 523 524EXPORT_SYMBOL(unregister_blkdev); 525 526static struct kobj_map *bdev_map; 527 528/** 529 * blk_mangle_minor - scatter minor numbers apart 530 * @minor: minor number to mangle 531 * 532 * Scatter consecutively allocated @minor number apart if MANGLE_DEVT 533 * is enabled. Mangling twice gives the original value. 534 * 535 * RETURNS: 536 * Mangled value. 537 * 538 * CONTEXT: 539 * Don't care. 540 */ 541static int blk_mangle_minor(int minor) 542{ 543#ifdef CONFIG_DEBUG_BLOCK_EXT_DEVT 544 int i; 545 546 for (i = 0; i < MINORBITS / 2; i++) { 547 int low = minor & (1 << i); 548 int high = minor & (1 << (MINORBITS - 1 - i)); 549 int distance = MINORBITS - 1 - 2 * i; 550 551 minor ^= low | high; /* clear both bits */ 552 low <<= distance; /* swap the positions */ 553 high >>= distance; 554 minor |= low | high; /* and set */ 555 } 556#endif 557 return minor; 558} 559 560/** 561 * blk_alloc_devt - allocate a dev_t for a partition 562 * @part: partition to allocate dev_t for 563 * @devt: out parameter for resulting dev_t 564 * 565 * Allocate a dev_t for block device. 566 * 567 * RETURNS: 568 * 0 on success, allocated dev_t is returned in *@devt. -errno on 569 * failure. 570 * 571 * CONTEXT: 572 * Might sleep. 573 */ 574int blk_alloc_devt(struct hd_struct *part, dev_t *devt) 575{ 576 struct gendisk *disk = part_to_disk(part); 577 int idx; 578 579 /* in consecutive minor range? */ 580 if (part->partno < disk->minors) { 581 *devt = MKDEV(disk->major, disk->first_minor + part->partno); 582 return 0; 583 } 584 585 /* allocate ext devt */ 586 idr_preload(GFP_KERNEL); 587 588 spin_lock_bh(&ext_devt_lock); 589 idx = idr_alloc(&ext_devt_idr, part, 0, NR_EXT_DEVT, GFP_NOWAIT); 590 spin_unlock_bh(&ext_devt_lock); 591 592 idr_preload_end(); 593 if (idx < 0) 594 return idx == -ENOSPC ? -EBUSY : idx; 595 596 *devt = MKDEV(BLOCK_EXT_MAJOR, blk_mangle_minor(idx)); 597 return 0; 598} 599 600/** 601 * blk_free_devt - free a dev_t 602 * @devt: dev_t to free 603 * 604 * Free @devt which was allocated using blk_alloc_devt(). 605 * 606 * CONTEXT: 607 * Might sleep. 608 */ 609void blk_free_devt(dev_t devt) 610{ 611 if (devt == MKDEV(0, 0)) 612 return; 613 614 if (MAJOR(devt) == BLOCK_EXT_MAJOR) { 615 spin_lock_bh(&ext_devt_lock); 616 idr_remove(&ext_devt_idr, blk_mangle_minor(MINOR(devt))); 617 spin_unlock_bh(&ext_devt_lock); 618 } 619} 620 621/* 622 * We invalidate devt by assigning NULL pointer for devt in idr. 623 */ 624void blk_invalidate_devt(dev_t devt) 625{ 626 if (MAJOR(devt) == BLOCK_EXT_MAJOR) { 627 spin_lock_bh(&ext_devt_lock); 628 idr_replace(&ext_devt_idr, NULL, blk_mangle_minor(MINOR(devt))); 629 spin_unlock_bh(&ext_devt_lock); 630 } 631} 632 633static char *bdevt_str(dev_t devt, char *buf) 634{ 635 if (MAJOR(devt) <= 0xff && MINOR(devt) <= 0xff) { 636 char tbuf[BDEVT_SIZE]; 637 snprintf(tbuf, BDEVT_SIZE, "%02x%02x", MAJOR(devt), MINOR(devt)); 638 snprintf(buf, BDEVT_SIZE, "%-9s", tbuf); 639 } else 640 snprintf(buf, BDEVT_SIZE, "%03x:%05x", MAJOR(devt), MINOR(devt)); 641 642 return buf; 643} 644 645/* 646 * Register device numbers dev..(dev+range-1) 647 * range must be nonzero 648 * The hash chain is sorted on range, so that subranges can override. 649 */ 650void blk_register_region(dev_t devt, unsigned long range, struct module *module, 651 struct kobject *(*probe)(dev_t, int *, void *), 652 int (*lock)(dev_t, void *), void *data) 653{ 654 kobj_map(bdev_map, devt, range, module, probe, lock, data); 655} 656 657EXPORT_SYMBOL(blk_register_region); 658 659void blk_unregister_region(dev_t devt, unsigned long range) 660{ 661 kobj_unmap(bdev_map, devt, range); 662} 663 664EXPORT_SYMBOL(blk_unregister_region); 665 666void blk_delete_region(dev_t devt, unsigned long range, 667 struct kobject *(*probe)(dev_t, int *, void *)) 668{ 669 kobj_delete(bdev_map, devt, range, probe); 670} 671 672EXPORT_SYMBOL(blk_delete_region); 673 674static struct kobject *exact_match(dev_t devt, int *partno, void *data) 675{ 676 struct gendisk *p = data; 677 678 return &disk_to_dev(p)->kobj; 679} 680 681static int exact_lock(dev_t devt, void *data) 682{ 683 struct gendisk *p = data; 684 685 if (!get_disk_and_module(p)) 686 return -1; 687 return 0; 688} 689 690static void disk_scan_partitions(struct gendisk *disk) 691{ 692 struct block_device *bdev; 693 694 if (!get_capacity(disk) || !disk_part_scan_enabled(disk)) 695 return; 696 697 set_bit(GD_NEED_PART_SCAN, &disk->state); 698 bdev = blkdev_get_by_dev(disk_devt(disk), FMODE_READ, NULL); 699 if (!IS_ERR(bdev)) 700 blkdev_put(bdev, FMODE_READ); 701} 702 703static void register_disk(struct device *parent, struct gendisk *disk, 704 const struct attribute_group **groups) 705{ 706 struct device *ddev = disk_to_dev(disk); 707 struct disk_part_iter piter; 708 struct hd_struct *part; 709 int err; 710 711 ddev->parent = parent; 712 713 dev_set_name(ddev, "%s", disk->disk_name); 714 715 /* delay uevents, until we scanned partition table */ 716 dev_set_uevent_suppress(ddev, 1); 717 718 if (groups) { 719 WARN_ON(ddev->groups); 720 ddev->groups = groups; 721 } 722 if (device_add(ddev)) 723 return; 724 if (!sysfs_deprecated) { 725 err = sysfs_create_link(block_depr, &ddev->kobj, 726 kobject_name(&ddev->kobj)); 727 if (err) { 728 device_del(ddev); 729 return; 730 } 731 } 732 733 /* 734 * avoid probable deadlock caused by allocating memory with 735 * GFP_KERNEL in runtime_resume callback of its all ancestor 736 * devices 737 */ 738 pm_runtime_set_memalloc_noio(ddev, true); 739 740 disk->part0.holder_dir = kobject_create_and_add("holders", &ddev->kobj); 741 disk->slave_dir = kobject_create_and_add("slaves", &ddev->kobj); 742 743 if (disk->flags & GENHD_FL_HIDDEN) 744 return; 745 746 disk_scan_partitions(disk); 747 748 /* announce disk after possible partitions are created */ 749 dev_set_uevent_suppress(ddev, 0); 750 kobject_uevent(&ddev->kobj, KOBJ_ADD); 751 752 /* announce possible partitions */ 753 disk_part_iter_init(&piter, disk, 0); 754 while ((part = disk_part_iter_next(&piter))) 755 kobject_uevent(&part_to_dev(part)->kobj, KOBJ_ADD); 756 disk_part_iter_exit(&piter); 757 758 if (disk->queue->backing_dev_info->dev) { 759 err = sysfs_create_link(&ddev->kobj, 760 &disk->queue->backing_dev_info->dev->kobj, 761 "bdi"); 762 WARN_ON(err); 763 } 764} 765 766/** 767 * __device_add_disk - add disk information to kernel list 768 * @parent: parent device for the disk 769 * @disk: per-device partitioning information 770 * @groups: Additional per-device sysfs groups 771 * @register_queue: register the queue if set to true 772 * 773 * This function registers the partitioning information in @disk 774 * with the kernel. 775 * 776 * FIXME: error handling 777 */ 778static void __device_add_disk(struct device *parent, struct gendisk *disk, 779 const struct attribute_group **groups, 780 bool register_queue) 781{ 782 dev_t devt; 783 int retval; 784 785 /* 786 * The disk queue should now be all set with enough information about 787 * the device for the elevator code to pick an adequate default 788 * elevator if one is needed, that is, for devices requesting queue 789 * registration. 790 */ 791 if (register_queue) 792 elevator_init_mq(disk->queue); 793 794 /* minors == 0 indicates to use ext devt from part0 and should 795 * be accompanied with EXT_DEVT flag. Make sure all 796 * parameters make sense. 797 */ 798 WARN_ON(disk->minors && !(disk->major || disk->first_minor)); 799 WARN_ON(!disk->minors && 800 !(disk->flags & (GENHD_FL_EXT_DEVT | GENHD_FL_HIDDEN))); 801 802 disk->flags |= GENHD_FL_UP; 803 804 retval = blk_alloc_devt(&disk->part0, &devt); 805 if (retval) { 806 WARN_ON(1); 807 return; 808 } 809 disk->major = MAJOR(devt); 810 disk->first_minor = MINOR(devt); 811 812 disk_alloc_events(disk); 813 814 if (disk->flags & GENHD_FL_HIDDEN) { 815 /* 816 * Don't let hidden disks show up in /proc/partitions, 817 * and don't bother scanning for partitions either. 818 */ 819 disk->flags |= GENHD_FL_SUPPRESS_PARTITION_INFO; 820 disk->flags |= GENHD_FL_NO_PART_SCAN; 821 } else { 822 struct backing_dev_info *bdi = disk->queue->backing_dev_info; 823 struct device *dev = disk_to_dev(disk); 824 int ret; 825 826 /* Register BDI before referencing it from bdev */ 827 dev->devt = devt; 828 ret = bdi_register(bdi, "%u:%u", MAJOR(devt), MINOR(devt)); 829 WARN_ON(ret); 830 bdi_set_owner(bdi, dev); 831 blk_register_region(disk_devt(disk), disk->minors, NULL, 832 exact_match, exact_lock, disk); 833 } 834 register_disk(parent, disk, groups); 835 if (register_queue) 836 blk_register_queue(disk); 837 838 /* 839 * Take an extra ref on queue which will be put on disk_release() 840 * so that it sticks around as long as @disk is there. 841 */ 842 WARN_ON_ONCE(!blk_get_queue(disk->queue)); 843 844 disk_add_events(disk); 845 blk_integrity_add(disk); 846} 847 848void device_add_disk(struct device *parent, struct gendisk *disk, 849 const struct attribute_group **groups) 850 851{ 852 __device_add_disk(parent, disk, groups, true); 853} 854EXPORT_SYMBOL(device_add_disk); 855 856void device_add_disk_no_queue_reg(struct device *parent, struct gendisk *disk) 857{ 858 __device_add_disk(parent, disk, NULL, false); 859} 860EXPORT_SYMBOL(device_add_disk_no_queue_reg); 861 862static void invalidate_partition(struct gendisk *disk, int partno) 863{ 864 struct block_device *bdev; 865 866 bdev = bdget_disk(disk, partno); 867 if (!bdev) 868 return; 869 870 fsync_bdev(bdev); 871 __invalidate_device(bdev, true); 872 873 /* 874 * Unhash the bdev inode for this device so that it gets evicted as soon 875 * as last inode reference is dropped. 876 */ 877 remove_inode_hash(bdev->bd_inode); 878 bdput(bdev); 879} 880 881/** 882 * del_gendisk - remove the gendisk 883 * @disk: the struct gendisk to remove 884 * 885 * Removes the gendisk and all its associated resources. This deletes the 886 * partitions associated with the gendisk, and unregisters the associated 887 * request_queue. 888 * 889 * This is the counter to the respective __device_add_disk() call. 890 * 891 * The final removal of the struct gendisk happens when its refcount reaches 0 892 * with put_disk(), which should be called after del_gendisk(), if 893 * __device_add_disk() was used. 894 * 895 * Drivers exist which depend on the release of the gendisk to be synchronous, 896 * it should not be deferred. 897 * 898 * Context: can sleep 899 */ 900void del_gendisk(struct gendisk *disk) 901{ 902 struct disk_part_iter piter; 903 struct hd_struct *part; 904 905 might_sleep(); 906 907 blk_integrity_del(disk); 908 disk_del_events(disk); 909 910 /* 911 * Block lookups of the disk until all bdevs are unhashed and the 912 * disk is marked as dead (GENHD_FL_UP cleared). 913 */ 914 down_write(&disk->lookup_sem); 915 /* invalidate stuff */ 916 disk_part_iter_init(&piter, disk, 917 DISK_PITER_INCL_EMPTY | DISK_PITER_REVERSE); 918 while ((part = disk_part_iter_next(&piter))) { 919 invalidate_partition(disk, part->partno); 920 delete_partition(part); 921 } 922 disk_part_iter_exit(&piter); 923 924 invalidate_partition(disk, 0); 925 set_capacity(disk, 0); 926 disk->flags &= ~GENHD_FL_UP; 927 up_write(&disk->lookup_sem); 928 929 if (!(disk->flags & GENHD_FL_HIDDEN)) 930 sysfs_remove_link(&disk_to_dev(disk)->kobj, "bdi"); 931 if (disk->queue) { 932 /* 933 * Unregister bdi before releasing device numbers (as they can 934 * get reused and we'd get clashes in sysfs). 935 */ 936 if (!(disk->flags & GENHD_FL_HIDDEN)) 937 bdi_unregister(disk->queue->backing_dev_info); 938 blk_unregister_queue(disk); 939 } else { 940 WARN_ON(1); 941 } 942 943 if (!(disk->flags & GENHD_FL_HIDDEN)) 944 blk_unregister_region(disk_devt(disk), disk->minors); 945 /* 946 * Remove gendisk pointer from idr so that it cannot be looked up 947 * while RCU period before freeing gendisk is running to prevent 948 * use-after-free issues. Note that the device number stays 949 * "in-use" until we really free the gendisk. 950 */ 951 blk_invalidate_devt(disk_devt(disk)); 952 953 kobject_put(disk->part0.holder_dir); 954 kobject_put(disk->slave_dir); 955 956 part_stat_set_all(&disk->part0, 0); 957 disk->part0.stamp = 0; 958 if (!sysfs_deprecated) 959 sysfs_remove_link(block_depr, dev_name(disk_to_dev(disk))); 960 pm_runtime_set_memalloc_noio(disk_to_dev(disk), false); 961 device_del(disk_to_dev(disk)); 962} 963EXPORT_SYMBOL(del_gendisk); 964 965/* sysfs access to bad-blocks list. */ 966static ssize_t disk_badblocks_show(struct device *dev, 967 struct device_attribute *attr, 968 char *page) 969{ 970 struct gendisk *disk = dev_to_disk(dev); 971 972 if (!disk->bb) 973 return sprintf(page, "\n"); 974 975 return badblocks_show(disk->bb, page, 0); 976} 977 978static ssize_t disk_badblocks_store(struct device *dev, 979 struct device_attribute *attr, 980 const char *page, size_t len) 981{ 982 struct gendisk *disk = dev_to_disk(dev); 983 984 if (!disk->bb) 985 return -ENXIO; 986 987 return badblocks_store(disk->bb, page, len, 0); 988} 989 990/** 991 * get_gendisk - get partitioning information for a given device 992 * @devt: device to get partitioning information for 993 * @partno: returned partition index 994 * 995 * This function gets the structure containing partitioning 996 * information for the given device @devt. 997 * 998 * Context: can sleep 999 */ 1000struct gendisk *get_gendisk(dev_t devt, int *partno) 1001{ 1002 struct gendisk *disk = NULL; 1003 1004 might_sleep(); 1005 1006 if (MAJOR(devt) != BLOCK_EXT_MAJOR) { 1007 struct kobject *kobj; 1008 1009 kobj = kobj_lookup(bdev_map, devt, partno); 1010 if (kobj) 1011 disk = dev_to_disk(kobj_to_dev(kobj)); 1012 } else { 1013 struct hd_struct *part; 1014 1015 spin_lock_bh(&ext_devt_lock); 1016 part = idr_find(&ext_devt_idr, blk_mangle_minor(MINOR(devt))); 1017 if (part && get_disk_and_module(part_to_disk(part))) { 1018 *partno = part->partno; 1019 disk = part_to_disk(part); 1020 } 1021 spin_unlock_bh(&ext_devt_lock); 1022 } 1023 1024 if (!disk) 1025 return NULL; 1026 1027 /* 1028 * Synchronize with del_gendisk() to not return disk that is being 1029 * destroyed. 1030 */ 1031 down_read(&disk->lookup_sem); 1032 if (unlikely((disk->flags & GENHD_FL_HIDDEN) || 1033 !(disk->flags & GENHD_FL_UP))) { 1034 up_read(&disk->lookup_sem); 1035 put_disk_and_module(disk); 1036 disk = NULL; 1037 } else { 1038 up_read(&disk->lookup_sem); 1039 } 1040 return disk; 1041} 1042 1043/** 1044 * bdget_disk - do bdget() by gendisk and partition number 1045 * @disk: gendisk of interest 1046 * @partno: partition number 1047 * 1048 * Find partition @partno from @disk, do bdget() on it. 1049 * 1050 * CONTEXT: 1051 * Don't care. 1052 * 1053 * RETURNS: 1054 * Resulting block_device on success, NULL on failure. 1055 */ 1056struct block_device *bdget_disk(struct gendisk *disk, int partno) 1057{ 1058 struct hd_struct *part; 1059 struct block_device *bdev = NULL; 1060 1061 part = disk_get_part(disk, partno); 1062 if (part) 1063 bdev = bdget_part(part); 1064 disk_put_part(part); 1065 1066 return bdev; 1067} 1068EXPORT_SYMBOL(bdget_disk); 1069 1070/* 1071 * print a full list of all partitions - intended for places where the root 1072 * filesystem can't be mounted and thus to give the victim some idea of what 1073 * went wrong 1074 */ 1075void __init printk_all_partitions(void) 1076{ 1077 struct class_dev_iter iter; 1078 struct device *dev; 1079 1080 class_dev_iter_init(&iter, &block_class, NULL, &disk_type); 1081 while ((dev = class_dev_iter_next(&iter))) { 1082 struct gendisk *disk = dev_to_disk(dev); 1083 struct disk_part_iter piter; 1084 struct hd_struct *part; 1085 char name_buf[BDEVNAME_SIZE]; 1086 char devt_buf[BDEVT_SIZE]; 1087 1088 /* 1089 * Don't show empty devices or things that have been 1090 * suppressed 1091 */ 1092 if (get_capacity(disk) == 0 || 1093 (disk->flags & GENHD_FL_SUPPRESS_PARTITION_INFO)) 1094 continue; 1095 1096 /* 1097 * Note, unlike /proc/partitions, I am showing the 1098 * numbers in hex - the same format as the root= 1099 * option takes. 1100 */ 1101 disk_part_iter_init(&piter, disk, DISK_PITER_INCL_PART0); 1102 while ((part = disk_part_iter_next(&piter))) { 1103 bool is_part0 = part == &disk->part0; 1104 1105 printk("%s%s %10llu %s %s", is_part0 ? "" : " ", 1106 bdevt_str(part_devt(part), devt_buf), 1107 (unsigned long long)part_nr_sects_read(part) >> 1 1108 , disk_name(disk, part->partno, name_buf), 1109 part->info ? part->info->uuid : ""); 1110 if (is_part0) { 1111 if (dev->parent && dev->parent->driver) 1112 printk(" driver: %s\n", 1113 dev->parent->driver->name); 1114 else 1115 printk(" (driver?)\n"); 1116 } else 1117 printk("\n"); 1118 } 1119 disk_part_iter_exit(&piter); 1120 } 1121 class_dev_iter_exit(&iter); 1122} 1123 1124#ifdef CONFIG_PROC_FS 1125/* iterator */ 1126static void *disk_seqf_start(struct seq_file *seqf, loff_t *pos) 1127{ 1128 loff_t skip = *pos; 1129 struct class_dev_iter *iter; 1130 struct device *dev; 1131 1132 iter = kmalloc(sizeof(*iter), GFP_KERNEL); 1133 if (!iter) 1134 return ERR_PTR(-ENOMEM); 1135 1136 seqf->private = iter; 1137 class_dev_iter_init(iter, &block_class, NULL, &disk_type); 1138 do { 1139 dev = class_dev_iter_next(iter); 1140 if (!dev) 1141 return NULL; 1142 } while (skip--); 1143 1144 return dev_to_disk(dev); 1145} 1146 1147static void *disk_seqf_next(struct seq_file *seqf, void *v, loff_t *pos) 1148{ 1149 struct device *dev; 1150 1151 (*pos)++; 1152 dev = class_dev_iter_next(seqf->private); 1153 if (dev) 1154 return dev_to_disk(dev); 1155 1156 return NULL; 1157} 1158 1159static void disk_seqf_stop(struct seq_file *seqf, void *v) 1160{ 1161 struct class_dev_iter *iter = seqf->private; 1162 1163 /* stop is called even after start failed :-( */ 1164 if (iter) { 1165 class_dev_iter_exit(iter); 1166 kfree(iter); 1167 seqf->private = NULL; 1168 } 1169} 1170 1171static void *show_partition_start(struct seq_file *seqf, loff_t *pos) 1172{ 1173 void *p; 1174 1175 p = disk_seqf_start(seqf, pos); 1176 if (!IS_ERR_OR_NULL(p) && !*pos) 1177 seq_puts(seqf, "major minor #blocks name\n\n"); 1178 return p; 1179} 1180 1181static int show_partition(struct seq_file *seqf, void *v) 1182{ 1183 struct gendisk *sgp = v; 1184 struct disk_part_iter piter; 1185 struct hd_struct *part; 1186 char buf[BDEVNAME_SIZE]; 1187 1188 /* Don't show non-partitionable removeable devices or empty devices */ 1189 if (!get_capacity(sgp) || (!disk_max_parts(sgp) && 1190 (sgp->flags & GENHD_FL_REMOVABLE))) 1191 return 0; 1192 if (sgp->flags & GENHD_FL_SUPPRESS_PARTITION_INFO) 1193 return 0; 1194 1195 /* show the full disk and all non-0 size partitions of it */ 1196 disk_part_iter_init(&piter, sgp, DISK_PITER_INCL_PART0); 1197 while ((part = disk_part_iter_next(&piter))) 1198 seq_printf(seqf, "%4d %7d %10llu %s\n", 1199 MAJOR(part_devt(part)), MINOR(part_devt(part)), 1200 (unsigned long long)part_nr_sects_read(part) >> 1, 1201 disk_name(sgp, part->partno, buf)); 1202 disk_part_iter_exit(&piter); 1203 1204 return 0; 1205} 1206 1207static const struct seq_operations partitions_op = { 1208 .start = show_partition_start, 1209 .next = disk_seqf_next, 1210 .stop = disk_seqf_stop, 1211 .show = show_partition 1212}; 1213#endif 1214 1215 1216static struct kobject *base_probe(dev_t devt, int *partno, void *data) 1217{ 1218 if (request_module("block-major-%d-%d", MAJOR(devt), MINOR(devt)) > 0) 1219 /* Make old-style 2.4 aliases work */ 1220 request_module("block-major-%d", MAJOR(devt)); 1221 return NULL; 1222} 1223 1224static int __init genhd_device_init(void) 1225{ 1226 int error; 1227 1228 block_class.dev_kobj = sysfs_dev_block_kobj; 1229 error = class_register(&block_class); 1230 if (unlikely(error)) 1231 return error; 1232 bdev_map = kobj_map_init(base_probe, &block_class_lock); 1233 blk_dev_init(); 1234 1235 register_blkdev(BLOCK_EXT_MAJOR, "blkext"); 1236 1237 /* create top-level block dir */ 1238 if (!sysfs_deprecated) 1239 block_depr = kobject_create_and_add("block", NULL); 1240 return 0; 1241} 1242 1243subsys_initcall(genhd_device_init); 1244 1245static ssize_t disk_range_show(struct device *dev, 1246 struct device_attribute *attr, char *buf) 1247{ 1248 struct gendisk *disk = dev_to_disk(dev); 1249 1250 return sprintf(buf, "%d\n", disk->minors); 1251} 1252 1253static ssize_t disk_ext_range_show(struct device *dev, 1254 struct device_attribute *attr, char *buf) 1255{ 1256 struct gendisk *disk = dev_to_disk(dev); 1257 1258 return sprintf(buf, "%d\n", disk_max_parts(disk)); 1259} 1260 1261static ssize_t disk_removable_show(struct device *dev, 1262 struct device_attribute *attr, char *buf) 1263{ 1264 struct gendisk *disk = dev_to_disk(dev); 1265 1266 return sprintf(buf, "%d\n", 1267 (disk->flags & GENHD_FL_REMOVABLE ? 1 : 0)); 1268} 1269 1270static ssize_t disk_hidden_show(struct device *dev, 1271 struct device_attribute *attr, char *buf) 1272{ 1273 struct gendisk *disk = dev_to_disk(dev); 1274 1275 return sprintf(buf, "%d\n", 1276 (disk->flags & GENHD_FL_HIDDEN ? 1 : 0)); 1277} 1278 1279static ssize_t disk_ro_show(struct device *dev, 1280 struct device_attribute *attr, char *buf) 1281{ 1282 struct gendisk *disk = dev_to_disk(dev); 1283 1284 return sprintf(buf, "%d\n", get_disk_ro(disk) ? 1 : 0); 1285} 1286 1287ssize_t part_size_show(struct device *dev, 1288 struct device_attribute *attr, char *buf) 1289{ 1290 struct hd_struct *p = dev_to_part(dev); 1291 1292 return sprintf(buf, "%llu\n", 1293 (unsigned long long)part_nr_sects_read(p)); 1294} 1295 1296ssize_t part_stat_show(struct device *dev, 1297 struct device_attribute *attr, char *buf) 1298{ 1299 struct hd_struct *p = dev_to_part(dev); 1300 struct request_queue *q = part_to_disk(p)->queue; 1301 struct disk_stats stat; 1302 unsigned int inflight; 1303 1304 part_stat_read_all(p, &stat); 1305 if (queue_is_mq(q)) 1306 inflight = blk_mq_in_flight(q, p); 1307 else 1308 inflight = part_in_flight(p); 1309 1310 return sprintf(buf, 1311 "%8lu %8lu %8llu %8u " 1312 "%8lu %8lu %8llu %8u " 1313 "%8u %8u %8u " 1314 "%8lu %8lu %8llu %8u " 1315 "%8lu %8u" 1316 "\n", 1317 stat.ios[STAT_READ], 1318 stat.merges[STAT_READ], 1319 (unsigned long long)stat.sectors[STAT_READ], 1320 (unsigned int)div_u64(stat.nsecs[STAT_READ], NSEC_PER_MSEC), 1321 stat.ios[STAT_WRITE], 1322 stat.merges[STAT_WRITE], 1323 (unsigned long long)stat.sectors[STAT_WRITE], 1324 (unsigned int)div_u64(stat.nsecs[STAT_WRITE], NSEC_PER_MSEC), 1325 inflight, 1326 jiffies_to_msecs(stat.io_ticks), 1327 (unsigned int)div_u64(stat.nsecs[STAT_READ] + 1328 stat.nsecs[STAT_WRITE] + 1329 stat.nsecs[STAT_DISCARD] + 1330 stat.nsecs[STAT_FLUSH], 1331 NSEC_PER_MSEC), 1332 stat.ios[STAT_DISCARD], 1333 stat.merges[STAT_DISCARD], 1334 (unsigned long long)stat.sectors[STAT_DISCARD], 1335 (unsigned int)div_u64(stat.nsecs[STAT_DISCARD], NSEC_PER_MSEC), 1336 stat.ios[STAT_FLUSH], 1337 (unsigned int)div_u64(stat.nsecs[STAT_FLUSH], NSEC_PER_MSEC)); 1338} 1339 1340ssize_t part_inflight_show(struct device *dev, struct device_attribute *attr, 1341 char *buf) 1342{ 1343 struct hd_struct *p = dev_to_part(dev); 1344 struct request_queue *q = part_to_disk(p)->queue; 1345 unsigned int inflight[2]; 1346 1347 if (queue_is_mq(q)) 1348 blk_mq_in_flight_rw(q, p, inflight); 1349 else 1350 part_in_flight_rw(p, inflight); 1351 1352 return sprintf(buf, "%8u %8u\n", inflight[0], inflight[1]); 1353} 1354 1355static ssize_t disk_capability_show(struct device *dev, 1356 struct device_attribute *attr, char *buf) 1357{ 1358 struct gendisk *disk = dev_to_disk(dev); 1359 1360 return sprintf(buf, "%x\n", disk->flags); 1361} 1362 1363static ssize_t disk_alignment_offset_show(struct device *dev, 1364 struct device_attribute *attr, 1365 char *buf) 1366{ 1367 struct gendisk *disk = dev_to_disk(dev); 1368 1369 return sprintf(buf, "%d\n", queue_alignment_offset(disk->queue)); 1370} 1371 1372static ssize_t disk_discard_alignment_show(struct device *dev, 1373 struct device_attribute *attr, 1374 char *buf) 1375{ 1376 struct gendisk *disk = dev_to_disk(dev); 1377 1378 return sprintf(buf, "%d\n", queue_discard_alignment(disk->queue)); 1379} 1380 1381static DEVICE_ATTR(range, 0444, disk_range_show, NULL); 1382static DEVICE_ATTR(ext_range, 0444, disk_ext_range_show, NULL); 1383static DEVICE_ATTR(removable, 0444, disk_removable_show, NULL); 1384static DEVICE_ATTR(hidden, 0444, disk_hidden_show, NULL); 1385static DEVICE_ATTR(ro, 0444, disk_ro_show, NULL); 1386static DEVICE_ATTR(size, 0444, part_size_show, NULL); 1387static DEVICE_ATTR(alignment_offset, 0444, disk_alignment_offset_show, NULL); 1388static DEVICE_ATTR(discard_alignment, 0444, disk_discard_alignment_show, NULL); 1389static DEVICE_ATTR(capability, 0444, disk_capability_show, NULL); 1390static DEVICE_ATTR(stat, 0444, part_stat_show, NULL); 1391static DEVICE_ATTR(inflight, 0444, part_inflight_show, NULL); 1392static DEVICE_ATTR(badblocks, 0644, disk_badblocks_show, disk_badblocks_store); 1393 1394#ifdef CONFIG_FAIL_MAKE_REQUEST 1395ssize_t part_fail_show(struct device *dev, 1396 struct device_attribute *attr, char *buf) 1397{ 1398 struct hd_struct *p = dev_to_part(dev); 1399 1400 return sprintf(buf, "%d\n", p->make_it_fail); 1401} 1402 1403ssize_t part_fail_store(struct device *dev, 1404 struct device_attribute *attr, 1405 const char *buf, size_t count) 1406{ 1407 struct hd_struct *p = dev_to_part(dev); 1408 int i; 1409 1410 if (count > 0 && sscanf(buf, "%d", &i) > 0) 1411 p->make_it_fail = (i == 0) ? 0 : 1; 1412 1413 return count; 1414} 1415 1416static struct device_attribute dev_attr_fail = 1417 __ATTR(make-it-fail, 0644, part_fail_show, part_fail_store); 1418#endif /* CONFIG_FAIL_MAKE_REQUEST */ 1419 1420#ifdef CONFIG_FAIL_IO_TIMEOUT 1421static struct device_attribute dev_attr_fail_timeout = 1422 __ATTR(io-timeout-fail, 0644, part_timeout_show, part_timeout_store); 1423#endif 1424 1425static struct attribute *disk_attrs[] = { 1426 &dev_attr_range.attr, 1427 &dev_attr_ext_range.attr, 1428 &dev_attr_removable.attr, 1429 &dev_attr_hidden.attr, 1430 &dev_attr_ro.attr, 1431 &dev_attr_size.attr, 1432 &dev_attr_alignment_offset.attr, 1433 &dev_attr_discard_alignment.attr, 1434 &dev_attr_capability.attr, 1435 &dev_attr_stat.attr, 1436 &dev_attr_inflight.attr, 1437 &dev_attr_badblocks.attr, 1438#ifdef CONFIG_FAIL_MAKE_REQUEST 1439 &dev_attr_fail.attr, 1440#endif 1441#ifdef CONFIG_FAIL_IO_TIMEOUT 1442 &dev_attr_fail_timeout.attr, 1443#endif 1444 NULL 1445}; 1446 1447static umode_t disk_visible(struct kobject *kobj, struct attribute *a, int n) 1448{ 1449 struct device *dev = container_of(kobj, typeof(*dev), kobj); 1450 struct gendisk *disk = dev_to_disk(dev); 1451 1452 if (a == &dev_attr_badblocks.attr && !disk->bb) 1453 return 0; 1454 return a->mode; 1455} 1456 1457static struct attribute_group disk_attr_group = { 1458 .attrs = disk_attrs, 1459 .is_visible = disk_visible, 1460}; 1461 1462static const struct attribute_group *disk_attr_groups[] = { 1463 &disk_attr_group, 1464 NULL 1465}; 1466 1467/** 1468 * disk_replace_part_tbl - replace disk->part_tbl in RCU-safe way 1469 * @disk: disk to replace part_tbl for 1470 * @new_ptbl: new part_tbl to install 1471 * 1472 * Replace disk->part_tbl with @new_ptbl in RCU-safe way. The 1473 * original ptbl is freed using RCU callback. 1474 * 1475 * LOCKING: 1476 * Matching bd_mutex locked or the caller is the only user of @disk. 1477 */ 1478static void disk_replace_part_tbl(struct gendisk *disk, 1479 struct disk_part_tbl *new_ptbl) 1480{ 1481 struct disk_part_tbl *old_ptbl = 1482 rcu_dereference_protected(disk->part_tbl, 1); 1483 1484 rcu_assign_pointer(disk->part_tbl, new_ptbl); 1485 1486 if (old_ptbl) { 1487 rcu_assign_pointer(old_ptbl->last_lookup, NULL); 1488 kfree_rcu(old_ptbl, rcu_head); 1489 } 1490} 1491 1492/** 1493 * disk_expand_part_tbl - expand disk->part_tbl 1494 * @disk: disk to expand part_tbl for 1495 * @partno: expand such that this partno can fit in 1496 * 1497 * Expand disk->part_tbl such that @partno can fit in. disk->part_tbl 1498 * uses RCU to allow unlocked dereferencing for stats and other stuff. 1499 * 1500 * LOCKING: 1501 * Matching bd_mutex locked or the caller is the only user of @disk. 1502 * Might sleep. 1503 * 1504 * RETURNS: 1505 * 0 on success, -errno on failure. 1506 */ 1507int disk_expand_part_tbl(struct gendisk *disk, int partno) 1508{ 1509 struct disk_part_tbl *old_ptbl = 1510 rcu_dereference_protected(disk->part_tbl, 1); 1511 struct disk_part_tbl *new_ptbl; 1512 int len = old_ptbl ? old_ptbl->len : 0; 1513 int i, target; 1514 1515 /* 1516 * check for int overflow, since we can get here from blkpg_ioctl() 1517 * with a user passed 'partno'. 1518 */ 1519 target = partno + 1; 1520 if (target < 0) 1521 return -EINVAL; 1522 1523 /* disk_max_parts() is zero during initialization, ignore if so */ 1524 if (disk_max_parts(disk) && target > disk_max_parts(disk)) 1525 return -EINVAL; 1526 1527 if (target <= len) 1528 return 0; 1529 1530 new_ptbl = kzalloc_node(struct_size(new_ptbl, part, target), GFP_KERNEL, 1531 disk->node_id); 1532 if (!new_ptbl) 1533 return -ENOMEM; 1534 1535 new_ptbl->len = target; 1536 1537 for (i = 0; i < len; i++) 1538 rcu_assign_pointer(new_ptbl->part[i], old_ptbl->part[i]); 1539 1540 disk_replace_part_tbl(disk, new_ptbl); 1541 return 0; 1542} 1543 1544/** 1545 * disk_release - releases all allocated resources of the gendisk 1546 * @dev: the device representing this disk 1547 * 1548 * This function releases all allocated resources of the gendisk. 1549 * 1550 * The struct gendisk refcount is incremented with get_gendisk() or 1551 * get_disk_and_module(), and its refcount is decremented with 1552 * put_disk_and_module() or put_disk(). Once the refcount reaches 0 this 1553 * function is called. 1554 * 1555 * Drivers which used __device_add_disk() have a gendisk with a request_queue 1556 * assigned. Since the request_queue sits on top of the gendisk for these 1557 * drivers we also call blk_put_queue() for them, and we expect the 1558 * request_queue refcount to reach 0 at this point, and so the request_queue 1559 * will also be freed prior to the disk. 1560 * 1561 * Context: can sleep 1562 */ 1563static void disk_release(struct device *dev) 1564{ 1565 struct gendisk *disk = dev_to_disk(dev); 1566 1567 might_sleep(); 1568 blk_mq_cancel_work_sync(disk->queue); 1569 1570 blk_free_devt(dev->devt); 1571 disk_release_events(disk); 1572 kfree(disk->random); 1573 disk_replace_part_tbl(disk, NULL); 1574 hd_free_part(&disk->part0); 1575 if (disk->queue) 1576 blk_put_queue(disk->queue); 1577 kfree(disk); 1578} 1579struct class block_class = { 1580 .name = "block", 1581}; 1582 1583static char *block_devnode(struct device *dev, umode_t *mode, 1584 kuid_t *uid, kgid_t *gid) 1585{ 1586 struct gendisk *disk = dev_to_disk(dev); 1587 1588 if (disk->fops->devnode) 1589 return disk->fops->devnode(disk, mode); 1590 return NULL; 1591} 1592 1593const struct device_type disk_type = { 1594 .name = "disk", 1595 .groups = disk_attr_groups, 1596 .release = disk_release, 1597 .devnode = block_devnode, 1598}; 1599 1600#ifdef CONFIG_PROC_FS 1601/* 1602 * aggregate disk stat collector. Uses the same stats that the sysfs 1603 * entries do, above, but makes them available through one seq_file. 1604 * 1605 * The output looks suspiciously like /proc/partitions with a bunch of 1606 * extra fields. 1607 */ 1608static int diskstats_show(struct seq_file *seqf, void *v) 1609{ 1610 struct gendisk *gp = v; 1611 struct disk_part_iter piter; 1612 struct hd_struct *hd; 1613 char buf[BDEVNAME_SIZE]; 1614 unsigned int inflight; 1615 struct disk_stats stat; 1616 1617 /* 1618 if (&disk_to_dev(gp)->kobj.entry == block_class.devices.next) 1619 seq_puts(seqf, "major minor name" 1620 " rio rmerge rsect ruse wio wmerge " 1621 "wsect wuse running use aveq" 1622 "\n\n"); 1623 */ 1624 1625 disk_part_iter_init(&piter, gp, DISK_PITER_INCL_EMPTY_PART0); 1626 while ((hd = disk_part_iter_next(&piter))) { 1627 part_stat_read_all(hd, &stat); 1628 if (queue_is_mq(gp->queue)) 1629 inflight = blk_mq_in_flight(gp->queue, hd); 1630 else 1631 inflight = part_in_flight(hd); 1632 1633 seq_printf(seqf, "%4d %7d %s " 1634 "%lu %lu %lu %u " 1635 "%lu %lu %lu %u " 1636 "%u %u %u " 1637 "%lu %lu %lu %u " 1638 "%lu %u" 1639 "\n", 1640 MAJOR(part_devt(hd)), MINOR(part_devt(hd)), 1641 disk_name(gp, hd->partno, buf), 1642 stat.ios[STAT_READ], 1643 stat.merges[STAT_READ], 1644 stat.sectors[STAT_READ], 1645 (unsigned int)div_u64(stat.nsecs[STAT_READ], 1646 NSEC_PER_MSEC), 1647 stat.ios[STAT_WRITE], 1648 stat.merges[STAT_WRITE], 1649 stat.sectors[STAT_WRITE], 1650 (unsigned int)div_u64(stat.nsecs[STAT_WRITE], 1651 NSEC_PER_MSEC), 1652 inflight, 1653 jiffies_to_msecs(stat.io_ticks), 1654 (unsigned int)div_u64(stat.nsecs[STAT_READ] + 1655 stat.nsecs[STAT_WRITE] + 1656 stat.nsecs[STAT_DISCARD] + 1657 stat.nsecs[STAT_FLUSH], 1658 NSEC_PER_MSEC), 1659 stat.ios[STAT_DISCARD], 1660 stat.merges[STAT_DISCARD], 1661 stat.sectors[STAT_DISCARD], 1662 (unsigned int)div_u64(stat.nsecs[STAT_DISCARD], 1663 NSEC_PER_MSEC), 1664 stat.ios[STAT_FLUSH], 1665 (unsigned int)div_u64(stat.nsecs[STAT_FLUSH], 1666 NSEC_PER_MSEC) 1667 ); 1668 } 1669 disk_part_iter_exit(&piter); 1670 1671 return 0; 1672} 1673 1674static const struct seq_operations diskstats_op = { 1675 .start = disk_seqf_start, 1676 .next = disk_seqf_next, 1677 .stop = disk_seqf_stop, 1678 .show = diskstats_show 1679}; 1680 1681static int __init proc_genhd_init(void) 1682{ 1683 proc_create_seq("diskstats", 0, NULL, &diskstats_op); 1684 proc_create_seq("partitions", 0, NULL, &partitions_op); 1685 return 0; 1686} 1687module_init(proc_genhd_init); 1688#endif /* CONFIG_PROC_FS */ 1689 1690dev_t blk_lookup_devt(const char *name, int partno) 1691{ 1692 dev_t devt = MKDEV(0, 0); 1693 struct class_dev_iter iter; 1694 struct device *dev; 1695 1696 class_dev_iter_init(&iter, &block_class, NULL, &disk_type); 1697 while ((dev = class_dev_iter_next(&iter))) { 1698 struct gendisk *disk = dev_to_disk(dev); 1699 struct hd_struct *part; 1700 1701 if (strcmp(dev_name(dev), name)) 1702 continue; 1703 1704 if (partno < disk->minors) { 1705 /* We need to return the right devno, even 1706 * if the partition doesn't exist yet. 1707 */ 1708 devt = MKDEV(MAJOR(dev->devt), 1709 MINOR(dev->devt) + partno); 1710 break; 1711 } 1712 part = disk_get_part(disk, partno); 1713 if (part) { 1714 devt = part_devt(part); 1715 disk_put_part(part); 1716 break; 1717 } 1718 disk_put_part(part); 1719 } 1720 class_dev_iter_exit(&iter); 1721 return devt; 1722} 1723 1724struct gendisk *__alloc_disk_node(int minors, int node_id) 1725{ 1726 struct gendisk *disk; 1727 struct disk_part_tbl *ptbl; 1728 1729 if (minors > DISK_MAX_PARTS) { 1730 printk(KERN_ERR 1731 "block: can't allocate more than %d partitions\n", 1732 DISK_MAX_PARTS); 1733 minors = DISK_MAX_PARTS; 1734 } 1735 1736 disk = kzalloc_node(sizeof(struct gendisk), GFP_KERNEL, node_id); 1737 if (!disk) 1738 return NULL; 1739 1740 disk->part0.dkstats = alloc_percpu(struct disk_stats); 1741 if (!disk->part0.dkstats) 1742 goto out_free_disk; 1743 1744 init_rwsem(&disk->lookup_sem); 1745 disk->node_id = node_id; 1746 if (disk_expand_part_tbl(disk, 0)) { 1747 free_percpu(disk->part0.dkstats); 1748 goto out_free_disk; 1749 } 1750 1751 ptbl = rcu_dereference_protected(disk->part_tbl, 1); 1752 rcu_assign_pointer(ptbl->part[0], &disk->part0); 1753 1754 /* 1755 * set_capacity() and get_capacity() currently don't use 1756 * seqcounter to read/update the part0->nr_sects. Still init 1757 * the counter as we can read the sectors in IO submission 1758 * patch using seqence counters. 1759 * 1760 * TODO: Ideally set_capacity() and get_capacity() should be 1761 * converted to make use of bd_mutex and sequence counters. 1762 */ 1763 hd_sects_seq_init(&disk->part0); 1764 if (hd_ref_init(&disk->part0)) 1765 goto out_free_part0; 1766 1767 disk->minors = minors; 1768 rand_initialize_disk(disk); 1769 disk_to_dev(disk)->class = &block_class; 1770 disk_to_dev(disk)->type = &disk_type; 1771 device_initialize(disk_to_dev(disk)); 1772 return disk; 1773 1774out_free_part0: 1775 hd_free_part(&disk->part0); 1776out_free_disk: 1777 kfree(disk); 1778 return NULL; 1779} 1780EXPORT_SYMBOL(__alloc_disk_node); 1781 1782/** 1783 * get_disk_and_module - increments the gendisk and gendisk fops module refcount 1784 * @disk: the struct gendisk to increment the refcount for 1785 * 1786 * This increments the refcount for the struct gendisk, and the gendisk's 1787 * fops module owner. 1788 * 1789 * Context: Any context. 1790 */ 1791struct kobject *get_disk_and_module(struct gendisk *disk) 1792{ 1793 struct module *owner; 1794 struct kobject *kobj; 1795 1796 if (!disk->fops) 1797 return NULL; 1798 owner = disk->fops->owner; 1799 if (owner && !try_module_get(owner)) 1800 return NULL; 1801 kobj = kobject_get_unless_zero(&disk_to_dev(disk)->kobj); 1802 if (kobj == NULL) { 1803 module_put(owner); 1804 return NULL; 1805 } 1806 return kobj; 1807 1808} 1809EXPORT_SYMBOL(get_disk_and_module); 1810 1811/** 1812 * put_disk - decrements the gendisk refcount 1813 * @disk: the struct gendisk to decrement the refcount for 1814 * 1815 * This decrements the refcount for the struct gendisk. When this reaches 0 1816 * we'll have disk_release() called. 1817 * 1818 * Context: Any context, but the last reference must not be dropped from 1819 * atomic context. 1820 */ 1821void put_disk(struct gendisk *disk) 1822{ 1823 if (disk) 1824 kobject_put(&disk_to_dev(disk)->kobj); 1825} 1826EXPORT_SYMBOL(put_disk); 1827 1828/** 1829 * put_disk_and_module - decrements the module and gendisk refcount 1830 * @disk: the struct gendisk to decrement the refcount for 1831 * 1832 * This is a counterpart of get_disk_and_module() and thus also of 1833 * get_gendisk(). 1834 * 1835 * Context: Any context, but the last reference must not be dropped from 1836 * atomic context. 1837 */ 1838void put_disk_and_module(struct gendisk *disk) 1839{ 1840 if (disk) { 1841 struct module *owner = disk->fops->owner; 1842 1843 put_disk(disk); 1844 module_put(owner); 1845 } 1846} 1847EXPORT_SYMBOL(put_disk_and_module); 1848 1849static void set_disk_ro_uevent(struct gendisk *gd, int ro) 1850{ 1851 char event[] = "DISK_RO=1"; 1852 char *envp[] = { event, NULL }; 1853 1854 if (!ro) 1855 event[8] = '0'; 1856 kobject_uevent_env(&disk_to_dev(gd)->kobj, KOBJ_CHANGE, envp); 1857} 1858 1859void set_device_ro(struct block_device *bdev, int flag) 1860{ 1861 bdev->bd_part->policy = flag; 1862} 1863 1864EXPORT_SYMBOL(set_device_ro); 1865 1866void set_disk_ro(struct gendisk *disk, int flag) 1867{ 1868 struct disk_part_iter piter; 1869 struct hd_struct *part; 1870 1871 if (disk->part0.policy != flag) { 1872 set_disk_ro_uevent(disk, flag); 1873 disk->part0.policy = flag; 1874 } 1875 1876 disk_part_iter_init(&piter, disk, DISK_PITER_INCL_EMPTY); 1877 while ((part = disk_part_iter_next(&piter))) 1878 part->policy = flag; 1879 disk_part_iter_exit(&piter); 1880} 1881 1882EXPORT_SYMBOL(set_disk_ro); 1883 1884int bdev_read_only(struct block_device *bdev) 1885{ 1886 if (!bdev) 1887 return 0; 1888 return bdev->bd_part->policy; 1889} 1890 1891EXPORT_SYMBOL(bdev_read_only); 1892 1893/* 1894 * Disk events - monitor disk events like media change and eject request. 1895 */ 1896struct disk_events { 1897 struct list_head node; /* all disk_event's */ 1898 struct gendisk *disk; /* the associated disk */ 1899 spinlock_t lock; 1900 1901 struct mutex block_mutex; /* protects blocking */ 1902 int block; /* event blocking depth */ 1903 unsigned int pending; /* events already sent out */ 1904 unsigned int clearing; /* events being cleared */ 1905 1906 long poll_msecs; /* interval, -1 for default */ 1907 struct delayed_work dwork; 1908}; 1909 1910static const char *disk_events_strs[] = { 1911 [ilog2(DISK_EVENT_MEDIA_CHANGE)] = "media_change", 1912 [ilog2(DISK_EVENT_EJECT_REQUEST)] = "eject_request", 1913}; 1914 1915static char *disk_uevents[] = { 1916 [ilog2(DISK_EVENT_MEDIA_CHANGE)] = "DISK_MEDIA_CHANGE=1", 1917 [ilog2(DISK_EVENT_EJECT_REQUEST)] = "DISK_EJECT_REQUEST=1", 1918}; 1919 1920/* list of all disk_events */ 1921static DEFINE_MUTEX(disk_events_mutex); 1922static LIST_HEAD(disk_events); 1923 1924/* disable in-kernel polling by default */ 1925static unsigned long disk_events_dfl_poll_msecs; 1926 1927static unsigned long disk_events_poll_jiffies(struct gendisk *disk) 1928{ 1929 struct disk_events *ev = disk->ev; 1930 long intv_msecs = 0; 1931 1932 /* 1933 * If device-specific poll interval is set, always use it. If 1934 * the default is being used, poll if the POLL flag is set. 1935 */ 1936 if (ev->poll_msecs >= 0) 1937 intv_msecs = ev->poll_msecs; 1938 else if (disk->event_flags & DISK_EVENT_FLAG_POLL) 1939 intv_msecs = disk_events_dfl_poll_msecs; 1940 1941 return msecs_to_jiffies(intv_msecs); 1942} 1943 1944/** 1945 * disk_block_events - block and flush disk event checking 1946 * @disk: disk to block events for 1947 * 1948 * On return from this function, it is guaranteed that event checking 1949 * isn't in progress and won't happen until unblocked by 1950 * disk_unblock_events(). Events blocking is counted and the actual 1951 * unblocking happens after the matching number of unblocks are done. 1952 * 1953 * Note that this intentionally does not block event checking from 1954 * disk_clear_events(). 1955 * 1956 * CONTEXT: 1957 * Might sleep. 1958 */ 1959void disk_block_events(struct gendisk *disk) 1960{ 1961 struct disk_events *ev = disk->ev; 1962 unsigned long flags; 1963 bool cancel; 1964 1965 if (!ev) 1966 return; 1967 1968 /* 1969 * Outer mutex ensures that the first blocker completes canceling 1970 * the event work before further blockers are allowed to finish. 1971 */ 1972 mutex_lock(&ev->block_mutex); 1973 1974 spin_lock_irqsave(&ev->lock, flags); 1975 cancel = !ev->block++; 1976 spin_unlock_irqrestore(&ev->lock, flags); 1977 1978 if (cancel) 1979 cancel_delayed_work_sync(&disk->ev->dwork); 1980 1981 mutex_unlock(&ev->block_mutex); 1982} 1983 1984static void __disk_unblock_events(struct gendisk *disk, bool check_now) 1985{ 1986 struct disk_events *ev = disk->ev; 1987 unsigned long intv; 1988 unsigned long flags; 1989 1990 spin_lock_irqsave(&ev->lock, flags); 1991 1992 if (WARN_ON_ONCE(ev->block <= 0)) 1993 goto out_unlock; 1994 1995 if (--ev->block) 1996 goto out_unlock; 1997 1998 intv = disk_events_poll_jiffies(disk); 1999 if (check_now) 2000 queue_delayed_work(system_freezable_power_efficient_wq, 2001 &ev->dwork, 0); 2002 else if (intv) 2003 queue_delayed_work(system_freezable_power_efficient_wq, 2004 &ev->dwork, intv); 2005out_unlock: 2006 spin_unlock_irqrestore(&ev->lock, flags); 2007} 2008 2009/** 2010 * disk_unblock_events - unblock disk event checking 2011 * @disk: disk to unblock events for 2012 * 2013 * Undo disk_block_events(). When the block count reaches zero, it 2014 * starts events polling if configured. 2015 * 2016 * CONTEXT: 2017 * Don't care. Safe to call from irq context. 2018 */ 2019void disk_unblock_events(struct gendisk *disk) 2020{ 2021 if (disk->ev) 2022 __disk_unblock_events(disk, false); 2023} 2024 2025/** 2026 * disk_flush_events - schedule immediate event checking and flushing 2027 * @disk: disk to check and flush events for 2028 * @mask: events to flush 2029 * 2030 * Schedule immediate event checking on @disk if not blocked. Events in 2031 * @mask are scheduled to be cleared from the driver. Note that this 2032 * doesn't clear the events from @disk->ev. 2033 * 2034 * CONTEXT: 2035 * If @mask is non-zero must be called with bdev->bd_mutex held. 2036 */ 2037void disk_flush_events(struct gendisk *disk, unsigned int mask) 2038{ 2039 struct disk_events *ev = disk->ev; 2040 2041 if (!ev) 2042 return; 2043 2044 spin_lock_irq(&ev->lock); 2045 ev->clearing |= mask; 2046 if (!ev->block) 2047 mod_delayed_work(system_freezable_power_efficient_wq, 2048 &ev->dwork, 0); 2049 spin_unlock_irq(&ev->lock); 2050} 2051 2052/** 2053 * disk_clear_events - synchronously check, clear and return pending events 2054 * @disk: disk to fetch and clear events from 2055 * @mask: mask of events to be fetched and cleared 2056 * 2057 * Disk events are synchronously checked and pending events in @mask 2058 * are cleared and returned. This ignores the block count. 2059 * 2060 * CONTEXT: 2061 * Might sleep. 2062 */ 2063static unsigned int disk_clear_events(struct gendisk *disk, unsigned int mask) 2064{ 2065 struct disk_events *ev = disk->ev; 2066 unsigned int pending; 2067 unsigned int clearing = mask; 2068 2069 if (!ev) 2070 return 0; 2071 2072 disk_block_events(disk); 2073 2074 /* 2075 * store the union of mask and ev->clearing on the stack so that the 2076 * race with disk_flush_events does not cause ambiguity (ev->clearing 2077 * can still be modified even if events are blocked). 2078 */ 2079 spin_lock_irq(&ev->lock); 2080 clearing |= ev->clearing; 2081 ev->clearing = 0; 2082 spin_unlock_irq(&ev->lock); 2083 2084 disk_check_events(ev, &clearing); 2085 /* 2086 * if ev->clearing is not 0, the disk_flush_events got called in the 2087 * middle of this function, so we want to run the workfn without delay. 2088 */ 2089 __disk_unblock_events(disk, ev->clearing ? true : false); 2090 2091 /* then, fetch and clear pending events */ 2092 spin_lock_irq(&ev->lock); 2093 pending = ev->pending & mask; 2094 ev->pending &= ~mask; 2095 spin_unlock_irq(&ev->lock); 2096 WARN_ON_ONCE(clearing & mask); 2097 2098 return pending; 2099} 2100 2101/** 2102 * bdev_check_media_change - check if a removable media has been changed 2103 * @bdev: block device to check 2104 * 2105 * Check whether a removable media has been changed, and attempt to free all 2106 * dentries and inodes and invalidates all block device page cache entries in 2107 * that case. 2108 * 2109 * Returns %true if the block device changed, or %false if not. 2110 */ 2111bool bdev_check_media_change(struct block_device *bdev) 2112{ 2113 unsigned int events; 2114 2115 events = disk_clear_events(bdev->bd_disk, DISK_EVENT_MEDIA_CHANGE | 2116 DISK_EVENT_EJECT_REQUEST); 2117 if (!(events & DISK_EVENT_MEDIA_CHANGE)) 2118 return false; 2119 2120 if (__invalidate_device(bdev, true)) 2121 pr_warn("VFS: busy inodes on changed media %s\n", 2122 bdev->bd_disk->disk_name); 2123 set_bit(GD_NEED_PART_SCAN, &bdev->bd_disk->state); 2124 return true; 2125} 2126EXPORT_SYMBOL(bdev_check_media_change); 2127 2128/* 2129 * Separate this part out so that a different pointer for clearing_ptr can be 2130 * passed in for disk_clear_events. 2131 */ 2132static void disk_events_workfn(struct work_struct *work) 2133{ 2134 struct delayed_work *dwork = to_delayed_work(work); 2135 struct disk_events *ev = container_of(dwork, struct disk_events, dwork); 2136 2137 disk_check_events(ev, &ev->clearing); 2138} 2139 2140static void disk_check_events(struct disk_events *ev, 2141 unsigned int *clearing_ptr) 2142{ 2143 struct gendisk *disk = ev->disk; 2144 char *envp[ARRAY_SIZE(disk_uevents) + 1] = { }; 2145 unsigned int clearing = *clearing_ptr; 2146 unsigned int events; 2147 unsigned long intv; 2148 int nr_events = 0, i; 2149 2150 /* check events */ 2151 events = disk->fops->check_events(disk, clearing); 2152 2153 /* accumulate pending events and schedule next poll if necessary */ 2154 spin_lock_irq(&ev->lock); 2155 2156 events &= ~ev->pending; 2157 ev->pending |= events; 2158 *clearing_ptr &= ~clearing; 2159 2160 intv = disk_events_poll_jiffies(disk); 2161 if (!ev->block && intv) 2162 queue_delayed_work(system_freezable_power_efficient_wq, 2163 &ev->dwork, intv); 2164 2165 spin_unlock_irq(&ev->lock); 2166 2167 /* 2168 * Tell userland about new events. Only the events listed in 2169 * @disk->events are reported, and only if DISK_EVENT_FLAG_UEVENT 2170 * is set. Otherwise, events are processed internally but never 2171 * get reported to userland. 2172 */ 2173 for (i = 0; i < ARRAY_SIZE(disk_uevents); i++) 2174 if ((events & disk->events & (1 << i)) && 2175 (disk->event_flags & DISK_EVENT_FLAG_UEVENT)) 2176 envp[nr_events++] = disk_uevents[i]; 2177 2178 if (nr_events) 2179 kobject_uevent_env(&disk_to_dev(disk)->kobj, KOBJ_CHANGE, envp); 2180} 2181 2182/* 2183 * A disk events enabled device has the following sysfs nodes under 2184 * its /sys/block/X/ directory. 2185 * 2186 * events : list of all supported events 2187 * events_async : list of events which can be detected w/o polling 2188 * (always empty, only for backwards compatibility) 2189 * events_poll_msecs : polling interval, 0: disable, -1: system default 2190 */ 2191static ssize_t __disk_events_show(unsigned int events, char *buf) 2192{ 2193 const char *delim = ""; 2194 ssize_t pos = 0; 2195 int i; 2196 2197 for (i = 0; i < ARRAY_SIZE(disk_events_strs); i++) 2198 if (events & (1 << i)) { 2199 pos += sprintf(buf + pos, "%s%s", 2200 delim, disk_events_strs[i]); 2201 delim = " "; 2202 } 2203 if (pos) 2204 pos += sprintf(buf + pos, "\n"); 2205 return pos; 2206} 2207 2208static ssize_t disk_events_show(struct device *dev, 2209 struct device_attribute *attr, char *buf) 2210{ 2211 struct gendisk *disk = dev_to_disk(dev); 2212 2213 if (!(disk->event_flags & DISK_EVENT_FLAG_UEVENT)) 2214 return 0; 2215 2216 return __disk_events_show(disk->events, buf); 2217} 2218 2219static ssize_t disk_events_async_show(struct device *dev, 2220 struct device_attribute *attr, char *buf) 2221{ 2222 return 0; 2223} 2224 2225static ssize_t disk_events_poll_msecs_show(struct device *dev, 2226 struct device_attribute *attr, 2227 char *buf) 2228{ 2229 struct gendisk *disk = dev_to_disk(dev); 2230 2231 if (!disk->ev) 2232 return sprintf(buf, "-1\n"); 2233 2234 return sprintf(buf, "%ld\n", disk->ev->poll_msecs); 2235} 2236 2237static ssize_t disk_events_poll_msecs_store(struct device *dev, 2238 struct device_attribute *attr, 2239 const char *buf, size_t count) 2240{ 2241 struct gendisk *disk = dev_to_disk(dev); 2242 long intv; 2243 2244 if (!count || !sscanf(buf, "%ld", &intv)) 2245 return -EINVAL; 2246 2247 if (intv < 0 && intv != -1) 2248 return -EINVAL; 2249 2250 if (!disk->ev) 2251 return -ENODEV; 2252 2253 disk_block_events(disk); 2254 disk->ev->poll_msecs = intv; 2255 __disk_unblock_events(disk, true); 2256 2257 return count; 2258} 2259 2260static const DEVICE_ATTR(events, 0444, disk_events_show, NULL); 2261static const DEVICE_ATTR(events_async, 0444, disk_events_async_show, NULL); 2262static const DEVICE_ATTR(events_poll_msecs, 0644, 2263 disk_events_poll_msecs_show, 2264 disk_events_poll_msecs_store); 2265 2266static const struct attribute *disk_events_attrs[] = { 2267 &dev_attr_events.attr, 2268 &dev_attr_events_async.attr, 2269 &dev_attr_events_poll_msecs.attr, 2270 NULL, 2271}; 2272 2273/* 2274 * The default polling interval can be specified by the kernel 2275 * parameter block.events_dfl_poll_msecs which defaults to 0 2276 * (disable). This can also be modified runtime by writing to 2277 * /sys/module/block/parameters/events_dfl_poll_msecs. 2278 */ 2279static int disk_events_set_dfl_poll_msecs(const char *val, 2280 const struct kernel_param *kp) 2281{ 2282 struct disk_events *ev; 2283 int ret; 2284 2285 ret = param_set_ulong(val, kp); 2286 if (ret < 0) 2287 return ret; 2288 2289 mutex_lock(&disk_events_mutex); 2290 2291 list_for_each_entry(ev, &disk_events, node) 2292 disk_flush_events(ev->disk, 0); 2293 2294 mutex_unlock(&disk_events_mutex); 2295 2296 return 0; 2297} 2298 2299static const struct kernel_param_ops disk_events_dfl_poll_msecs_param_ops = { 2300 .set = disk_events_set_dfl_poll_msecs, 2301 .get = param_get_ulong, 2302}; 2303 2304#undef MODULE_PARAM_PREFIX 2305#define MODULE_PARAM_PREFIX "block." 2306 2307module_param_cb(events_dfl_poll_msecs, &disk_events_dfl_poll_msecs_param_ops, 2308 &disk_events_dfl_poll_msecs, 0644); 2309 2310/* 2311 * disk_{alloc|add|del|release}_events - initialize and destroy disk_events. 2312 */ 2313static void disk_alloc_events(struct gendisk *disk) 2314{ 2315 struct disk_events *ev; 2316 2317 if (!disk->fops->check_events || !disk->events) 2318 return; 2319 2320 ev = kzalloc(sizeof(*ev), GFP_KERNEL); 2321 if (!ev) { 2322 pr_warn("%s: failed to initialize events\n", disk->disk_name); 2323 return; 2324 } 2325 2326 INIT_LIST_HEAD(&ev->node); 2327 ev->disk = disk; 2328 spin_lock_init(&ev->lock); 2329 mutex_init(&ev->block_mutex); 2330 ev->block = 1; 2331 ev->poll_msecs = -1; 2332 INIT_DELAYED_WORK(&ev->dwork, disk_events_workfn); 2333 2334 disk->ev = ev; 2335} 2336 2337static void disk_add_events(struct gendisk *disk) 2338{ 2339 /* FIXME: error handling */ 2340 if (sysfs_create_files(&disk_to_dev(disk)->kobj, disk_events_attrs) < 0) 2341 pr_warn("%s: failed to create sysfs files for events\n", 2342 disk->disk_name); 2343 2344 if (!disk->ev) 2345 return; 2346 2347 mutex_lock(&disk_events_mutex); 2348 list_add_tail(&disk->ev->node, &disk_events); 2349 mutex_unlock(&disk_events_mutex); 2350 2351 /* 2352 * Block count is initialized to 1 and the following initial 2353 * unblock kicks it into action. 2354 */ 2355 __disk_unblock_events(disk, true); 2356} 2357 2358static void disk_del_events(struct gendisk *disk) 2359{ 2360 if (disk->ev) { 2361 disk_block_events(disk); 2362 2363 mutex_lock(&disk_events_mutex); 2364 list_del_init(&disk->ev->node); 2365 mutex_unlock(&disk_events_mutex); 2366 } 2367 2368 sysfs_remove_files(&disk_to_dev(disk)->kobj, disk_events_attrs); 2369} 2370 2371static void disk_release_events(struct gendisk *disk) 2372{ 2373 /* the block count should be 1 from disk_del_events() */ 2374 WARN_ON_ONCE(disk->ev && disk->ev->block != 1); 2375 kfree(disk->ev); 2376} 2377