2 * Code extracted from drivers/block/genhd.c
3 * Copyright (C) 1991-1998 Linus Torvalds
4 * Re-organised Feb 1998 Russell King
6 * We now have independent partition support from the
7 * block drivers, which allows all the partition code to
8 * be grouped in one location, and it to be mostly self
12 #include <linux/init.h>
13 #include <linux/module.h>
15 #include <linux/slab.h>
16 #include <linux/kmod.h>
17 #include <linux/ctype.h>
18 #include <linux/genhd.h>
19 #include <linux/blktrace_api.h>
21 #include "partitions/check.h"
23 #ifdef CONFIG_BLK_DEV_MD
24 extern void md_autodetect_dev(dev_t dev
);
28 * disk_name() is used by partition check code and the genhd driver.
29 * It formats the devicename of the indicated disk into
30 * the supplied buffer (of size at least 32), and returns
31 * a pointer to that same buffer (for convenience).
34 char *disk_name(struct gendisk
*hd
, int partno
, char *buf
)
37 snprintf(buf
, BDEVNAME_SIZE
, "%s", hd
->disk_name
);
38 else if (isdigit(hd
->disk_name
[strlen(hd
->disk_name
)-1]))
39 snprintf(buf
, BDEVNAME_SIZE
, "%sp%d", hd
->disk_name
, partno
);
41 snprintf(buf
, BDEVNAME_SIZE
, "%s%d", hd
->disk_name
, partno
);
46 const char *bdevname(struct block_device
*bdev
, char *buf
)
48 return disk_name(bdev
->bd_disk
, bdev
->bd_part
->partno
, buf
);
51 EXPORT_SYMBOL(bdevname
);
54 * There's very little reason to use this, you should really
55 * have a struct block_device just about everywhere and use
58 const char *__bdevname(dev_t dev
, char *buffer
)
60 scnprintf(buffer
, BDEVNAME_SIZE
, "unknown-block(%u,%u)",
61 MAJOR(dev
), MINOR(dev
));
65 EXPORT_SYMBOL(__bdevname
);
67 static ssize_t
part_partition_show(struct device
*dev
,
68 struct device_attribute
*attr
, char *buf
)
70 struct hd_struct
*p
= dev_to_part(dev
);
72 return sprintf(buf
, "%d\n", p
->partno
);
75 static ssize_t
part_start_show(struct device
*dev
,
76 struct device_attribute
*attr
, char *buf
)
78 struct hd_struct
*p
= dev_to_part(dev
);
80 return sprintf(buf
, "%llu\n",(unsigned long long)p
->start_sect
);
83 ssize_t
part_size_show(struct device
*dev
,
84 struct device_attribute
*attr
, char *buf
)
86 struct hd_struct
*p
= dev_to_part(dev
);
87 return sprintf(buf
, "%llu\n",(unsigned long long)part_nr_sects_read(p
));
90 static ssize_t
part_ro_show(struct device
*dev
,
91 struct device_attribute
*attr
, char *buf
)
93 struct hd_struct
*p
= dev_to_part(dev
);
94 return sprintf(buf
, "%d\n", p
->policy
? 1 : 0);
97 static ssize_t
part_alignment_offset_show(struct device
*dev
,
98 struct device_attribute
*attr
, char *buf
)
100 struct hd_struct
*p
= dev_to_part(dev
);
101 return sprintf(buf
, "%llu\n", (unsigned long long)p
->alignment_offset
);
104 static ssize_t
part_discard_alignment_show(struct device
*dev
,
105 struct device_attribute
*attr
, char *buf
)
107 struct hd_struct
*p
= dev_to_part(dev
);
108 return sprintf(buf
, "%u\n", p
->discard_alignment
);
111 ssize_t
part_stat_show(struct device
*dev
,
112 struct device_attribute
*attr
, char *buf
)
114 struct hd_struct
*p
= dev_to_part(dev
);
115 struct request_queue
*q
= dev_to_disk(dev
)->queue
;
116 unsigned int inflight
[2];
119 cpu
= part_stat_lock();
120 part_round_stats(q
, cpu
, p
);
122 part_in_flight(q
, p
, inflight
);
124 "%8lu %8lu %8llu %8u "
125 "%8lu %8lu %8llu %8u "
128 part_stat_read(p
, ios
[READ
]),
129 part_stat_read(p
, merges
[READ
]),
130 (unsigned long long)part_stat_read(p
, sectors
[READ
]),
131 jiffies_to_msecs(part_stat_read(p
, ticks
[READ
])),
132 part_stat_read(p
, ios
[WRITE
]),
133 part_stat_read(p
, merges
[WRITE
]),
134 (unsigned long long)part_stat_read(p
, sectors
[WRITE
]),
135 jiffies_to_msecs(part_stat_read(p
, ticks
[WRITE
])),
137 jiffies_to_msecs(part_stat_read(p
, io_ticks
)),
138 jiffies_to_msecs(part_stat_read(p
, time_in_queue
)));
141 ssize_t
part_inflight_show(struct device
*dev
,
142 struct device_attribute
*attr
, char *buf
)
144 struct hd_struct
*p
= dev_to_part(dev
);
146 return sprintf(buf
, "%8u %8u\n", atomic_read(&p
->in_flight
[0]),
147 atomic_read(&p
->in_flight
[1]));
150 #ifdef CONFIG_FAIL_MAKE_REQUEST
151 ssize_t
part_fail_show(struct device
*dev
,
152 struct device_attribute
*attr
, char *buf
)
154 struct hd_struct
*p
= dev_to_part(dev
);
156 return sprintf(buf
, "%d\n", p
->make_it_fail
);
159 ssize_t
part_fail_store(struct device
*dev
,
160 struct device_attribute
*attr
,
161 const char *buf
, size_t count
)
163 struct hd_struct
*p
= dev_to_part(dev
);
166 if (count
> 0 && sscanf(buf
, "%d", &i
) > 0)
167 p
->make_it_fail
= (i
== 0) ? 0 : 1;
173 static DEVICE_ATTR(partition
, S_IRUGO
, part_partition_show
, NULL
);
174 static DEVICE_ATTR(start
, S_IRUGO
, part_start_show
, NULL
);
175 static DEVICE_ATTR(size
, S_IRUGO
, part_size_show
, NULL
);
176 static DEVICE_ATTR(ro
, S_IRUGO
, part_ro_show
, NULL
);
177 static DEVICE_ATTR(alignment_offset
, S_IRUGO
, part_alignment_offset_show
, NULL
);
178 static DEVICE_ATTR(discard_alignment
, S_IRUGO
, part_discard_alignment_show
,
180 static DEVICE_ATTR(stat
, S_IRUGO
, part_stat_show
, NULL
);
181 static DEVICE_ATTR(inflight
, S_IRUGO
, part_inflight_show
, NULL
);
182 #ifdef CONFIG_FAIL_MAKE_REQUEST
183 static struct device_attribute dev_attr_fail
=
184 __ATTR(make
-it
-fail
, S_IRUGO
|S_IWUSR
, part_fail_show
, part_fail_store
);
187 static struct attribute
*part_attrs
[] = {
188 &dev_attr_partition
.attr
,
189 &dev_attr_start
.attr
,
192 &dev_attr_alignment_offset
.attr
,
193 &dev_attr_discard_alignment
.attr
,
195 &dev_attr_inflight
.attr
,
196 #ifdef CONFIG_FAIL_MAKE_REQUEST
202 static struct attribute_group part_attr_group
= {
206 static const struct attribute_group
*part_attr_groups
[] = {
208 #ifdef CONFIG_BLK_DEV_IO_TRACE
209 &blk_trace_attr_group
,
214 static void part_release(struct device
*dev
)
216 struct hd_struct
*p
= dev_to_part(dev
);
217 blk_free_devt(dev
->devt
);
222 static int part_uevent(struct device
*dev
, struct kobj_uevent_env
*env
)
224 struct hd_struct
*part
= dev_to_part(dev
);
226 add_uevent_var(env
, "PARTN=%u", part
->partno
);
227 if (part
->info
&& part
->info
->volname
[0])
228 add_uevent_var(env
, "PARTNAME=%s", part
->info
->volname
);
232 struct device_type part_type
= {
234 .groups
= part_attr_groups
,
235 .release
= part_release
,
236 .uevent
= part_uevent
,
239 static void delete_partition_rcu_cb(struct rcu_head
*head
)
241 struct hd_struct
*part
= container_of(head
, struct hd_struct
, rcu_head
);
243 part
->start_sect
= 0;
245 part_stat_set_all(part
, 0);
246 put_device(part_to_dev(part
));
249 void __delete_partition(struct percpu_ref
*ref
)
251 struct hd_struct
*part
= container_of(ref
, struct hd_struct
, ref
);
252 call_rcu(&part
->rcu_head
, delete_partition_rcu_cb
);
256 * Must be called either with bd_mutex held, before a disk can be opened or
257 * after all disk users are gone.
259 void delete_partition(struct gendisk
*disk
, int partno
)
261 struct disk_part_tbl
*ptbl
=
262 rcu_dereference_protected(disk
->part_tbl
, 1);
263 struct hd_struct
*part
;
265 if (partno
>= ptbl
->len
)
268 part
= rcu_dereference_protected(ptbl
->part
[partno
], 1);
272 rcu_assign_pointer(ptbl
->part
[partno
], NULL
);
273 rcu_assign_pointer(ptbl
->last_lookup
, NULL
);
274 kobject_put(part
->holder_dir
);
275 device_del(part_to_dev(part
));
277 hd_struct_kill(part
);
280 static ssize_t
whole_disk_show(struct device
*dev
,
281 struct device_attribute
*attr
, char *buf
)
285 static DEVICE_ATTR(whole_disk
, S_IRUSR
| S_IRGRP
| S_IROTH
,
286 whole_disk_show
, NULL
);
289 * Must be called either with bd_mutex held, before a disk can be opened or
290 * after all disk users are gone.
292 struct hd_struct
*add_partition(struct gendisk
*disk
, int partno
,
293 sector_t start
, sector_t len
, int flags
,
294 struct partition_meta_info
*info
)
297 dev_t devt
= MKDEV(0, 0);
298 struct device
*ddev
= disk_to_dev(disk
);
300 struct disk_part_tbl
*ptbl
;
304 err
= disk_expand_part_tbl(disk
, partno
);
307 ptbl
= rcu_dereference_protected(disk
->part_tbl
, 1);
309 if (ptbl
->part
[partno
])
310 return ERR_PTR(-EBUSY
);
312 p
= kzalloc(sizeof(*p
), GFP_KERNEL
);
314 return ERR_PTR(-EBUSY
);
316 if (!init_part_stats(p
)) {
321 seqcount_init(&p
->nr_sects_seq
);
322 pdev
= part_to_dev(p
);
324 p
->start_sect
= start
;
325 p
->alignment_offset
=
326 queue_limit_alignment_offset(&disk
->queue
->limits
, start
);
327 p
->discard_alignment
=
328 queue_limit_discard_alignment(&disk
->queue
->limits
, start
);
331 p
->policy
= get_disk_ro(disk
);
334 struct partition_meta_info
*pinfo
= alloc_part_info(disk
);
339 memcpy(pinfo
, info
, sizeof(*info
));
343 dname
= dev_name(ddev
);
344 if (isdigit(dname
[strlen(dname
) - 1]))
345 dev_set_name(pdev
, "%sp%d", dname
, partno
);
347 dev_set_name(pdev
, "%s%d", dname
, partno
);
349 device_initialize(pdev
);
350 pdev
->class = &block_class
;
351 pdev
->type
= &part_type
;
354 err
= blk_alloc_devt(p
, &devt
);
359 /* delay uevent until 'holders' subdir is created */
360 dev_set_uevent_suppress(pdev
, 1);
361 err
= device_add(pdev
);
366 p
->holder_dir
= kobject_create_and_add("holders", &pdev
->kobj
);
370 dev_set_uevent_suppress(pdev
, 0);
371 if (flags
& ADDPART_FLAG_WHOLEDISK
) {
372 err
= device_create_file(pdev
, &dev_attr_whole_disk
);
377 err
= hd_ref_init(p
);
379 if (flags
& ADDPART_FLAG_WHOLEDISK
)
380 goto out_remove_file
;
384 /* everything is up and running, commence */
385 rcu_assign_pointer(ptbl
->part
[partno
], p
);
387 /* suppress uevent if the disk suppresses it */
388 if (!dev_get_uevent_suppress(ddev
))
389 kobject_uevent(&pdev
->kobj
, KOBJ_ADD
);
400 device_remove_file(pdev
, &dev_attr_whole_disk
);
402 kobject_put(p
->holder_dir
);
409 static bool disk_unlock_native_capacity(struct gendisk
*disk
)
411 const struct block_device_operations
*bdops
= disk
->fops
;
413 if (bdops
->unlock_native_capacity
&&
414 !(disk
->flags
& GENHD_FL_NATIVE_CAPACITY
)) {
415 printk(KERN_CONT
"enabling native capacity\n");
416 bdops
->unlock_native_capacity(disk
);
417 disk
->flags
|= GENHD_FL_NATIVE_CAPACITY
;
420 printk(KERN_CONT
"truncated\n");
425 static int drop_partitions(struct gendisk
*disk
, struct block_device
*bdev
)
427 struct disk_part_iter piter
;
428 struct hd_struct
*part
;
431 if (bdev
->bd_part_count
|| bdev
->bd_super
)
433 res
= invalidate_partition(disk
, 0);
437 disk_part_iter_init(&piter
, disk
, DISK_PITER_INCL_EMPTY
);
438 while ((part
= disk_part_iter_next(&piter
)))
439 delete_partition(disk
, part
->partno
);
440 disk_part_iter_exit(&piter
);
445 static bool part_zone_aligned(struct gendisk
*disk
,
446 struct block_device
*bdev
,
447 sector_t from
, sector_t size
)
449 unsigned int zone_sectors
= bdev_zone_sectors(bdev
);
452 * If this function is called, then the disk is a zoned block device
453 * (host-aware or host-managed). This can be detected even if the
454 * zoned block device support is disabled (CONFIG_BLK_DEV_ZONED not
455 * set). In this case, however, only host-aware devices will be seen
456 * as a block device is not created for host-managed devices. Without
457 * zoned block device support, host-aware drives can still be used as
458 * regular block devices (no zone operation) and their zone size will
459 * be reported as 0. Allow this case.
465 * Check partition start and size alignement. If the drive has a
466 * smaller last runt zone, ignore it and allow the partition to
467 * use it. Check the zone size too: it should be a power of 2 number
470 if (WARN_ON_ONCE(!is_power_of_2(zone_sectors
))) {
473 div_u64_rem(from
, zone_sectors
, &rem
);
476 if ((from
+ size
) < get_capacity(disk
)) {
477 div_u64_rem(size
, zone_sectors
, &rem
);
484 if (from
& (zone_sectors
- 1))
486 if ((from
+ size
) < get_capacity(disk
) &&
487 (size
& (zone_sectors
- 1)))
495 int rescan_partitions(struct gendisk
*disk
, struct block_device
*bdev
)
497 struct parsed_partitions
*state
= NULL
;
498 struct hd_struct
*part
;
501 if (state
&& !IS_ERR(state
)) {
502 free_partitions(state
);
506 res
= drop_partitions(disk
, bdev
);
510 if (disk
->fops
->revalidate_disk
)
511 disk
->fops
->revalidate_disk(disk
);
512 check_disk_size_change(disk
, bdev
);
513 bdev
->bd_invalidated
= 0;
514 if (!get_capacity(disk
) || !(state
= check_partition(disk
, bdev
)))
518 * I/O error reading the partition table. If any
519 * partition code tried to read beyond EOD, retry
520 * after unlocking native capacity.
522 if (PTR_ERR(state
) == -ENOSPC
) {
523 printk(KERN_WARNING
"%s: partition table beyond EOD, ",
525 if (disk_unlock_native_capacity(disk
))
531 * If any partition code tried to read beyond EOD, try
532 * unlocking native capacity even if partition table is
533 * successfully read as we could be missing some partitions.
535 if (state
->access_beyond_eod
) {
537 "%s: partition table partially beyond EOD, ",
539 if (disk_unlock_native_capacity(disk
))
543 /* tell userspace that the media / partition table may have changed */
544 kobject_uevent(&disk_to_dev(disk
)->kobj
, KOBJ_CHANGE
);
546 /* Detect the highest partition number and preallocate
547 * disk->part_tbl. This is an optimization and not strictly
550 for (p
= 1, highest
= 0; p
< state
->limit
; p
++)
551 if (state
->parts
[p
].size
)
554 disk_expand_part_tbl(disk
, highest
);
557 for (p
= 1; p
< state
->limit
; p
++) {
560 size
= state
->parts
[p
].size
;
564 from
= state
->parts
[p
].from
;
565 if (from
>= get_capacity(disk
)) {
567 "%s: p%d start %llu is beyond EOD, ",
568 disk
->disk_name
, p
, (unsigned long long) from
);
569 if (disk_unlock_native_capacity(disk
))
574 if (from
+ size
> get_capacity(disk
)) {
576 "%s: p%d size %llu extends beyond EOD, ",
577 disk
->disk_name
, p
, (unsigned long long) size
);
579 if (disk_unlock_native_capacity(disk
)) {
580 /* free state and restart */
584 * we can not ignore partitions of broken tables
585 * created by for example camera firmware, but
586 * we limit them to the end of the disk to avoid
587 * creating invalid block devices
589 size
= get_capacity(disk
) - from
;
594 * On a zoned block device, partitions should be aligned on the
595 * device zone size (i.e. zone boundary crossing not allowed).
596 * Otherwise, resetting the write pointer of the last zone of
597 * one partition may impact the following partition.
599 if (bdev_is_zoned(bdev
) &&
600 !part_zone_aligned(disk
, bdev
, from
, size
)) {
602 "%s: p%d start %llu+%llu is not zone aligned\n",
603 disk
->disk_name
, p
, (unsigned long long) from
,
604 (unsigned long long) size
);
608 part
= add_partition(disk
, p
, from
, size
,
609 state
->parts
[p
].flags
,
610 &state
->parts
[p
].info
);
612 printk(KERN_ERR
" %s: p%d could not be added: %ld\n",
613 disk
->disk_name
, p
, -PTR_ERR(part
));
616 #ifdef CONFIG_BLK_DEV_MD
617 if (state
->parts
[p
].flags
& ADDPART_FLAG_RAID
)
618 md_autodetect_dev(part_to_dev(part
)->devt
);
621 free_partitions(state
);
625 int invalidate_partitions(struct gendisk
*disk
, struct block_device
*bdev
)
629 if (!bdev
->bd_invalidated
)
632 res
= drop_partitions(disk
, bdev
);
636 set_capacity(disk
, 0);
637 check_disk_size_change(disk
, bdev
);
638 bdev
->bd_invalidated
= 0;
639 /* tell userspace that the media / partition table may have changed */
640 kobject_uevent(&disk_to_dev(disk
)->kobj
, KOBJ_CHANGE
);
645 unsigned char *read_dev_sector(struct block_device
*bdev
, sector_t n
, Sector
*p
)
647 struct address_space
*mapping
= bdev
->bd_inode
->i_mapping
;
650 page
= read_mapping_page(mapping
, (pgoff_t
)(n
>> (PAGE_SHIFT
-9)), NULL
);
655 return (unsigned char *)page_address(page
) + ((n
& ((1 << (PAGE_SHIFT
- 9)) - 1)) << 9);
663 EXPORT_SYMBOL(read_dev_sector
);