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