block/genhd.c

   1 /*
   2  *  gendisk handling
   3  */
   4
   5 #include <linux/module.h>
   6 #include <linux/fs.h>
   7 #include <linux/genhd.h>
   8 #include <linux/kdev_t.h>
   9 #include <linux/kernel.h>
  10 #include <linux/blkdev.h>
  11 #include <linux/init.h>
  12 #include <linux/spinlock.h>
  13 #include <linux/proc_fs.h>
  14 #include <linux/seq_file.h>
  15 #include <linux/slab.h>
  16 #include <linux/kmod.h>
  17 #include <linux/kobj_map.h>
  18 #include <linux/buffer_head.h>
  19 #include <linux/mutex.h>
  20 #include <linux/idr.h>
  21
  22 #include "blk.h"
  23
  24 static DEFINE_MUTEX(block_class_lock);
  25 #ifndef CONFIG_SYSFS_DEPRECATED
  26 struct kobject *block_depr;
  27 #endif
  28
  29 /* for extended dynamic devt allocation, currently only one major is used */
  30 #define MAX_EXT_DEVT            (1 << MINORBITS)
  31
  32 /* For extended devt allocation.  ext_devt_mutex prevents look up
  33  * results from going away underneath its user.
  34  */
  35 static DEFINE_MUTEX(ext_devt_mutex);
  36 static DEFINE_IDR(ext_devt_idr);
  37
  38 static struct device_type disk_type;
  39
  40 /**
  41  * disk_get_part - get partition
  42  * @disk: disk to look partition from
  43  * @partno: partition number
  44  *
  45  * Look for partition @partno from @disk.  If found, increment
  46  * reference count and return it.
  47  *
  48  * CONTEXT:
  49  * Don't care.
  50  *
  51  * RETURNS:
  52  * Pointer to the found partition on success, NULL if not found.
  53  */
  54 struct hd_struct *disk_get_part(struct gendisk *disk, int partno)
  55 {
  56         struct hd_struct *part = NULL;
  57         struct disk_part_tbl *ptbl;
  58
  59         if (unlikely(partno < 0))
  60                 return NULL;
  61
  62         rcu_read_lock();
  63
  64         ptbl = rcu_dereference(disk->part_tbl);
  65         if (likely(partno < ptbl->len)) {
  66                 part = rcu_dereference(ptbl->part[partno]);
  67                 if (part)
  68                         get_device(part_to_dev(part));
  69         }
  70
  71         rcu_read_unlock();
  72
  73         return part;
  74 }
  75 EXPORT_SYMBOL_GPL(disk_get_part);
  76
  77 /**
  78  * disk_part_iter_init - initialize partition iterator
  79  * @piter: iterator to initialize
  80  * @disk: disk to iterate over
  81  * @flags: DISK_PITER_* flags
  82  *
  83  * Initialize @piter so that it iterates over partitions of @disk.
  84  *
  85  * CONTEXT:
  86  * Don't care.
  87  */
  88 void disk_part_iter_init(struct disk_part_iter *piter, struct gendisk *disk,
  89                           unsigned int flags)
  90 {
  91         struct disk_part_tbl *ptbl;
  92
  93         rcu_read_lock();
  94         ptbl = rcu_dereference(disk->part_tbl);
  95
  96         piter->disk = disk;
  97         piter->part = NULL;
  98
  99         if (flags & DISK_PITER_REVERSE)
 100                 piter->idx = ptbl->len - 1;
 101         else if (flags & DISK_PITER_INCL_PART0)
 102                 piter->idx = 0;
 103         else
 104                 piter->idx = 1;
 105
 106         piter->flags = flags;
 107
 108         rcu_read_unlock();
 109 }
 110 EXPORT_SYMBOL_GPL(disk_part_iter_init);
 111
 112 /**
 113  * disk_part_iter_next - proceed iterator to the next partition and return it
 114  * @piter: iterator of interest
 115  *
 116  * Proceed @piter to the next partition and return it.
 117  *
 118  * CONTEXT:
 119  * Don't care.
 120  */
 121 struct hd_struct *disk_part_iter_next(struct disk_part_iter *piter)
 122 {
 123         struct disk_part_tbl *ptbl;
 124         int inc, end;
 125
 126         /* put the last partition */
 127         disk_put_part(piter->part);
 128         piter->part = NULL;
 129
 130         /* get part_tbl */
 131         rcu_read_lock();
 132         ptbl = rcu_dereference(piter->disk->part_tbl);
 133
 134         /* determine iteration parameters */
 135         if (piter->flags & DISK_PITER_REVERSE) {
 136                 inc = -1;
 137                 if (piter->flags & DISK_PITER_INCL_PART0)
 138                         end = -1;
 139                 else
 140                         end = 0;
 141         } else {
 142                 inc = 1;
 143                 end = ptbl->len;
 144         }
 145
 146         /* iterate to the next partition */
 147         for (; piter->idx != end; piter->idx += inc) {
 148                 struct hd_struct *part;
 149
 150                 part = rcu_dereference(ptbl->part[piter->idx]);
 151                 if (!part)
 152                         continue;
 153                 if (!(piter->flags & DISK_PITER_INCL_EMPTY) && !part->nr_sects)
 154                         continue;
 155
 156                 get_device(part_to_dev(part));
 157                 piter->part = part;
 158                 piter->idx += inc;
 159                 break;
 160         }
 161
 162         rcu_read_unlock();
 163
 164         return piter->part;
 165 }
 166 EXPORT_SYMBOL_GPL(disk_part_iter_next);
 167
 168 /**
 169  * disk_part_iter_exit - finish up partition iteration
 170  * @piter: iter of interest
 171  *
 172  * Called when iteration is over.  Cleans up @piter.
 173  *
 174  * CONTEXT:
 175  * Don't care.
 176  */
 177 void disk_part_iter_exit(struct disk_part_iter *piter)
 178 {
 179         disk_put_part(piter->part);
 180         piter->part = NULL;
 181 }
 182 EXPORT_SYMBOL_GPL(disk_part_iter_exit);
 183
 184 static inline int sector_in_part(struct hd_struct *part, sector_t sector)
 185 {
 186         return part->start_sect <= sector &&
 187                 sector < part->start_sect + part->nr_sects;
 188 }
 189
 190 /**
 191  * disk_map_sector_rcu - map sector to partition
 192  * @disk: gendisk of interest
 193  * @sector: sector to map
 194  *
 195  * Find out which partition @sector maps to on @disk.  This is
 196  * primarily used for stats accounting.
 197  *
 198  * CONTEXT:
 199  * RCU read locked.  The returned partition pointer is valid only
 200  * while preemption is disabled.
 201  *
 202  * RETURNS:
 203  * Found partition on success, part0 is returned if no partition matches
 204  */
 205 struct hd_struct *disk_map_sector_rcu(struct gendisk *disk, sector_t sector)
 206 {
 207         struct disk_part_tbl *ptbl;
 208         struct hd_struct *part;
 209         int i;
 210
 211         ptbl = rcu_dereference(disk->part_tbl);
 212
 213         part = rcu_dereference(ptbl->last_lookup);
 214         if (part && sector_in_part(part, sector))
 215                 return part;
 216
 217         for (i = 1; i < ptbl->len; i++) {
 218                 part = rcu_dereference(ptbl->part[i]);
 219
 220                 if (part && sector_in_part(part, sector)) {
 221                         rcu_assign_pointer(ptbl->last_lookup, part);
 222                         return part;
 223                 }
 224         }
 225         return &disk->part0;
 226 }
 227 EXPORT_SYMBOL_GPL(disk_map_sector_rcu);
 228
 229 /*
 230  * Can be deleted altogether. Later.
 231  *
 232  */
 233 static struct blk_major_name {
 234         struct blk_major_name *next;
 235         int major;
 236         char name[16];
 237 } *major_names[BLKDEV_MAJOR_HASH_SIZE];
 238
 239 /* index in the above - for now: assume no multimajor ranges */
 240 static inline int major_to_index(int major)
 241 {
 242         return major % BLKDEV_MAJOR_HASH_SIZE;
 243 }
 244
 245 #ifdef CONFIG_PROC_FS
 246 void blkdev_show(struct seq_file *seqf, off_t offset)
 247 {
 248         struct blk_major_name *dp;
 249
 250         if (offset < BLKDEV_MAJOR_HASH_SIZE) {
 251                 mutex_lock(&block_class_lock);
 252                 for (dp = major_names[offset]; dp; dp = dp->next)
 253                         seq_printf(seqf, "%3d %s\n", dp->major, dp->name);
 254                 mutex_unlock(&block_class_lock);
 255         }
 256 }
 257 #endif /* CONFIG_PROC_FS */
 258
 259 /**
 260  * register_blkdev - register a new block device
 261  *
 262  * @major: the requested major device number [1..255]. If @major=0, try to
 263  *         allocate any unused major number.
 264  * @name: the name of the new block device as a zero terminated string
 265  *
 266  * The @name must be unique within the system.
 267  *
 268  * The return value depends on the @major input parameter.
 269  *  - if a major device number was requested in range [1..255] then the
 270  *    function returns zero on success, or a negative error code
 271  *  - if any unused major number was requested with @major=0 parameter
 272  *    then the return value is the allocated major number in range
 273  *    [1..255] or a negative error code otherwise
 274  */
 275 int register_blkdev(unsigned int major, const char *name)
 276 {
 277         struct blk_major_name **n, *p;
 278         int index, ret = 0;
 279
 280         mutex_lock(&block_class_lock);
 281
 282         /* temporary */
 283         if (major == 0) {
 284                 for (index = ARRAY_SIZE(major_names)-1; index > 0; index--) {
 285                         if (major_names[index] == NULL)
 286                                 break;
 287                 }
 288
 289                 if (index == 0) {
 290                         printk("register_blkdev: failed to get major for %s\n",
 291                                name);
 292                         ret = -EBUSY;
 293                         goto out;
 294                 }
 295                 major = index;
 296                 ret = major;
 297         }
 298
 299         p = kmalloc(sizeof(struct blk_major_name), GFP_KERNEL);
 300         if (p == NULL) {
 301                 ret = -ENOMEM;
 302                 goto out;
 303         }
 304
 305         p->major = major;
 306         strlcpy(p->name, name, sizeof(p->name));
 307         p->next = NULL;
 308         index = major_to_index(major);
 309
 310         for (n = &major_names[index]; *n; n = &(*n)->next) {
 311                 if ((*n)->major == major)
 312                         break;
 313         }
 314         if (!*n)
 315                 *n = p;
 316         else
 317                 ret = -EBUSY;
 318
 319         if (ret < 0) {
 320                 printk("register_blkdev: cannot get major %d for %s\n",
 321                        major, name);
 322                 kfree(p);
 323         }
 324 out:
 325         mutex_unlock(&block_class_lock);
 326         return ret;
 327 }
 328
 329 EXPORT_SYMBOL(register_blkdev);
 330
 331 void unregister_blkdev(unsigned int major, const char *name)
 332 {
 333         struct blk_major_name **n;
 334         struct blk_major_name *p = NULL;
 335         int index = major_to_index(major);
 336
 337         mutex_lock(&block_class_lock);
 338         for (n = &major_names[index]; *n; n = &(*n)->next)
 339                 if ((*n)->major == major)
 340                         break;
 341         if (!*n || strcmp((*n)->name, name)) {
 342                 WARN_ON(1);
 343         } else {
 344                 p = *n;
 345                 *n = p->next;
 346         }
 347         mutex_unlock(&block_class_lock);
 348         kfree(p);
 349 }
 350
 351 EXPORT_SYMBOL(unregister_blkdev);
 352
 353 static struct kobj_map *bdev_map;
 354
 355 /**
 356  * blk_mangle_minor - scatter minor numbers apart
 357  * @minor: minor number to mangle
 358  *
 359  * Scatter consecutively allocated @minor number apart if MANGLE_DEVT
 360  * is enabled.  Mangling twice gives the original value.
 361  *
 362  * RETURNS:
 363  * Mangled value.
 364  *
 365  * CONTEXT:
 366  * Don't care.
 367  */
 368 static int blk_mangle_minor(int minor)
 369 {
 370 #ifdef CONFIG_DEBUG_BLOCK_EXT_DEVT
 371         int i;
 372
 373         for (i = 0; i < MINORBITS / 2; i++) {
 374                 int low = minor & (1 << i);
 375                 int high = minor & (1 << (MINORBITS - 1 - i));
 376                 int distance = MINORBITS - 1 - 2 * i;
 377
 378                 minor ^= low | high;    /* clear both bits */
 379                 low <<= distance;       /* swap the positions */
 380                 high >>= distance;
 381                 minor |= low | high;    /* and set */
 382         }
 383 #endif
 384         return minor;
 385 }
 386
 387 /**
 388  * blk_alloc_devt - allocate a dev_t for a partition
 389  * @part: partition to allocate dev_t for
 390  * @devt: out parameter for resulting dev_t
 391  *
 392  * Allocate a dev_t for block device.
 393  *
 394  * RETURNS:
 395  * 0 on success, allocated dev_t is returned in *@devt.  -errno on
 396  * failure.
 397  *
 398  * CONTEXT:
 399  * Might sleep.
 400  */
 401 int blk_alloc_devt(struct hd_struct *part, dev_t *devt)
 402 {
 403         struct gendisk *disk = part_to_disk(part);
 404         int idx, rc;
 405
 406         /* in consecutive minor range? */
 407         if (part->partno < disk->minors) {
 408                 *devt = MKDEV(disk->major, disk->first_minor + part->partno);
 409                 return 0;
 410         }
 411
 412         /* allocate ext devt */
 413         do {
 414                 if (!idr_pre_get(&ext_devt_idr, GFP_KERNEL))
 415                         return -ENOMEM;
 416                 rc = idr_get_new(&ext_devt_idr, part, &idx);
 417         } while (rc == -EAGAIN);
 418
 419         if (rc)
 420                 return rc;
 421
 422         if (idx > MAX_EXT_DEVT) {
 423                 idr_remove(&ext_devt_idr, idx);
 424                 return -EBUSY;
 425         }
 426
 427         *devt = MKDEV(BLOCK_EXT_MAJOR, blk_mangle_minor(idx));
 428         return 0;
 429 }
 430
 431 /**
 432  * blk_free_devt - free a dev_t
 433  * @devt: dev_t to free
 434  *
 435  * Free @devt which was allocated using blk_alloc_devt().
 436  *
 437  * CONTEXT:
 438  * Might sleep.
 439  */
 440 void blk_free_devt(dev_t devt)
 441 {
 442         might_sleep();
 443
 444         if (devt == MKDEV(0, 0))
 445                 return;
 446
 447         if (MAJOR(devt) == BLOCK_EXT_MAJOR) {
 448                 mutex_lock(&ext_devt_mutex);
 449                 idr_remove(&ext_devt_idr, blk_mangle_minor(MINOR(devt)));
 450                 mutex_unlock(&ext_devt_mutex);
 451         }
 452 }
 453
 454 static char *bdevt_str(dev_t devt, char *buf)
 455 {
 456         if (MAJOR(devt) <= 0xff && MINOR(devt) <= 0xff) {
 457                 char tbuf[BDEVT_SIZE];
 458                 snprintf(tbuf, BDEVT_SIZE, "%02x%02x", MAJOR(devt), MINOR(devt));
 459                 snprintf(buf, BDEVT_SIZE, "%-9s", tbuf);
 460         } else
 461                 snprintf(buf, BDEVT_SIZE, "%03x:%05x", MAJOR(devt), MINOR(devt));
 462
 463         return buf;
 464 }
 465
 466 /*
 467  * Register device numbers dev..(dev+range-1)
 468  * range must be nonzero
 469  * The hash chain is sorted on range, so that subranges can override.
 470  */
 471 void blk_register_region(dev_t devt, unsigned long range, struct module *module,
 472                          struct kobject *(*probe)(dev_t, int *, void *),
 473                          int (*lock)(dev_t, void *), void *data)
 474 {
 475         kobj_map(bdev_map, devt, range, module, probe, lock, data);
 476 }
 477
 478 EXPORT_SYMBOL(blk_register_region);
 479
 480 void blk_unregister_region(dev_t devt, unsigned long range)
 481 {
 482         kobj_unmap(bdev_map, devt, range);
 483 }
 484
 485 EXPORT_SYMBOL(blk_unregister_region);
 486
 487 static struct kobject *exact_match(dev_t devt, int *partno, void *data)
 488 {
 489         struct gendisk *p = data;
 490
 491         return &disk_to_dev(p)->kobj;
 492 }
 493
 494 static int exact_lock(dev_t devt, void *data)
 495 {
 496         struct gendisk *p = data;
 497
 498         if (!get_disk(p))
 499                 return -1;
 500         return 0;
 501 }
 502
 503 /**
 504  * add_disk - add partitioning information to kernel list
 505  * @disk: per-device partitioning information
 506  *
 507  * This function registers the partitioning information in @disk
 508  * with the kernel.
 509  *
 510  * FIXME: error handling
 511  */
 512 void add_disk(struct gendisk *disk)
 513 {
 514         struct backing_dev_info *bdi;
 515         dev_t devt;
 516         int retval;
 517
 518         /* minors == 0 indicates to use ext devt from part0 and should
 519          * be accompanied with EXT_DEVT flag.  Make sure all
 520          * parameters make sense.
 521          */
 522         WARN_ON(disk->minors && !(disk->major || disk->first_minor));
 523         WARN_ON(!disk->minors && !(disk->flags & GENHD_FL_EXT_DEVT));
 524
 525         disk->flags |= GENHD_FL_UP;
 526
 527         retval = blk_alloc_devt(&disk->part0, &devt);
 528         if (retval) {
 529                 WARN_ON(1);
 530                 return;
 531         }
 532         disk_to_dev(disk)->devt = devt;
 533
 534         /* ->major and ->first_minor aren't supposed to be
 535          * dereferenced from here on, but set them just in case.
 536          */
 537         disk->major = MAJOR(devt);
 538         disk->first_minor = MINOR(devt);
 539
 540         blk_register_region(disk_devt(disk), disk->minors, NULL,
 541                             exact_match, exact_lock, disk);
 542         register_disk(disk);
 543         blk_register_queue(disk);
 544
 545         bdi = &disk->queue->backing_dev_info;
 546         bdi_register_dev(bdi, disk_devt(disk));
 547         retval = sysfs_create_link(&disk_to_dev(disk)->kobj, &bdi->dev->kobj,
 548                                    "bdi");
 549         WARN_ON(retval);
 550 }
 551
 552 EXPORT_SYMBOL(add_disk);
 553 EXPORT_SYMBOL(del_gendisk);     /* in partitions/check.c */
 554
 555 void unlink_gendisk(struct gendisk *disk)
 556 {
 557         sysfs_remove_link(&disk_to_dev(disk)->kobj, "bdi");
 558         bdi_unregister(&disk->queue->backing_dev_info);
 559         blk_unregister_queue(disk);
 560         blk_unregister_region(disk_devt(disk), disk->minors);
 561 }
 562
 563 /**
 564  * get_gendisk - get partitioning information for a given device
 565  * @devt: device to get partitioning information for
 566  * @partno: returned partition index
 567  *
 568  * This function gets the structure containing partitioning
 569  * information for the given device @devt.
 570  */
 571 struct gendisk *get_gendisk(dev_t devt, int *partno)
 572 {
 573         struct gendisk *disk = NULL;
 574
 575         if (MAJOR(devt) != BLOCK_EXT_MAJOR) {
 576                 struct kobject *kobj;
 577
 578                 kobj = kobj_lookup(bdev_map, devt, partno);
 579                 if (kobj)
 580                         disk = dev_to_disk(kobj_to_dev(kobj));
 581         } else {
 582                 struct hd_struct *part;
 583
 584                 mutex_lock(&ext_devt_mutex);
 585                 part = idr_find(&ext_devt_idr, blk_mangle_minor(MINOR(devt)));
 586                 if (part && get_disk(part_to_disk(part))) {
 587                         *partno = part->partno;
 588                         disk = part_to_disk(part);
 589                 }
 590                 mutex_unlock(&ext_devt_mutex);
 591         }
 592
 593         return disk;
 594 }
 595
 596 /**
 597  * bdget_disk - do bdget() by gendisk and partition number
 598  * @disk: gendisk of interest
 599  * @partno: partition number
 600  *
 601  * Find partition @partno from @disk, do bdget() on it.
 602  *
 603  * CONTEXT:
 604  * Don't care.
 605  *
 606  * RETURNS:
 607  * Resulting block_device on success, NULL on failure.
 608  */
 609 struct block_device *bdget_disk(struct gendisk *disk, int partno)
 610 {
 611         struct hd_struct *part;
 612         struct block_device *bdev = NULL;
 613
 614         part = disk_get_part(disk, partno);
 615         if (part)
 616                 bdev = bdget(part_devt(part));
 617         disk_put_part(part);
 618
 619         return bdev;
 620 }
 621 EXPORT_SYMBOL(bdget_disk);
 622
 623 /*
 624  * print a full list of all partitions - intended for places where the root
 625  * filesystem can't be mounted and thus to give the victim some idea of what
 626  * went wrong
 627  */
 628 void __init printk_all_partitions(void)
 629 {
 630         struct class_dev_iter iter;
 631         struct device *dev;
 632
 633         class_dev_iter_init(&iter, &block_class, NULL, &disk_type);
 634         while ((dev = class_dev_iter_next(&iter))) {
 635                 struct gendisk *disk = dev_to_disk(dev);
 636                 struct disk_part_iter piter;
 637                 struct hd_struct *part;
 638                 char name_buf[BDEVNAME_SIZE];
 639                 char devt_buf[BDEVT_SIZE];
 640
 641                 /*
 642                  * Don't show empty devices or things that have been
 643                  * surpressed
 644                  */
 645                 if (get_capacity(disk) == 0 ||
 646                     (disk->flags & GENHD_FL_SUPPRESS_PARTITION_INFO))
 647                         continue;
 648
 649                 /*
 650                  * Note, unlike /proc/partitions, I am showing the
 651                  * numbers in hex - the same format as the root=
 652                  * option takes.
 653                  */
 654                 disk_part_iter_init(&piter, disk, DISK_PITER_INCL_PART0);
 655                 while ((part = disk_part_iter_next(&piter))) {
 656                         bool is_part0 = part == &disk->part0;
 657
 658                         printk("%s%s %10llu %s", is_part0 ? "" : "  ",
 659                                bdevt_str(part_devt(part), devt_buf),
 660                                (unsigned long long)part->nr_sects >> 1,
 661                                disk_name(disk, part->partno, name_buf));
 662                         if (is_part0) {
 663                                 if (disk->driverfs_dev != NULL &&
 664                                     disk->driverfs_dev->driver != NULL)
 665                                         printk(" driver: %s\n",
 666                                               disk->driverfs_dev->driver->name);
 667                                 else
 668                                         printk(" (driver?)\n");
 669                         } else
 670                                 printk("\n");
 671                 }
 672                 disk_part_iter_exit(&piter);
 673         }
 674         class_dev_iter_exit(&iter);
 675 }
 676
 677 #ifdef CONFIG_PROC_FS
 678 /* iterator */
 679 static void *disk_seqf_start(struct seq_file *seqf, loff_t *pos)
 680 {
 681         loff_t skip = *pos;
 682         struct class_dev_iter *iter;
 683         struct device *dev;
 684
 685         iter = kmalloc(sizeof(*iter), GFP_KERNEL);
 686         if (!iter)
 687                 return ERR_PTR(-ENOMEM);
 688
 689         seqf->private = iter;
 690         class_dev_iter_init(iter, &block_class, NULL, &disk_type);
 691         do {
 692                 dev = class_dev_iter_next(iter);
 693                 if (!dev)
 694                         return NULL;
 695         } while (skip--);
 696
 697         return dev_to_disk(dev);
 698 }
 699
 700 static void *disk_seqf_next(struct seq_file *seqf, void *v, loff_t *pos)
 701 {
 702         struct device *dev;
 703
 704         (*pos)++;
 705         dev = class_dev_iter_next(seqf->private);
 706         if (dev)
 707                 return dev_to_disk(dev);
 708
 709         return NULL;
 710 }
 711
 712 static void disk_seqf_stop(struct seq_file *seqf, void *v)
 713 {
 714         struct class_dev_iter *iter = seqf->private;
 715
 716         /* stop is called even after start failed :-( */
 717         if (iter) {
 718                 class_dev_iter_exit(iter);
 719                 kfree(iter);
 720         }
 721 }
 722
 723 static void *show_partition_start(struct seq_file *seqf, loff_t *pos)
 724 {
 725         static void *p;
 726
 727         p = disk_seqf_start(seqf, pos);
 728         if (!IS_ERR(p) && p && !*pos)
 729                 seq_puts(seqf, "major minor  #blocks  name\n\n");
 730         return p;
 731 }
 732
 733 static int show_partition(struct seq_file *seqf, void *v)
 734 {
 735         struct gendisk *sgp = v;
 736         struct disk_part_iter piter;
 737         struct hd_struct *part;
 738         char buf[BDEVNAME_SIZE];
 739
 740         /* Don't show non-partitionable removeable devices or empty devices */
 741         if (!get_capacity(sgp) || (!disk_partitionable(sgp) &&
 742                                    (sgp->flags & GENHD_FL_REMOVABLE)))
 743                 return 0;
 744         if (sgp->flags & GENHD_FL_SUPPRESS_PARTITION_INFO)
 745                 return 0;
 746
 747         /* show the full disk and all non-0 size partitions of it */
 748         disk_part_iter_init(&piter, sgp, DISK_PITER_INCL_PART0);
 749         while ((part = disk_part_iter_next(&piter)))
 750                 seq_printf(seqf, "%4d  %7d %10llu %s\n",
 751                            MAJOR(part_devt(part)), MINOR(part_devt(part)),
 752                            (unsigned long long)part->nr_sects >> 1,
 753                            disk_name(sgp, part->partno, buf));
 754         disk_part_iter_exit(&piter);
 755
 756         return 0;
 757 }
 758
 759 static const struct seq_operations partitions_op = {
 760         .start  = show_partition_start,
 761         .next   = disk_seqf_next,
 762         .stop   = disk_seqf_stop,
 763         .show   = show_partition
 764 };
 765
 766 static int partitions_open(struct inode *inode, struct file *file)
 767 {
 768         return seq_open(file, &partitions_op);
 769 }
 770
 771 static const struct file_operations proc_partitions_operations = {
 772         .open           = partitions_open,
 773         .read           = seq_read,
 774         .llseek         = seq_lseek,
 775         .release        = seq_release,
 776 };
 777 #endif
 778
 779
 780 static struct kobject *base_probe(dev_t devt, int *partno, void *data)
 781 {
 782         if (request_module("block-major-%d-%d", MAJOR(devt), MINOR(devt)) > 0)
 783                 /* Make old-style 2.4 aliases work */
 784                 request_module("block-major-%d", MAJOR(devt));
 785         return NULL;
 786 }
 787
 788 static int __init genhd_device_init(void)
 789 {
 790         int error;
 791
 792         block_class.dev_kobj = sysfs_dev_block_kobj;
 793         error = class_register(&block_class);
 794         if (unlikely(error))
 795                 return error;
 796         bdev_map = kobj_map_init(base_probe, &block_class_lock);
 797         blk_dev_init();
 798
 799         register_blkdev(BLOCK_EXT_MAJOR, "blkext");
 800
 801 #ifndef CONFIG_SYSFS_DEPRECATED
 802         /* create top-level block dir */
 803         block_depr = kobject_create_and_add("block", NULL);
 804 #endif
 805         return 0;
 806 }
 807
 808 subsys_initcall(genhd_device_init);
 809
 810 static ssize_t disk_range_show(struct device *dev,
 811                                struct device_attribute *attr, char *buf)
 812 {
 813         struct gendisk *disk = dev_to_disk(dev);
 814
 815         return sprintf(buf, "%d\n", disk->minors);
 816 }
 817
 818 static ssize_t disk_ext_range_show(struct device *dev,
 819                                    struct device_attribute *attr, char *buf)
 820 {
 821         struct gendisk *disk = dev_to_disk(dev);
 822
 823         return sprintf(buf, "%d\n", disk_max_parts(disk));
 824 }
 825
 826 static ssize_t disk_removable_show(struct device *dev,
 827                                    struct device_attribute *attr, char *buf)
 828 {
 829         struct gendisk *disk = dev_to_disk(dev);
 830
 831         return sprintf(buf, "%d\n",
 832                        (disk->flags & GENHD_FL_REMOVABLE ? 1 : 0));
 833 }
 834
 835 static ssize_t disk_ro_show(struct device *dev,
 836                                    struct device_attribute *attr, char *buf)
 837 {
 838         struct gendisk *disk = dev_to_disk(dev);
 839
 840         return sprintf(buf, "%d\n", get_disk_ro(disk) ? 1 : 0);
 841 }
 842
 843 static ssize_t disk_capability_show(struct device *dev,
 844                                     struct device_attribute *attr, char *buf)
 845 {
 846         struct gendisk *disk = dev_to_disk(dev);
 847
 848         return sprintf(buf, "%x\n", disk->flags);
 849 }
 850
 851 static DEVICE_ATTR(range, S_IRUGO, disk_range_show, NULL);
 852 static DEVICE_ATTR(ext_range, S_IRUGO, disk_ext_range_show, NULL);
 853 static DEVICE_ATTR(removable, S_IRUGO, disk_removable_show, NULL);
 854 static DEVICE_ATTR(ro, S_IRUGO, disk_ro_show, NULL);
 855 static DEVICE_ATTR(size, S_IRUGO, part_size_show, NULL);
 856 static DEVICE_ATTR(capability, S_IRUGO, disk_capability_show, NULL);
 857 static DEVICE_ATTR(stat, S_IRUGO, part_stat_show, NULL);
 858 #ifdef CONFIG_FAIL_MAKE_REQUEST
 859 static struct device_attribute dev_attr_fail =
 860         __ATTR(make-it-fail, S_IRUGO|S_IWUSR, part_fail_show, part_fail_store);
 861 #endif
 862 #ifdef CONFIG_FAIL_IO_TIMEOUT
 863 static struct device_attribute dev_attr_fail_timeout =
 864         __ATTR(io-timeout-fail,  S_IRUGO|S_IWUSR, part_timeout_show,
 865                 part_timeout_store);
 866 #endif
 867
 868 static struct attribute *disk_attrs[] = {
 869         &dev_attr_range.attr,
 870         &dev_attr_ext_range.attr,
 871         &dev_attr_removable.attr,
 872         &dev_attr_ro.attr,
 873         &dev_attr_size.attr,
 874         &dev_attr_capability.attr,
 875         &dev_attr_stat.attr,
 876 #ifdef CONFIG_FAIL_MAKE_REQUEST
 877         &dev_attr_fail.attr,
 878 #endif
 879 #ifdef CONFIG_FAIL_IO_TIMEOUT
 880         &dev_attr_fail_timeout.attr,
 881 #endif
 882         NULL
 883 };
 884
 885 static struct attribute_group disk_attr_group = {
 886         .attrs = disk_attrs,
 887 };
 888
 889 static struct attribute_group *disk_attr_groups[] = {
 890         &disk_attr_group,
 891         NULL
 892 };
 893
 894 static void disk_free_ptbl_rcu_cb(struct rcu_head *head)
 895 {
 896         struct disk_part_tbl *ptbl =
 897                 container_of(head, struct disk_part_tbl, rcu_head);
 898
 899         kfree(ptbl);
 900 }
 901
 902 /**
 903  * disk_replace_part_tbl - replace disk->part_tbl in RCU-safe way
 904  * @disk: disk to replace part_tbl for
 905  * @new_ptbl: new part_tbl to install
 906  *
 907  * Replace disk->part_tbl with @new_ptbl in RCU-safe way.  The
 908  * original ptbl is freed using RCU callback.
 909  *
 910  * LOCKING:
 911  * Matching bd_mutx locked.
 912  */
 913 static void disk_replace_part_tbl(struct gendisk *disk,
 914                                   struct disk_part_tbl *new_ptbl)
 915 {
 916         struct disk_part_tbl *old_ptbl = disk->part_tbl;
 917
 918         rcu_assign_pointer(disk->part_tbl, new_ptbl);
 919
 920         if (old_ptbl) {
 921                 rcu_assign_pointer(old_ptbl->last_lookup, NULL);
 922                 call_rcu(&old_ptbl->rcu_head, disk_free_ptbl_rcu_cb);
 923         }
 924 }
 925
 926 /**
 927  * disk_expand_part_tbl - expand disk->part_tbl
 928  * @disk: disk to expand part_tbl for
 929  * @partno: expand such that this partno can fit in
 930  *
 931  * Expand disk->part_tbl such that @partno can fit in.  disk->part_tbl
 932  * uses RCU to allow unlocked dereferencing for stats and other stuff.
 933  *
 934  * LOCKING:
 935  * Matching bd_mutex locked, might sleep.
 936  *
 937  * RETURNS:
 938  * 0 on success, -errno on failure.
 939  */
 940 int disk_expand_part_tbl(struct gendisk *disk, int partno)
 941 {
 942         struct disk_part_tbl *old_ptbl = disk->part_tbl;
 943         struct disk_part_tbl *new_ptbl;
 944         int len = old_ptbl ? old_ptbl->len : 0;
 945         int target = partno + 1;
 946         size_t size;
 947         int i;
 948
 949         /* disk_max_parts() is zero during initialization, ignore if so */
 950         if (disk_max_parts(disk) && target > disk_max_parts(disk))
 951                 return -EINVAL;
 952
 953         if (target <= len)
 954                 return 0;
 955
 956         size = sizeof(*new_ptbl) + target * sizeof(new_ptbl->part[0]);
 957         new_ptbl = kzalloc_node(size, GFP_KERNEL, disk->node_id);
 958         if (!new_ptbl)
 959                 return -ENOMEM;
 960
 961         INIT_RCU_HEAD(&new_ptbl->rcu_head);
 962         new_ptbl->len = target;
 963
 964         for (i = 0; i < len; i++)
 965                 rcu_assign_pointer(new_ptbl->part[i], old_ptbl->part[i]);
 966
 967         disk_replace_part_tbl(disk, new_ptbl);
 968         return 0;
 969 }
 970
 971 static void disk_release(struct device *dev)
 972 {
 973         struct gendisk *disk = dev_to_disk(dev);
 974
 975         kfree(disk->random);
 976         disk_replace_part_tbl(disk, NULL);
 977         free_part_stats(&disk->part0);
 978         kfree(disk);
 979 }
 980 struct class block_class = {
 981         .name           = "block",
 982 };
 983
 984 static struct device_type disk_type = {
 985         .name           = "disk",
 986         .groups         = disk_attr_groups,
 987         .release        = disk_release,
 988 };
 989
 990 #ifdef CONFIG_PROC_FS
 991 /*
 992  * aggregate disk stat collector.  Uses the same stats that the sysfs
 993  * entries do, above, but makes them available through one seq_file.
 994  *
 995  * The output looks suspiciously like /proc/partitions with a bunch of
 996  * extra fields.
 997  */
 998 static int diskstats_show(struct seq_file *seqf, void *v)
 999 {
1000         struct gendisk *gp = v;
1001         struct disk_part_iter piter;
1002         struct hd_struct *hd;
1003         char buf[BDEVNAME_SIZE];
1004         int cpu;
1005
1006         /*
1007         if (&disk_to_dev(gp)->kobj.entry == block_class.devices.next)
1008                 seq_puts(seqf,  "major minor name"
1009                                 "     rio rmerge rsect ruse wio wmerge "
1010                                 "wsect wuse running use aveq"
1011                                 "\n\n");
1012         */
1013
1014         disk_part_iter_init(&piter, gp, DISK_PITER_INCL_PART0);
1015         while ((hd = disk_part_iter_next(&piter))) {
1016                 cpu = part_stat_lock();
1017                 part_round_stats(cpu, hd);
1018                 part_stat_unlock();
1019                 seq_printf(seqf, "%4d %7d %s %lu %lu %llu "
1020                            "%u %lu %lu %llu %u %u %u %u\n",
1021                            MAJOR(part_devt(hd)), MINOR(part_devt(hd)),
1022                            disk_name(gp, hd->partno, buf),
1023                            part_stat_read(hd, ios[0]),
1024                            part_stat_read(hd, merges[0]),
1025                            (unsigned long long)part_stat_read(hd, sectors[0]),
1026                            jiffies_to_msecs(part_stat_read(hd, ticks[0])),
1027                            part_stat_read(hd, ios[1]),
1028                            part_stat_read(hd, merges[1]),
1029                            (unsigned long long)part_stat_read(hd, sectors[1]),
1030                            jiffies_to_msecs(part_stat_read(hd, ticks[1])),
1031                            hd->in_flight,
1032                            jiffies_to_msecs(part_stat_read(hd, io_ticks)),
1033                            jiffies_to_msecs(part_stat_read(hd, time_in_queue))
1034                         );
1035         }
1036         disk_part_iter_exit(&piter);
1037
1038         return 0;
1039 }
1040
1041 static const struct seq_operations diskstats_op = {
1042         .start  = disk_seqf_start,
1043         .next   = disk_seqf_next,
1044         .stop   = disk_seqf_stop,
1045         .show   = diskstats_show
1046 };
1047
1048 static int diskstats_open(struct inode *inode, struct file *file)
1049 {
1050         return seq_open(file, &diskstats_op);
1051 }
1052
1053 static const struct file_operations proc_diskstats_operations = {
1054         .open           = diskstats_open,
1055         .read           = seq_read,
1056         .llseek         = seq_lseek,
1057         .release        = seq_release,
1058 };
1059
1060 static int __init proc_genhd_init(void)
1061 {
1062         proc_create("diskstats", 0, NULL, &proc_diskstats_operations);
1063         proc_create("partitions", 0, NULL, &proc_partitions_operations);
1064         return 0;
1065 }
1066 module_init(proc_genhd_init);
1067 #endif /* CONFIG_PROC_FS */
1068
1069 static void media_change_notify_thread(struct work_struct *work)
1070 {
1071         struct gendisk *gd = container_of(work, struct gendisk, async_notify);
1072         char event[] = "MEDIA_CHANGE=1";
1073         char *envp[] = { event, NULL };
1074
1075         /*
1076          * set enviroment vars to indicate which event this is for
1077          * so that user space will know to go check the media status.
1078          */
1079         kobject_uevent_env(&disk_to_dev(gd)->kobj, KOBJ_CHANGE, envp);
1080         put_device(gd->driverfs_dev);
1081 }
1082
1083 #if 0
1084 void genhd_media_change_notify(struct gendisk *disk)
1085 {
1086         get_device(disk->driverfs_dev);
1087         schedule_work(&disk->async_notify);
1088 }
1089 EXPORT_SYMBOL_GPL(genhd_media_change_notify);
1090 #endif  /*  0  */
1091
1092 dev_t blk_lookup_devt(const char *name, int partno)
1093 {
1094         dev_t devt = MKDEV(0, 0);
1095         struct class_dev_iter iter;
1096         struct device *dev;
1097
1098         class_dev_iter_init(&iter, &block_class, NULL, &disk_type);
1099         while ((dev = class_dev_iter_next(&iter))) {
1100                 struct gendisk *disk = dev_to_disk(dev);
1101                 struct hd_struct *part;
1102
1103                 if (strcmp(dev_name(dev), name))
1104                         continue;
1105
1106                 if (partno < disk->minors) {
1107                         /* We need to return the right devno, even
1108                          * if the partition doesn't exist yet.
1109                          */
1110                         devt = MKDEV(MAJOR(dev->devt),
1111                                      MINOR(dev->devt) + partno);
1112                         break;
1113                 }
1114                 part = disk_get_part(disk, partno);
1115                 if (part) {
1116                         devt = part_devt(part);
1117                         disk_put_part(part);
1118                         break;
1119                 }
1120                 disk_put_part(part);
1121         }
1122         class_dev_iter_exit(&iter);
1123         return devt;
1124 }
1125 EXPORT_SYMBOL(blk_lookup_devt);
1126
1127 struct gendisk *alloc_disk(int minors)
1128 {
1129         return alloc_disk_node(minors, -1);
1130 }
1131 EXPORT_SYMBOL(alloc_disk);
1132
1133 struct gendisk *alloc_disk_node(int minors, int node_id)
1134 {
1135         struct gendisk *disk;
1136
1137         disk = kmalloc_node(sizeof(struct gendisk),
1138                                 GFP_KERNEL | __GFP_ZERO, node_id);
1139         if (disk) {
1140                 if (!init_part_stats(&disk->part0)) {
1141                         kfree(disk);
1142                         return NULL;
1143                 }
1144                 disk->node_id = node_id;
1145                 if (disk_expand_part_tbl(disk, 0)) {
1146                         free_part_stats(&disk->part0);
1147                         kfree(disk);
1148                         return NULL;
1149                 }
1150                 disk->part_tbl->part[0] = &disk->part0;
1151
1152                 disk->minors = minors;
1153                 rand_initialize_disk(disk);
1154                 disk_to_dev(disk)->class = &block_class;
1155                 disk_to_dev(disk)->type = &disk_type;
1156                 device_initialize(disk_to_dev(disk));
1157                 INIT_WORK(&disk->async_notify,
1158                         media_change_notify_thread);
1159         }
1160         return disk;
1161 }
1162 EXPORT_SYMBOL(alloc_disk_node);
1163
1164 struct kobject *get_disk(struct gendisk *disk)
1165 {
1166         struct module *owner;
1167         struct kobject *kobj;
1168
1169         if (!disk->fops)
1170                 return NULL;
1171         owner = disk->fops->owner;
1172         if (owner && !try_module_get(owner))
1173                 return NULL;
1174         kobj = kobject_get(&disk_to_dev(disk)->kobj);
1175         if (kobj == NULL) {
1176                 module_put(owner);
1177                 return NULL;
1178         }
1179         return kobj;
1180
1181 }
1182
1183 EXPORT_SYMBOL(get_disk);
1184
1185 void put_disk(struct gendisk *disk)
1186 {
1187         if (disk)
1188                 kobject_put(&disk_to_dev(disk)->kobj);
1189 }
1190
1191 EXPORT_SYMBOL(put_disk);
1192
1193 void set_device_ro(struct block_device *bdev, int flag)
1194 {
1195         bdev->bd_part->policy = flag;
1196 }
1197
1198 EXPORT_SYMBOL(set_device_ro);
1199
1200 void set_disk_ro(struct gendisk *disk, int flag)
1201 {
1202         struct disk_part_iter piter;
1203         struct hd_struct *part;
1204
1205         disk_part_iter_init(&piter, disk,
1206                             DISK_PITER_INCL_EMPTY | DISK_PITER_INCL_PART0);
1207         while ((part = disk_part_iter_next(&piter)))
1208                 part->policy = flag;
1209         disk_part_iter_exit(&piter);
1210 }
1211
1212 EXPORT_SYMBOL(set_disk_ro);
1213
1214 int bdev_read_only(struct block_device *bdev)
1215 {
1216         if (!bdev)
1217                 return 0;
1218         return bdev->bd_part->policy;
1219 }
1220
1221 EXPORT_SYMBOL(bdev_read_only);
1222
1223 int invalidate_partition(struct gendisk *disk, int partno)
1224 {
1225         int res = 0;
1226         struct block_device *bdev = bdget_disk(disk, partno);
1227         if (bdev) {
1228                 fsync_bdev(bdev);
1229                 res = __invalidate_device(bdev);
1230                 bdput(bdev);
1231         }
1232         return res;
1233 }
1234
1235 EXPORT_SYMBOL(invalidate_partition);