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