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/slab.h>
20 #include <linux/kmod.h>
21 #include <linux/ctype.h>
22 #include <linux/genhd.h>
23 #include <linux/blktrace_api.h>
42 #ifdef CONFIG_BLK_DEV_MD
43 extern void md_autodetect_dev(dev_t dev
);
46 int warn_no_part
= 1; /*This is ugly: should make genhd removable media aware*/
48 static int (*check_part
[])(struct parsed_partitions
*) = {
50 * Probe partition formats with tables at disk address 0
51 * that also have an ADFS boot block at 0xdc0.
53 #ifdef CONFIG_ACORN_PARTITION_ICS
56 #ifdef CONFIG_ACORN_PARTITION_POWERTEC
57 adfspart_check_POWERTEC
,
59 #ifdef CONFIG_ACORN_PARTITION_EESOX
64 * Now move on to formats that only have partition info at
65 * disk address 0xdc0. Since these may also have stale
66 * PC/BIOS partition tables, they need to come before
69 #ifdef CONFIG_ACORN_PARTITION_CUMANA
70 adfspart_check_CUMANA
,
72 #ifdef CONFIG_ACORN_PARTITION_ADFS
76 #ifdef CONFIG_EFI_PARTITION
77 efi_partition
, /* this must come before msdos */
79 #ifdef CONFIG_SGI_PARTITION
82 #ifdef CONFIG_LDM_PARTITION
83 ldm_partition
, /* this must come before msdos */
85 #ifdef CONFIG_MSDOS_PARTITION
88 #ifdef CONFIG_OSF_PARTITION
91 #ifdef CONFIG_SUN_PARTITION
94 #ifdef CONFIG_AMIGA_PARTITION
97 #ifdef CONFIG_ATARI_PARTITION
100 #ifdef CONFIG_MAC_PARTITION
103 #ifdef CONFIG_ULTRIX_PARTITION
106 #ifdef CONFIG_IBM_PARTITION
109 #ifdef CONFIG_KARMA_PARTITION
112 #ifdef CONFIG_SYSV68_PARTITION
119 * disk_name() is used by partition check code and the genhd driver.
120 * It formats the devicename of the indicated disk into
121 * the supplied buffer (of size at least 32), and returns
122 * a pointer to that same buffer (for convenience).
125 char *disk_name(struct gendisk
*hd
, int partno
, char *buf
)
128 snprintf(buf
, BDEVNAME_SIZE
, "%s", hd
->disk_name
);
129 else if (isdigit(hd
->disk_name
[strlen(hd
->disk_name
)-1]))
130 snprintf(buf
, BDEVNAME_SIZE
, "%sp%d", hd
->disk_name
, partno
);
132 snprintf(buf
, BDEVNAME_SIZE
, "%s%d", hd
->disk_name
, partno
);
137 const char *bdevname(struct block_device
*bdev
, char *buf
)
139 return disk_name(bdev
->bd_disk
, bdev
->bd_part
->partno
, buf
);
142 EXPORT_SYMBOL(bdevname
);
145 * There's very little reason to use this, you should really
146 * have a struct block_device just about everywhere and use
147 * bdevname() instead.
149 const char *__bdevname(dev_t dev
, char *buffer
)
151 scnprintf(buffer
, BDEVNAME_SIZE
, "unknown-block(%u,%u)",
152 MAJOR(dev
), MINOR(dev
));
156 EXPORT_SYMBOL(__bdevname
);
158 static struct parsed_partitions
*
159 check_partition(struct gendisk
*hd
, struct block_device
*bdev
)
161 struct parsed_partitions
*state
;
164 state
= kzalloc(sizeof(struct parsed_partitions
), GFP_KERNEL
);
167 state
->pp_buf
= (char *)__get_free_page(GFP_KERNEL
);
168 if (!state
->pp_buf
) {
172 state
->pp_buf
[0] = '\0';
175 disk_name(hd
, 0, state
->name
);
176 snprintf(state
->pp_buf
, PAGE_SIZE
, " %s:", state
->name
);
177 if (isdigit(state
->name
[strlen(state
->name
)-1]))
178 sprintf(state
->name
, "p");
180 state
->limit
= disk_max_parts(hd
);
182 while (!res
&& check_part
[i
]) {
183 memset(&state
->parts
, 0, sizeof(state
->parts
));
184 res
= check_part
[i
++](state
);
186 /* We have hit an I/O error which we don't report now.
187 * But record it, and let the others do their job.
195 printk(KERN_INFO
"%s", state
->pp_buf
);
197 free_page((unsigned long)state
->pp_buf
);
200 if (state
->access_beyond_eod
)
203 /* The partition is unrecognized. So report I/O errors if there were any */
206 strlcat(state
->pp_buf
, " unknown partition table\n", PAGE_SIZE
);
207 else if (warn_no_part
)
208 strlcat(state
->pp_buf
, " unable to read partition table\n", PAGE_SIZE
);
210 printk(KERN_INFO
"%s", state
->pp_buf
);
212 free_page((unsigned long)state
->pp_buf
);
217 static ssize_t
part_partition_show(struct device
*dev
,
218 struct device_attribute
*attr
, char *buf
)
220 struct hd_struct
*p
= dev_to_part(dev
);
222 return sprintf(buf
, "%d\n", p
->partno
);
225 static ssize_t
part_start_show(struct device
*dev
,
226 struct device_attribute
*attr
, char *buf
)
228 struct hd_struct
*p
= dev_to_part(dev
);
230 return sprintf(buf
, "%llu\n",(unsigned long long)p
->start_sect
);
233 ssize_t
part_size_show(struct device
*dev
,
234 struct device_attribute
*attr
, char *buf
)
236 struct hd_struct
*p
= dev_to_part(dev
);
237 return sprintf(buf
, "%llu\n",(unsigned long long)p
->nr_sects
);
240 ssize_t
part_ro_show(struct device
*dev
,
241 struct device_attribute
*attr
, char *buf
)
243 struct hd_struct
*p
= dev_to_part(dev
);
244 return sprintf(buf
, "%d\n", p
->policy
? 1 : 0);
247 ssize_t
part_alignment_offset_show(struct device
*dev
,
248 struct device_attribute
*attr
, char *buf
)
250 struct hd_struct
*p
= dev_to_part(dev
);
251 return sprintf(buf
, "%llu\n", (unsigned long long)p
->alignment_offset
);
254 ssize_t
part_discard_alignment_show(struct device
*dev
,
255 struct device_attribute
*attr
, char *buf
)
257 struct hd_struct
*p
= dev_to_part(dev
);
258 struct gendisk
*disk
= dev_to_disk(dev
);
259 unsigned int alignment
= 0;
262 alignment
= queue_limit_discard_alignment(&disk
->queue
->limits
,
264 return sprintf(buf
, "%u\n", alignment
);
267 ssize_t
part_stat_show(struct device
*dev
,
268 struct device_attribute
*attr
, char *buf
)
270 struct hd_struct
*p
= dev_to_part(dev
);
273 cpu
= part_stat_lock();
274 part_round_stats(cpu
, p
);
277 "%8lu %8lu %8llu %8u "
278 "%8lu %8lu %8llu %8u "
281 part_stat_read(p
, ios
[READ
]),
282 part_stat_read(p
, merges
[READ
]),
283 (unsigned long long)part_stat_read(p
, sectors
[READ
]),
284 jiffies_to_msecs(part_stat_read(p
, ticks
[READ
])),
285 part_stat_read(p
, ios
[WRITE
]),
286 part_stat_read(p
, merges
[WRITE
]),
287 (unsigned long long)part_stat_read(p
, sectors
[WRITE
]),
288 jiffies_to_msecs(part_stat_read(p
, ticks
[WRITE
])),
290 jiffies_to_msecs(part_stat_read(p
, io_ticks
)),
291 jiffies_to_msecs(part_stat_read(p
, time_in_queue
)));
294 ssize_t
part_inflight_show(struct device
*dev
,
295 struct device_attribute
*attr
, char *buf
)
297 struct hd_struct
*p
= dev_to_part(dev
);
299 return sprintf(buf
, "%8u %8u\n", atomic_read(&p
->in_flight
[0]),
300 atomic_read(&p
->in_flight
[1]));
303 #ifdef CONFIG_FAIL_MAKE_REQUEST
304 ssize_t
part_fail_show(struct device
*dev
,
305 struct device_attribute
*attr
, char *buf
)
307 struct hd_struct
*p
= dev_to_part(dev
);
309 return sprintf(buf
, "%d\n", p
->make_it_fail
);
312 ssize_t
part_fail_store(struct device
*dev
,
313 struct device_attribute
*attr
,
314 const char *buf
, size_t count
)
316 struct hd_struct
*p
= dev_to_part(dev
);
319 if (count
> 0 && sscanf(buf
, "%d", &i
) > 0)
320 p
->make_it_fail
= (i
== 0) ? 0 : 1;
326 static DEVICE_ATTR(partition
, S_IRUGO
, part_partition_show
, NULL
);
327 static DEVICE_ATTR(start
, S_IRUGO
, part_start_show
, NULL
);
328 static DEVICE_ATTR(size
, S_IRUGO
, part_size_show
, NULL
);
329 static DEVICE_ATTR(ro
, S_IRUGO
, part_ro_show
, NULL
);
330 static DEVICE_ATTR(alignment_offset
, S_IRUGO
, part_alignment_offset_show
, NULL
);
331 static DEVICE_ATTR(discard_alignment
, S_IRUGO
, part_discard_alignment_show
,
333 static DEVICE_ATTR(stat
, S_IRUGO
, part_stat_show
, NULL
);
334 static DEVICE_ATTR(inflight
, S_IRUGO
, part_inflight_show
, NULL
);
335 #ifdef CONFIG_FAIL_MAKE_REQUEST
336 static struct device_attribute dev_attr_fail
=
337 __ATTR(make
-it
-fail
, S_IRUGO
|S_IWUSR
, part_fail_show
, part_fail_store
);
340 static struct attribute
*part_attrs
[] = {
341 &dev_attr_partition
.attr
,
342 &dev_attr_start
.attr
,
345 &dev_attr_alignment_offset
.attr
,
346 &dev_attr_discard_alignment
.attr
,
348 &dev_attr_inflight
.attr
,
349 #ifdef CONFIG_FAIL_MAKE_REQUEST
355 static struct attribute_group part_attr_group
= {
359 static const struct attribute_group
*part_attr_groups
[] = {
361 #ifdef CONFIG_BLK_DEV_IO_TRACE
362 &blk_trace_attr_group
,
367 static void part_release(struct device
*dev
)
369 struct hd_struct
*p
= dev_to_part(dev
);
375 struct device_type part_type
= {
377 .groups
= part_attr_groups
,
378 .release
= part_release
,
381 static void delete_partition_rcu_cb(struct rcu_head
*head
)
383 struct hd_struct
*part
= container_of(head
, struct hd_struct
, rcu_head
);
385 part
->start_sect
= 0;
387 part_stat_set_all(part
, 0);
388 put_device(part_to_dev(part
));
391 void __delete_partition(struct hd_struct
*part
)
393 call_rcu(&part
->rcu_head
, delete_partition_rcu_cb
);
396 void delete_partition(struct gendisk
*disk
, int partno
)
398 struct disk_part_tbl
*ptbl
= disk
->part_tbl
;
399 struct hd_struct
*part
;
401 if (partno
>= ptbl
->len
)
404 part
= ptbl
->part
[partno
];
408 blk_free_devt(part_devt(part
));
409 rcu_assign_pointer(ptbl
->part
[partno
], NULL
);
410 rcu_assign_pointer(ptbl
->last_lookup
, NULL
);
411 kobject_put(part
->holder_dir
);
412 device_del(part_to_dev(part
));
417 static ssize_t
whole_disk_show(struct device
*dev
,
418 struct device_attribute
*attr
, char *buf
)
422 static DEVICE_ATTR(whole_disk
, S_IRUSR
| S_IRGRP
| S_IROTH
,
423 whole_disk_show
, NULL
);
425 struct hd_struct
*add_partition(struct gendisk
*disk
, int partno
,
426 sector_t start
, sector_t len
, int flags
,
427 struct partition_meta_info
*info
)
430 dev_t devt
= MKDEV(0, 0);
431 struct device
*ddev
= disk_to_dev(disk
);
433 struct disk_part_tbl
*ptbl
;
437 err
= disk_expand_part_tbl(disk
, partno
);
440 ptbl
= disk
->part_tbl
;
442 if (ptbl
->part
[partno
])
443 return ERR_PTR(-EBUSY
);
445 p
= kzalloc(sizeof(*p
), GFP_KERNEL
);
447 return ERR_PTR(-EBUSY
);
449 if (!init_part_stats(p
)) {
453 pdev
= part_to_dev(p
);
455 p
->start_sect
= start
;
456 p
->alignment_offset
=
457 queue_limit_alignment_offset(&disk
->queue
->limits
, start
);
460 p
->policy
= get_disk_ro(disk
);
463 struct partition_meta_info
*pinfo
= alloc_part_info(disk
);
466 memcpy(pinfo
, info
, sizeof(*info
));
470 dname
= dev_name(ddev
);
471 if (isdigit(dname
[strlen(dname
) - 1]))
472 dev_set_name(pdev
, "%sp%d", dname
, partno
);
474 dev_set_name(pdev
, "%s%d", dname
, partno
);
476 device_initialize(pdev
);
477 pdev
->class = &block_class
;
478 pdev
->type
= &part_type
;
481 err
= blk_alloc_devt(p
, &devt
);
486 /* delay uevent until 'holders' subdir is created */
487 dev_set_uevent_suppress(pdev
, 1);
488 err
= device_add(pdev
);
493 p
->holder_dir
= kobject_create_and_add("holders", &pdev
->kobj
);
497 dev_set_uevent_suppress(pdev
, 0);
498 if (flags
& ADDPART_FLAG_WHOLEDISK
) {
499 err
= device_create_file(pdev
, &dev_attr_whole_disk
);
504 /* everything is up and running, commence */
505 rcu_assign_pointer(ptbl
->part
[partno
], p
);
507 /* suppress uevent if the disk suppresses it */
508 if (!dev_get_uevent_suppress(ddev
))
509 kobject_uevent(&pdev
->kobj
, KOBJ_ADD
);
522 kobject_put(p
->holder_dir
);
530 static bool disk_unlock_native_capacity(struct gendisk
*disk
)
532 const struct block_device_operations
*bdops
= disk
->fops
;
534 if (bdops
->unlock_native_capacity
&&
535 !(disk
->flags
& GENHD_FL_NATIVE_CAPACITY
)) {
536 printk(KERN_CONT
"enabling native capacity\n");
537 bdops
->unlock_native_capacity(disk
);
538 disk
->flags
|= GENHD_FL_NATIVE_CAPACITY
;
541 printk(KERN_CONT
"truncated\n");
546 int rescan_partitions(struct gendisk
*disk
, struct block_device
*bdev
)
548 struct parsed_partitions
*state
= NULL
;
549 struct disk_part_iter piter
;
550 struct hd_struct
*part
;
553 if (state
&& !IS_ERR(state
)) {
558 if (bdev
->bd_part_count
)
560 res
= invalidate_partition(disk
, 0);
564 disk_part_iter_init(&piter
, disk
, DISK_PITER_INCL_EMPTY
);
565 while ((part
= disk_part_iter_next(&piter
)))
566 delete_partition(disk
, part
->partno
);
567 disk_part_iter_exit(&piter
);
569 if (disk
->fops
->revalidate_disk
)
570 disk
->fops
->revalidate_disk(disk
);
571 check_disk_size_change(disk
, bdev
);
572 bdev
->bd_invalidated
= 0;
573 if (!get_capacity(disk
) || !(state
= check_partition(disk
, bdev
)))
577 * I/O error reading the partition table. If any
578 * partition code tried to read beyond EOD, retry
579 * after unlocking native capacity.
581 if (PTR_ERR(state
) == -ENOSPC
) {
582 printk(KERN_WARNING
"%s: partition table beyond EOD, ",
584 if (disk_unlock_native_capacity(disk
))
590 * If any partition code tried to read beyond EOD, try
591 * unlocking native capacity even if partition table is
592 * successfully read as we could be missing some partitions.
594 if (state
->access_beyond_eod
) {
596 "%s: partition table partially beyond EOD, ",
598 if (disk_unlock_native_capacity(disk
))
602 /* tell userspace that the media / partition table may have changed */
603 kobject_uevent(&disk_to_dev(disk
)->kobj
, KOBJ_CHANGE
);
605 /* Detect the highest partition number and preallocate
606 * disk->part_tbl. This is an optimization and not strictly
609 for (p
= 1, highest
= 0; p
< state
->limit
; p
++)
610 if (state
->parts
[p
].size
)
613 disk_expand_part_tbl(disk
, highest
);
616 for (p
= 1; p
< state
->limit
; p
++) {
618 struct partition_meta_info
*info
= NULL
;
620 size
= state
->parts
[p
].size
;
624 from
= state
->parts
[p
].from
;
625 if (from
>= get_capacity(disk
)) {
627 "%s: p%d start %llu is beyond EOD, ",
628 disk
->disk_name
, p
, (unsigned long long) from
);
629 if (disk_unlock_native_capacity(disk
))
634 if (from
+ size
> get_capacity(disk
)) {
636 "%s: p%d size %llu extends beyond EOD, ",
637 disk
->disk_name
, p
, (unsigned long long) size
);
639 if (disk_unlock_native_capacity(disk
)) {
640 /* free state and restart */
644 * we can not ignore partitions of broken tables
645 * created by for example camera firmware, but
646 * we limit them to the end of the disk to avoid
647 * creating invalid block devices
649 size
= get_capacity(disk
) - from
;
653 if (state
->parts
[p
].has_info
)
654 info
= &state
->parts
[p
].info
;
655 part
= add_partition(disk
, p
, from
, size
,
656 state
->parts
[p
].flags
,
657 &state
->parts
[p
].info
);
659 printk(KERN_ERR
" %s: p%d could not be added: %ld\n",
660 disk
->disk_name
, p
, -PTR_ERR(part
));
663 #ifdef CONFIG_BLK_DEV_MD
664 if (state
->parts
[p
].flags
& ADDPART_FLAG_RAID
)
665 md_autodetect_dev(part_to_dev(part
)->devt
);
672 unsigned char *read_dev_sector(struct block_device
*bdev
, sector_t n
, Sector
*p
)
674 struct address_space
*mapping
= bdev
->bd_inode
->i_mapping
;
677 page
= read_mapping_page(mapping
, (pgoff_t
)(n
>> (PAGE_CACHE_SHIFT
-9)),
683 return (unsigned char *)page_address(page
) + ((n
& ((1 << (PAGE_CACHE_SHIFT
- 9)) - 1)) << 9);
685 page_cache_release(page
);
691 EXPORT_SYMBOL(read_dev_sector
);