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