fs/partitions/check.c

   1 /*
   2  *  fs/partitions/check.c
   3  *
   4  *  Code extracted from drivers/block/genhd.c
   5  *  Copyright (C) 1991-1998  Linus Torvalds
   6  *  Re-organised Feb 1998 Russell King
   7  *
   8  *  We now have independent partition support from the
   9  *  block drivers, which allows all the partition code to
  10  *  be grouped in one location, and it to be mostly self
  11  *  contained.
  12  *
  13  *  Added needed MAJORS for new pairs, {hdi,hdj}, {hdk,hdl}
  14  */
  15
  16 #include <linux/init.h>
  17 #include <linux/module.h>
  18 #include <linux/fs.h>
  19 #include <linux/kmod.h>
  20 #include <linux/ctype.h>
  21 #include <linux/devfs_fs_kernel.h>
  22
  23 #include "check.h"
  24 #include "devfs.h"
  25
  26 #include "acorn.h"
  27 #include "amiga.h"
  28 #include "atari.h"
  29 #include "ldm.h"
  30 #include "mac.h"
  31 #include "msdos.h"
  32 #include "osf.h"
  33 #include "sgi.h"
  34 #include "sun.h"
  35 #include "ibm.h"
  36 #include "ultrix.h"
  37 #include "efi.h"
  38
  39 #ifdef CONFIG_BLK_DEV_MD
  40 extern void md_autodetect_dev(dev_t dev);
  41 #endif
  42
  43 int warn_no_part = 1; /*This is ugly: should make genhd removable media aware*/
  44
  45 static int (*check_part[])(struct parsed_partitions *, struct block_device *) = {
  46         /*
  47          * Probe partition formats with tables at disk address 0
  48          * that also have an ADFS boot block at 0xdc0.
  49          */
  50 #ifdef CONFIG_ACORN_PARTITION_ICS
  51         adfspart_check_ICS,
  52 #endif
  53 #ifdef CONFIG_ACORN_PARTITION_POWERTEC
  54         adfspart_check_POWERTEC,
  55 #endif
  56 #ifdef CONFIG_ACORN_PARTITION_EESOX
  57         adfspart_check_EESOX,
  58 #endif
  59
  60         /*
  61          * Now move on to formats that only have partition info at
  62          * disk address 0xdc0.  Since these may also have stale
  63          * PC/BIOS partition tables, they need to come before
  64          * the msdos entry.
  65          */
  66 #ifdef CONFIG_ACORN_PARTITION_CUMANA
  67         adfspart_check_CUMANA,
  68 #endif
  69 #ifdef CONFIG_ACORN_PARTITION_ADFS
  70         adfspart_check_ADFS,
  71 #endif
  72
  73 #ifdef CONFIG_EFI_PARTITION
  74         efi_partition,          /* this must come before msdos */
  75 #endif
  76 #ifdef CONFIG_LDM_PARTITION
  77         ldm_partition,          /* this must come before msdos */
  78 #endif
  79 #ifdef CONFIG_NEC98_PARTITION
  80         nec98_partition,        /* must be come before `msdos_partition' */
  81 #endif
  82 #ifdef CONFIG_MSDOS_PARTITION
  83         msdos_partition,
  84 #endif
  85 #ifdef CONFIG_OSF_PARTITION
  86         osf_partition,
  87 #endif
  88 #ifdef CONFIG_SUN_PARTITION
  89         sun_partition,
  90 #endif
  91 #ifdef CONFIG_AMIGA_PARTITION
  92         amiga_partition,
  93 #endif
  94 #ifdef CONFIG_ATARI_PARTITION
  95         atari_partition,
  96 #endif
  97 #ifdef CONFIG_MAC_PARTITION
  98         mac_partition,
  99 #endif
 100 #ifdef CONFIG_SGI_PARTITION
 101         sgi_partition,
 102 #endif
 103 #ifdef CONFIG_ULTRIX_PARTITION
 104         ultrix_partition,
 105 #endif
 106 #ifdef CONFIG_IBM_PARTITION
 107         ibm_partition,
 108 #endif
 109         NULL
 110 };
 111
 112 /*
 113  * disk_name() is used by partition check code and the genhd driver.
 114  * It formats the devicename of the indicated disk into
 115  * the supplied buffer (of size at least 32), and returns
 116  * a pointer to that same buffer (for convenience).
 117  */
 118
 119 char *disk_name(struct gendisk *hd, int part, char *buf)
 120 {
 121         if (!part)
 122                 snprintf(buf, BDEVNAME_SIZE, "%s", hd->disk_name);
 123         else if (isdigit(hd->disk_name[strlen(hd->disk_name)-1]))
 124                 snprintf(buf, BDEVNAME_SIZE, "%sp%d", hd->disk_name, part);
 125         else
 126                 snprintf(buf, BDEVNAME_SIZE, "%s%d", hd->disk_name, part);
 127
 128         return buf;
 129 }
 130
 131 const char *bdevname(struct block_device *bdev, char *buf)
 132 {
 133         int part = MINOR(bdev->bd_dev) - bdev->bd_disk->first_minor;
 134         return disk_name(bdev->bd_disk, part, buf);
 135 }
 136
 137 EXPORT_SYMBOL(bdevname);
 138
 139 /*
 140  * NOTE: this cannot be called from interrupt context.
 141  *
 142  * But in interrupt context you should really have a struct
 143  * block_device anyway and use bdevname() above.
 144  */
 145 const char *__bdevname(dev_t dev, char *buffer)
 146 {
 147         struct gendisk *disk;
 148         int part;
 149
 150         disk = get_gendisk(dev, &part);
 151         if (disk) {
 152                 buffer = disk_name(disk, part, buffer);
 153                 put_disk(disk);
 154         } else {
 155                 snprintf(buffer, BDEVNAME_SIZE, "unknown-block(%u,%u)",
 156                                 MAJOR(dev), MINOR(dev));
 157         }
 158
 159         return buffer;
 160 }
 161
 162 EXPORT_SYMBOL(__bdevname);
 163
 164 static struct parsed_partitions *
 165 check_partition(struct gendisk *hd, struct block_device *bdev)
 166 {
 167         struct parsed_partitions *state;
 168         int i, res;
 169
 170         state = kmalloc(sizeof(struct parsed_partitions), GFP_KERNEL);
 171         if (!state)
 172                 return NULL;
 173
 174 #ifdef CONFIG_DEVFS_FS
 175         if (hd->devfs_name[0] != '\0') {
 176                 printk(KERN_INFO " /dev/%s:", hd->devfs_name);
 177                 sprintf(state->name, "p");
 178         }
 179 #endif
 180         else {
 181                 disk_name(hd, 0, state->name);
 182                 printk(KERN_INFO " %s:", state->name);
 183                 if (isdigit(state->name[strlen(state->name)-1]))
 184                         sprintf(state->name, "p");
 185         }
 186         state->limit = hd->minors;
 187         i = res = 0;
 188         while (!res && check_part[i]) {
 189                 memset(&state->parts, 0, sizeof(state->parts));
 190                 res = check_part[i++](state, bdev);
 191         }
 192         if (res > 0)
 193                 return state;
 194         if (!res)
 195                 printk(" unknown partition table\n");
 196         else if (warn_no_part)
 197                 printk(" unable to read partition table\n");
 198         kfree(state);
 199         return NULL;
 200 }
 201
 202 /*
 203  * sysfs bindings for partitions
 204  */
 205
 206 struct part_attribute {
 207         struct attribute attr;
 208         ssize_t (*show)(struct hd_struct *,char *);
 209 };
 210
 211 static ssize_t
 212 part_attr_show(struct kobject * kobj, struct attribute * attr, char * page)
 213 {
 214         struct hd_struct * p = container_of(kobj,struct hd_struct,kobj);
 215         struct part_attribute * part_attr = container_of(attr,struct part_attribute,attr);
 216         ssize_t ret = 0;
 217         if (part_attr->show)
 218                 ret = part_attr->show(p,page);
 219         return ret;
 220 }
 221
 222 static struct sysfs_ops part_sysfs_ops = {
 223         .show   =       part_attr_show,
 224 };
 225
 226 static ssize_t part_dev_read(struct hd_struct * p, char *page)
 227 {
 228         struct gendisk *disk = container_of(p->kobj.parent,struct gendisk,kobj);
 229         dev_t dev = MKDEV(disk->major, disk->first_minor + p->partno);
 230         return print_dev_t(page, dev);
 231 }
 232 static ssize_t part_start_read(struct hd_struct * p, char *page)
 233 {
 234         return sprintf(page, "%llu\n",(unsigned long long)p->start_sect);
 235 }
 236 static ssize_t part_size_read(struct hd_struct * p, char *page)
 237 {
 238         return sprintf(page, "%llu\n",(unsigned long long)p->nr_sects);
 239 }
 240 static ssize_t part_stat_read(struct hd_struct * p, char *page)
 241 {
 242         return sprintf(page, "%8u %8llu %8u %8llu\n",
 243                        p->reads, (unsigned long long)p->read_sectors,
 244                        p->writes, (unsigned long long)p->write_sectors);
 245 }
 246 static struct part_attribute part_attr_dev = {
 247         .attr = {.name = "dev", .mode = S_IRUGO },
 248         .show   = part_dev_read
 249 };
 250 static struct part_attribute part_attr_start = {
 251         .attr = {.name = "start", .mode = S_IRUGO },
 252         .show   = part_start_read
 253 };
 254 static struct part_attribute part_attr_size = {
 255         .attr = {.name = "size", .mode = S_IRUGO },
 256         .show   = part_size_read
 257 };
 258 static struct part_attribute part_attr_stat = {
 259         .attr = {.name = "stat", .mode = S_IRUGO },
 260         .show   = part_stat_read
 261 };
 262
 263 static struct attribute * default_attrs[] = {
 264         &part_attr_dev.attr,
 265         &part_attr_start.attr,
 266         &part_attr_size.attr,
 267         &part_attr_stat.attr,
 268         NULL,
 269 };
 270
 271 extern struct subsystem block_subsys;
 272
 273 static void part_release(struct kobject *kobj)
 274 {
 275         struct hd_struct * p = container_of(kobj,struct hd_struct,kobj);
 276         kfree(p);
 277 }
 278
 279 struct kobj_type ktype_part = {
 280         .release        = part_release,
 281         .default_attrs  = default_attrs,
 282         .sysfs_ops      = &part_sysfs_ops,
 283 };
 284
 285 void delete_partition(struct gendisk *disk, int part)
 286 {
 287         struct hd_struct *p = disk->part[part-1];
 288         if (!p)
 289                 return;
 290         if (!p->nr_sects)
 291                 return;
 292         disk->part[part-1] = NULL;
 293         p->start_sect = 0;
 294         p->nr_sects = 0;
 295         p->reads = p->writes = p->read_sectors = p->write_sectors = 0;
 296         devfs_remove("%s/part%d", disk->devfs_name, part);
 297         kobject_unregister(&p->kobj);
 298 }
 299
 300 void add_partition(struct gendisk *disk, int part, sector_t start, sector_t len)
 301 {
 302         struct hd_struct *p;
 303
 304         p = kmalloc(sizeof(*p), GFP_KERNEL);
 305         if (!p)
 306                 return;
 307
 308         memset(p, 0, sizeof(*p));
 309         p->start_sect = start;
 310         p->nr_sects = len;
 311         p->partno = part;
 312
 313         devfs_mk_bdev(MKDEV(disk->major, disk->first_minor + part),
 314                         S_IFBLK|S_IRUSR|S_IWUSR,
 315                         "%s/part%d", disk->devfs_name, part);
 316
 317         if (isdigit(disk->kobj.name[strlen(disk->kobj.name)-1]))
 318                 snprintf(p->kobj.name,KOBJ_NAME_LEN,"%sp%d",disk->kobj.name,part);
 319         else
 320                 snprintf(p->kobj.name,KOBJ_NAME_LEN,"%s%d",disk->kobj.name,part);
 321         p->kobj.parent = &disk->kobj;
 322         p->kobj.ktype = &ktype_part;
 323         kobject_register(&p->kobj);
 324         disk->part[part-1] = p;
 325 }
 326
 327 static void disk_sysfs_symlinks(struct gendisk *disk)
 328 {
 329         struct device *target = get_device(disk->driverfs_dev);
 330         if (target) {
 331                 sysfs_create_link(&disk->kobj,&target->kobj,"device");
 332                 sysfs_create_link(&target->kobj,&disk->kobj,"block");
 333         }
 334 }
 335
 336 /* Not exported, helper to add_disk(). */
 337 void register_disk(struct gendisk *disk)
 338 {
 339         struct parsed_partitions *state;
 340         struct block_device *bdev;
 341         char *s;
 342         int j;
 343         int err;
 344
 345         strlcpy(disk->kobj.name,disk->disk_name,KOBJ_NAME_LEN);
 346         /* ewww... some of these buggers have / in name... */
 347         s = strchr(disk->kobj.name, '/');
 348         if (s)
 349                 *s = '!';
 350         if ((err = kobject_add(&disk->kobj)))
 351                 return;
 352         disk_sysfs_symlinks(disk);
 353
 354         /* No minors to use for partitions */
 355         if (disk->minors == 1) {
 356                 if (disk->devfs_name[0] != '\0')
 357                         devfs_add_disk(disk);
 358                 return;
 359         }
 360
 361         /* always add handle for the whole disk */
 362         devfs_add_partitioned(disk);
 363
 364         /* No such device (e.g., media were just removed) */
 365         if (!get_capacity(disk))
 366                 return;
 367
 368         bdev = bdget_disk(disk, 0);
 369         if (!bdev)
 370                 return;
 371
 372         if (blkdev_get(bdev, FMODE_READ, 0) < 0)
 373                 return;
 374         state = check_partition(disk, bdev);
 375         if (state) {
 376                 for (j = 1; j < state->limit; j++) {
 377                         sector_t size = state->parts[j].size;
 378                         sector_t from = state->parts[j].from;
 379                         if (!size)
 380                                 continue;
 381                         add_partition(disk, j, from, size);
 382 #ifdef CONFIG_BLK_DEV_MD
 383                         if (!state->parts[j].flags)
 384                                 continue;
 385                         md_autodetect_dev(bdev->bd_dev+j);
 386 #endif
 387                 }
 388                 kfree(state);
 389         }
 390         blkdev_put(bdev);
 391 }
 392
 393 int rescan_partitions(struct gendisk *disk, struct block_device *bdev)
 394 {
 395         struct parsed_partitions *state;
 396         int p, res;
 397
 398         if (bdev->bd_part_count)
 399                 return -EBUSY;
 400         res = invalidate_partition(disk, 0);
 401         if (res)
 402                 return res;
 403         bdev->bd_invalidated = 0;
 404         for (p = 1; p < disk->minors; p++)
 405                 delete_partition(disk, p);
 406         if (disk->fops->revalidate_disk)
 407                 disk->fops->revalidate_disk(disk);
 408         if (!get_capacity(disk) || !(state = check_partition(disk, bdev)))
 409                 return res;
 410         for (p = 1; p < state->limit; p++) {
 411                 sector_t size = state->parts[p].size;
 412                 sector_t from = state->parts[p].from;
 413                 if (!size)
 414                         continue;
 415                 add_partition(disk, p, from, size);
 416 #ifdef CONFIG_BLK_DEV_MD
 417                 if (state->parts[p].flags)
 418                         md_autodetect_dev(bdev->bd_dev+p);
 419 #endif
 420         }
 421         kfree(state);
 422         return res;
 423 }
 424
 425 unsigned char *read_dev_sector(struct block_device *bdev, sector_t n, Sector *p)
 426 {
 427         struct address_space *mapping = bdev->bd_inode->i_mapping;
 428         struct page *page;
 429
 430         page = read_cache_page(mapping, (pgoff_t)(n >> (PAGE_CACHE_SHIFT-9)),
 431                         (filler_t *)mapping->a_ops->readpage, NULL);
 432         if (!IS_ERR(page)) {
 433                 wait_on_page_locked(page);
 434                 if (!PageUptodate(page))
 435                         goto fail;
 436                 if (PageError(page))
 437                         goto fail;
 438                 p->v = page;
 439                 return (unsigned char *)page_address(page) +  ((n & ((1 << (PAGE_CACHE_SHIFT - 9)) - 1)) << 9);
 440 fail:
 441                 page_cache_release(page);
 442         }
 443         p->v = NULL;
 444         return NULL;
 445 }
 446
 447 EXPORT_SYMBOL(read_dev_sector);
 448
 449 void del_gendisk(struct gendisk *disk)
 450 {
 451         int p;
 452
 453         /* invalidate stuff */
 454         for (p = disk->minors - 1; p > 0; p--) {
 455                 invalidate_partition(disk, p);
 456                 delete_partition(disk, p);
 457         }
 458         invalidate_partition(disk, 0);
 459         disk->capacity = 0;
 460         disk->flags &= ~GENHD_FL_UP;
 461         unlink_gendisk(disk);
 462         disk_stat_set_all(disk, 0);
 463         disk->stamp = disk->stamp_idle = 0;
 464
 465         devfs_remove_disk(disk);
 466
 467         if (disk->driverfs_dev) {
 468                 sysfs_remove_link(&disk->kobj, "device");
 469                 sysfs_remove_link(&disk->driverfs_dev->kobj, "block");
 470                 put_device(disk->driverfs_dev);
 471         }
 472         kobject_del(&disk->kobj);
 473 }