2 * fs/partitions/check.c
4 * Code extracted from drivers/block/genhd.c
5 * Copyright (C) 1991-1998 Linus Torvalds
6 * Re-organised Feb 1998 Russell King
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
13 * Added needed MAJORS for new pairs, {hdi,hdj}, {hdk,hdl}
16 #include <linux/init.h>
17 #include <linux/module.h>
19 #include <linux/kmod.h>
20 #include <linux/ctype.h>
21 #include <linux/genhd.h>
22 #include <linux/blktrace_api.h>
41 #ifdef CONFIG_BLK_DEV_MD
42 extern void md_autodetect_dev(dev_t dev
);
45 int warn_no_part
= 1; /*This is ugly: should make genhd removable media aware*/
47 static int (*check_part
[])(struct parsed_partitions
*, struct block_device
*) = {
49 * Probe partition formats with tables at disk address 0
50 * that also have an ADFS boot block at 0xdc0.
52 #ifdef CONFIG_ACORN_PARTITION_ICS
55 #ifdef CONFIG_ACORN_PARTITION_POWERTEC
56 adfspart_check_POWERTEC
,
58 #ifdef CONFIG_ACORN_PARTITION_EESOX
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
68 #ifdef CONFIG_ACORN_PARTITION_CUMANA
69 adfspart_check_CUMANA
,
71 #ifdef CONFIG_ACORN_PARTITION_ADFS
75 #ifdef CONFIG_EFI_PARTITION
76 efi_partition
, /* this must come before msdos */
78 #ifdef CONFIG_SGI_PARTITION
81 #ifdef CONFIG_LDM_PARTITION
82 ldm_partition
, /* this must come before msdos */
84 #ifdef CONFIG_MSDOS_PARTITION
87 #ifdef CONFIG_OSF_PARTITION
90 #ifdef CONFIG_SUN_PARTITION
93 #ifdef CONFIG_AMIGA_PARTITION
96 #ifdef CONFIG_ATARI_PARTITION
99 #ifdef CONFIG_MAC_PARTITION
102 #ifdef CONFIG_ULTRIX_PARTITION
105 #ifdef CONFIG_IBM_PARTITION
108 #ifdef CONFIG_KARMA_PARTITION
111 #ifdef CONFIG_SYSV68_PARTITION
118 * disk_name() is used by partition check code and the genhd driver.
119 * It formats the devicename of the indicated disk into
120 * the supplied buffer (of size at least 32), and returns
121 * a pointer to that same buffer (for convenience).
124 char *disk_name(struct gendisk
*hd
, int partno
, char *buf
)
127 snprintf(buf
, BDEVNAME_SIZE
, "%s", hd
->disk_name
);
128 else if (isdigit(hd
->disk_name
[strlen(hd
->disk_name
)-1]))
129 snprintf(buf
, BDEVNAME_SIZE
, "%sp%d", hd
->disk_name
, partno
);
131 snprintf(buf
, BDEVNAME_SIZE
, "%s%d", hd
->disk_name
, partno
);
136 const char *bdevname(struct block_device
*bdev
, char *buf
)
138 return disk_name(bdev
->bd_disk
, bdev
->bd_part
->partno
, buf
);
141 EXPORT_SYMBOL(bdevname
);
144 * There's very little reason to use this, you should really
145 * have a struct block_device just about everywhere and use
146 * bdevname() instead.
148 const char *__bdevname(dev_t dev
, char *buffer
)
150 scnprintf(buffer
, BDEVNAME_SIZE
, "unknown-block(%u,%u)",
151 MAJOR(dev
), MINOR(dev
));
155 EXPORT_SYMBOL(__bdevname
);
157 static struct parsed_partitions
*
158 check_partition(struct gendisk
*hd
, struct block_device
*bdev
)
160 struct parsed_partitions
*state
;
163 state
= kmalloc(sizeof(struct parsed_partitions
), GFP_KERNEL
);
167 disk_name(hd
, 0, state
->name
);
168 printk(KERN_INFO
" %s:", state
->name
);
169 if (isdigit(state
->name
[strlen(state
->name
)-1]))
170 sprintf(state
->name
, "p");
172 state
->limit
= disk_max_parts(hd
);
174 while (!res
&& check_part
[i
]) {
175 memset(&state
->parts
, 0, sizeof(state
->parts
));
176 res
= check_part
[i
++](state
, bdev
);
178 /* We have hit an I/O error which we don't report now.
179 * But record it, and let the others do their job.
189 /* The partition is unrecognized. So report I/O errors if there were any */
192 printk(" unknown partition table\n");
193 else if (warn_no_part
)
194 printk(" unable to read partition table\n");
199 static ssize_t
part_partition_show(struct device
*dev
,
200 struct device_attribute
*attr
, char *buf
)
202 struct hd_struct
*p
= dev_to_part(dev
);
204 return sprintf(buf
, "%d\n", p
->partno
);
207 static ssize_t
part_start_show(struct device
*dev
,
208 struct device_attribute
*attr
, char *buf
)
210 struct hd_struct
*p
= dev_to_part(dev
);
212 return sprintf(buf
, "%llu\n",(unsigned long long)p
->start_sect
);
215 ssize_t
part_size_show(struct device
*dev
,
216 struct device_attribute
*attr
, char *buf
)
218 struct hd_struct
*p
= dev_to_part(dev
);
219 return sprintf(buf
, "%llu\n",(unsigned long long)p
->nr_sects
);
222 ssize_t
part_alignment_offset_show(struct device
*dev
,
223 struct device_attribute
*attr
, char *buf
)
225 struct hd_struct
*p
= dev_to_part(dev
);
226 return sprintf(buf
, "%llu\n", (unsigned long long)p
->alignment_offset
);
229 ssize_t
part_discard_alignment_show(struct device
*dev
,
230 struct device_attribute
*attr
, char *buf
)
232 struct hd_struct
*p
= dev_to_part(dev
);
233 return sprintf(buf
, "%u\n", p
->discard_alignment
);
236 ssize_t
part_stat_show(struct device
*dev
,
237 struct device_attribute
*attr
, char *buf
)
239 struct hd_struct
*p
= dev_to_part(dev
);
242 cpu
= part_stat_lock();
243 part_round_stats(cpu
, p
);
246 "%8lu %8lu %8llu %8u "
247 "%8lu %8lu %8llu %8u "
250 part_stat_read(p
, ios
[READ
]),
251 part_stat_read(p
, merges
[READ
]),
252 (unsigned long long)part_stat_read(p
, sectors
[READ
]),
253 jiffies_to_msecs(part_stat_read(p
, ticks
[READ
])),
254 part_stat_read(p
, ios
[WRITE
]),
255 part_stat_read(p
, merges
[WRITE
]),
256 (unsigned long long)part_stat_read(p
, sectors
[WRITE
]),
257 jiffies_to_msecs(part_stat_read(p
, ticks
[WRITE
])),
259 jiffies_to_msecs(part_stat_read(p
, io_ticks
)),
260 jiffies_to_msecs(part_stat_read(p
, time_in_queue
)));
263 ssize_t
part_inflight_show(struct device
*dev
,
264 struct device_attribute
*attr
, char *buf
)
266 struct hd_struct
*p
= dev_to_part(dev
);
268 return sprintf(buf
, "%8u %8u\n", p
->in_flight
[0], p
->in_flight
[1]);
271 #ifdef CONFIG_FAIL_MAKE_REQUEST
272 ssize_t
part_fail_show(struct device
*dev
,
273 struct device_attribute
*attr
, char *buf
)
275 struct hd_struct
*p
= dev_to_part(dev
);
277 return sprintf(buf
, "%d\n", p
->make_it_fail
);
280 ssize_t
part_fail_store(struct device
*dev
,
281 struct device_attribute
*attr
,
282 const char *buf
, size_t count
)
284 struct hd_struct
*p
= dev_to_part(dev
);
287 if (count
> 0 && sscanf(buf
, "%d", &i
) > 0)
288 p
->make_it_fail
= (i
== 0) ? 0 : 1;
294 static DEVICE_ATTR(partition
, S_IRUGO
, part_partition_show
, NULL
);
295 static DEVICE_ATTR(start
, S_IRUGO
, part_start_show
, NULL
);
296 static DEVICE_ATTR(size
, S_IRUGO
, part_size_show
, NULL
);
297 static DEVICE_ATTR(alignment_offset
, S_IRUGO
, part_alignment_offset_show
, NULL
);
298 static DEVICE_ATTR(discard_alignment
, S_IRUGO
, part_discard_alignment_show
,
300 static DEVICE_ATTR(stat
, S_IRUGO
, part_stat_show
, NULL
);
301 static DEVICE_ATTR(inflight
, S_IRUGO
, part_inflight_show
, NULL
);
302 #ifdef CONFIG_FAIL_MAKE_REQUEST
303 static struct device_attribute dev_attr_fail
=
304 __ATTR(make
-it
-fail
, S_IRUGO
|S_IWUSR
, part_fail_show
, part_fail_store
);
307 static struct attribute
*part_attrs
[] = {
308 &dev_attr_partition
.attr
,
309 &dev_attr_start
.attr
,
311 &dev_attr_alignment_offset
.attr
,
312 &dev_attr_discard_alignment
.attr
,
314 &dev_attr_inflight
.attr
,
315 #ifdef CONFIG_FAIL_MAKE_REQUEST
321 static struct attribute_group part_attr_group
= {
325 static const struct attribute_group
*part_attr_groups
[] = {
327 #ifdef CONFIG_BLK_DEV_IO_TRACE
328 &blk_trace_attr_group
,
333 static void part_release(struct device
*dev
)
335 struct hd_struct
*p
= dev_to_part(dev
);
340 struct device_type part_type
= {
342 .groups
= part_attr_groups
,
343 .release
= part_release
,
346 static void delete_partition_rcu_cb(struct rcu_head
*head
)
348 struct hd_struct
*part
= container_of(head
, struct hd_struct
, rcu_head
);
350 part
->start_sect
= 0;
352 part_stat_set_all(part
, 0);
353 put_device(part_to_dev(part
));
356 void delete_partition(struct gendisk
*disk
, int partno
)
358 struct disk_part_tbl
*ptbl
= disk
->part_tbl
;
359 struct hd_struct
*part
;
361 if (partno
>= ptbl
->len
)
364 part
= ptbl
->part
[partno
];
368 blk_free_devt(part_devt(part
));
369 rcu_assign_pointer(ptbl
->part
[partno
], NULL
);
370 rcu_assign_pointer(ptbl
->last_lookup
, NULL
);
371 kobject_put(part
->holder_dir
);
372 device_del(part_to_dev(part
));
374 call_rcu(&part
->rcu_head
, delete_partition_rcu_cb
);
377 static ssize_t
whole_disk_show(struct device
*dev
,
378 struct device_attribute
*attr
, char *buf
)
382 static DEVICE_ATTR(whole_disk
, S_IRUSR
| S_IRGRP
| S_IROTH
,
383 whole_disk_show
, NULL
);
385 struct hd_struct
*add_partition(struct gendisk
*disk
, int partno
,
386 sector_t start
, sector_t len
, int flags
)
389 dev_t devt
= MKDEV(0, 0);
390 struct device
*ddev
= disk_to_dev(disk
);
392 struct disk_part_tbl
*ptbl
;
396 err
= disk_expand_part_tbl(disk
, partno
);
399 ptbl
= disk
->part_tbl
;
401 if (ptbl
->part
[partno
])
402 return ERR_PTR(-EBUSY
);
404 p
= kzalloc(sizeof(*p
), GFP_KERNEL
);
406 return ERR_PTR(-EBUSY
);
408 if (!init_part_stats(p
)) {
412 pdev
= part_to_dev(p
);
414 p
->start_sect
= start
;
415 p
->alignment_offset
=
416 queue_limit_alignment_offset(&disk
->queue
->limits
, start
);
417 p
->discard_alignment
=
418 queue_limit_discard_alignment(&disk
->queue
->limits
, start
);
421 p
->policy
= get_disk_ro(disk
);
423 dname
= dev_name(ddev
);
424 if (isdigit(dname
[strlen(dname
) - 1]))
425 dev_set_name(pdev
, "%sp%d", dname
, partno
);
427 dev_set_name(pdev
, "%s%d", dname
, partno
);
429 device_initialize(pdev
);
430 pdev
->class = &block_class
;
431 pdev
->type
= &part_type
;
434 err
= blk_alloc_devt(p
, &devt
);
439 /* delay uevent until 'holders' subdir is created */
440 dev_set_uevent_suppress(pdev
, 1);
441 err
= device_add(pdev
);
446 p
->holder_dir
= kobject_create_and_add("holders", &pdev
->kobj
);
450 dev_set_uevent_suppress(pdev
, 0);
451 if (flags
& ADDPART_FLAG_WHOLEDISK
) {
452 err
= device_create_file(pdev
, &dev_attr_whole_disk
);
457 /* everything is up and running, commence */
458 INIT_RCU_HEAD(&p
->rcu_head
);
459 rcu_assign_pointer(ptbl
->part
[partno
], p
);
461 /* suppress uevent if the disk supresses it */
462 if (!dev_get_uevent_suppress(ddev
))
463 kobject_uevent(&pdev
->kobj
, KOBJ_ADD
);
473 kobject_put(p
->holder_dir
);
481 /* Not exported, helper to add_disk(). */
482 void register_disk(struct gendisk
*disk
)
484 struct device
*ddev
= disk_to_dev(disk
);
485 struct block_device
*bdev
;
486 struct disk_part_iter piter
;
487 struct hd_struct
*part
;
490 ddev
->parent
= disk
->driverfs_dev
;
492 dev_set_name(ddev
, disk
->disk_name
);
494 /* delay uevents, until we scanned partition table */
495 dev_set_uevent_suppress(ddev
, 1);
497 if (device_add(ddev
))
499 #ifndef CONFIG_SYSFS_DEPRECATED
500 err
= sysfs_create_link(block_depr
, &ddev
->kobj
,
501 kobject_name(&ddev
->kobj
));
507 disk
->part0
.holder_dir
= kobject_create_and_add("holders", &ddev
->kobj
);
508 disk
->slave_dir
= kobject_create_and_add("slaves", &ddev
->kobj
);
510 /* No minors to use for partitions */
511 if (!disk_partitionable(disk
))
514 /* No such device (e.g., media were just removed) */
515 if (!get_capacity(disk
))
518 bdev
= bdget_disk(disk
, 0);
522 bdev
->bd_invalidated
= 1;
523 err
= blkdev_get(bdev
, FMODE_READ
);
526 blkdev_put(bdev
, FMODE_READ
);
529 /* announce disk after possible partitions are created */
530 dev_set_uevent_suppress(ddev
, 0);
531 kobject_uevent(&ddev
->kobj
, KOBJ_ADD
);
533 /* announce possible partitions */
534 disk_part_iter_init(&piter
, disk
, 0);
535 while ((part
= disk_part_iter_next(&piter
)))
536 kobject_uevent(&part_to_dev(part
)->kobj
, KOBJ_ADD
);
537 disk_part_iter_exit(&piter
);
540 int rescan_partitions(struct gendisk
*disk
, struct block_device
*bdev
)
542 struct disk_part_iter piter
;
543 struct hd_struct
*part
;
544 struct parsed_partitions
*state
;
547 if (bdev
->bd_part_count
)
549 res
= invalidate_partition(disk
, 0);
553 disk_part_iter_init(&piter
, disk
, DISK_PITER_INCL_EMPTY
);
554 while ((part
= disk_part_iter_next(&piter
)))
555 delete_partition(disk
, part
->partno
);
556 disk_part_iter_exit(&piter
);
558 if (disk
->fops
->revalidate_disk
)
559 disk
->fops
->revalidate_disk(disk
);
560 check_disk_size_change(disk
, bdev
);
561 bdev
->bd_invalidated
= 0;
562 if (!get_capacity(disk
) || !(state
= check_partition(disk
, bdev
)))
564 if (IS_ERR(state
)) /* I/O error reading the partition table */
567 /* tell userspace that the media / partition table may have changed */
568 kobject_uevent(&disk_to_dev(disk
)->kobj
, KOBJ_CHANGE
);
570 /* Detect the highest partition number and preallocate
571 * disk->part_tbl. This is an optimization and not strictly
574 for (p
= 1, highest
= 0; p
< state
->limit
; p
++)
575 if (state
->parts
[p
].size
)
578 disk_expand_part_tbl(disk
, highest
);
581 for (p
= 1; p
< state
->limit
; p
++) {
584 size
= state
->parts
[p
].size
;
588 from
= state
->parts
[p
].from
;
589 if (from
>= get_capacity(disk
)) {
591 "%s: p%d ignored, start %llu is behind the end of the disk\n",
592 disk
->disk_name
, p
, (unsigned long long) from
);
596 if (from
+ size
> get_capacity(disk
)) {
597 const struct block_device_operations
*bdops
= disk
->fops
;
598 unsigned long long capacity
;
601 "%s: p%d size %llu exceeds device capacity, ",
602 disk
->disk_name
, p
, (unsigned long long) size
);
604 if (bdops
->set_capacity
&&
605 (disk
->flags
& GENHD_FL_NATIVE_CAPACITY
) == 0) {
606 printk(KERN_CONT
"enabling native capacity\n");
607 capacity
= bdops
->set_capacity(disk
, ~0ULL);
608 disk
->flags
|= GENHD_FL_NATIVE_CAPACITY
;
609 if (capacity
> get_capacity(disk
)) {
610 set_capacity(disk
, capacity
);
611 check_disk_size_change(disk
, bdev
);
612 bdev
->bd_invalidated
= 0;
617 * we can not ignore partitions of broken tables
618 * created by for example camera firmware, but
619 * we limit them to the end of the disk to avoid
620 * creating invalid block devices
622 printk(KERN_CONT
"limited to end of disk\n");
623 size
= get_capacity(disk
) - from
;
626 part
= add_partition(disk
, p
, from
, size
,
627 state
->parts
[p
].flags
);
629 printk(KERN_ERR
" %s: p%d could not be added: %ld\n",
630 disk
->disk_name
, p
, -PTR_ERR(part
));
633 #ifdef CONFIG_BLK_DEV_MD
634 if (state
->parts
[p
].flags
& ADDPART_FLAG_RAID
)
635 md_autodetect_dev(part_to_dev(part
)->devt
);
642 unsigned char *read_dev_sector(struct block_device
*bdev
, sector_t n
, Sector
*p
)
644 struct address_space
*mapping
= bdev
->bd_inode
->i_mapping
;
647 page
= read_mapping_page(mapping
, (pgoff_t
)(n
>> (PAGE_CACHE_SHIFT
-9)),
653 return (unsigned char *)page_address(page
) + ((n
& ((1 << (PAGE_CACHE_SHIFT
- 9)) - 1)) << 9);
655 page_cache_release(page
);
661 EXPORT_SYMBOL(read_dev_sector
);
663 void del_gendisk(struct gendisk
*disk
)
665 struct disk_part_iter piter
;
666 struct hd_struct
*part
;
668 /* invalidate stuff */
669 disk_part_iter_init(&piter
, disk
,
670 DISK_PITER_INCL_EMPTY
| DISK_PITER_REVERSE
);
671 while ((part
= disk_part_iter_next(&piter
))) {
672 invalidate_partition(disk
, part
->partno
);
673 delete_partition(disk
, part
->partno
);
675 disk_part_iter_exit(&piter
);
677 invalidate_partition(disk
, 0);
678 blk_free_devt(disk_to_dev(disk
)->devt
);
679 set_capacity(disk
, 0);
680 disk
->flags
&= ~GENHD_FL_UP
;
681 unlink_gendisk(disk
);
682 part_stat_set_all(&disk
->part0
, 0);
683 disk
->part0
.stamp
= 0;
685 kobject_put(disk
->part0
.holder_dir
);
686 kobject_put(disk
->slave_dir
);
687 disk
->driverfs_dev
= NULL
;
688 #ifndef CONFIG_SYSFS_DEPRECATED
689 sysfs_remove_link(block_depr
, dev_name(disk_to_dev(disk
)));
691 device_del(disk_to_dev(disk
));