block/genhd.c

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