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
);
117 cpu
= part_stat_lock();
118 part_round_stats(cpu
, p
);
121 "%8lu %8lu %8llu %8u "
122 "%8lu %8lu %8llu %8u "
125 part_stat_read(p
, ios
[READ
]),
126 part_stat_read(p
, merges
[READ
]),
127 (unsigned long long)part_stat_read(p
, sectors
[READ
]),
128 jiffies_to_msecs(part_stat_read(p
, ticks
[READ
])),
129 part_stat_read(p
, ios
[WRITE
]),
130 part_stat_read(p
, merges
[WRITE
]),
131 (unsigned long long)part_stat_read(p
, sectors
[WRITE
]),
132 jiffies_to_msecs(part_stat_read(p
, ticks
[WRITE
])),
134 jiffies_to_msecs(part_stat_read(p
, io_ticks
)),
135 jiffies_to_msecs(part_stat_read(p
, time_in_queue
)));
138 ssize_t
part_inflight_show(struct device
*dev
,
139 struct device_attribute
*attr
, char *buf
)
141 struct hd_struct
*p
= dev_to_part(dev
);
143 return sprintf(buf
, "%8u %8u\n", atomic_read(&p
->in_flight
[0]),
144 atomic_read(&p
->in_flight
[1]));
147 #ifdef CONFIG_FAIL_MAKE_REQUEST
148 ssize_t
part_fail_show(struct device
*dev
,
149 struct device_attribute
*attr
, char *buf
)
151 struct hd_struct
*p
= dev_to_part(dev
);
153 return sprintf(buf
, "%d\n", p
->make_it_fail
);
156 ssize_t
part_fail_store(struct device
*dev
,
157 struct device_attribute
*attr
,
158 const char *buf
, size_t count
)
160 struct hd_struct
*p
= dev_to_part(dev
);
163 if (count
> 0 && sscanf(buf
, "%d", &i
) > 0)
164 p
->make_it_fail
= (i
== 0) ? 0 : 1;
170 static DEVICE_ATTR(partition
, S_IRUGO
, part_partition_show
, NULL
);
171 static DEVICE_ATTR(start
, S_IRUGO
, part_start_show
, NULL
);
172 static DEVICE_ATTR(size
, S_IRUGO
, part_size_show
, NULL
);
173 static DEVICE_ATTR(ro
, S_IRUGO
, part_ro_show
, NULL
);
174 static DEVICE_ATTR(alignment_offset
, S_IRUGO
, part_alignment_offset_show
, NULL
);
175 static DEVICE_ATTR(discard_alignment
, S_IRUGO
, part_discard_alignment_show
,
177 static DEVICE_ATTR(stat
, S_IRUGO
, part_stat_show
, NULL
);
178 static DEVICE_ATTR(inflight
, S_IRUGO
, part_inflight_show
, NULL
);
179 #ifdef CONFIG_FAIL_MAKE_REQUEST
180 static struct device_attribute dev_attr_fail
=
181 __ATTR(make
-it
-fail
, S_IRUGO
|S_IWUSR
, part_fail_show
, part_fail_store
);
184 static struct attribute
*part_attrs
[] = {
185 &dev_attr_partition
.attr
,
186 &dev_attr_start
.attr
,
189 &dev_attr_alignment_offset
.attr
,
190 &dev_attr_discard_alignment
.attr
,
192 &dev_attr_inflight
.attr
,
193 #ifdef CONFIG_FAIL_MAKE_REQUEST
199 static struct attribute_group part_attr_group
= {
203 static const struct attribute_group
*part_attr_groups
[] = {
205 #ifdef CONFIG_BLK_DEV_IO_TRACE
206 &blk_trace_attr_group
,
211 static void part_release(struct device
*dev
)
213 struct hd_struct
*p
= dev_to_part(dev
);
214 blk_free_devt(dev
->devt
);
220 static int part_uevent(struct device
*dev
, struct kobj_uevent_env
*env
)
222 struct hd_struct
*part
= dev_to_part(dev
);
224 add_uevent_var(env
, "PARTN=%u", part
->partno
);
225 if (part
->info
&& part
->info
->volname
[0])
226 add_uevent_var(env
, "PARTNAME=%s", part
->info
->volname
);
230 struct device_type part_type
= {
232 .groups
= part_attr_groups
,
233 .release
= part_release
,
234 .uevent
= part_uevent
,
237 static void delete_partition_rcu_cb(struct rcu_head
*head
)
239 struct hd_struct
*part
= container_of(head
, struct hd_struct
, rcu_head
);
241 part
->start_sect
= 0;
243 part_stat_set_all(part
, 0);
244 put_device(part_to_dev(part
));
247 void __delete_partition(struct hd_struct
*part
)
249 call_rcu(&part
->rcu_head
, delete_partition_rcu_cb
);
252 void delete_partition(struct gendisk
*disk
, int partno
)
254 struct disk_part_tbl
*ptbl
= disk
->part_tbl
;
255 struct hd_struct
*part
;
257 if (partno
>= ptbl
->len
)
260 part
= ptbl
->part
[partno
];
264 rcu_assign_pointer(ptbl
->part
[partno
], NULL
);
265 rcu_assign_pointer(ptbl
->last_lookup
, NULL
);
266 kobject_put(part
->holder_dir
);
267 device_del(part_to_dev(part
));
272 static ssize_t
whole_disk_show(struct device
*dev
,
273 struct device_attribute
*attr
, char *buf
)
277 static DEVICE_ATTR(whole_disk
, S_IRUSR
| S_IRGRP
| S_IROTH
,
278 whole_disk_show
, NULL
);
280 struct hd_struct
*add_partition(struct gendisk
*disk
, int partno
,
281 sector_t start
, sector_t len
, int flags
,
282 struct partition_meta_info
*info
)
285 dev_t devt
= MKDEV(0, 0);
286 struct device
*ddev
= disk_to_dev(disk
);
288 struct disk_part_tbl
*ptbl
;
292 err
= disk_expand_part_tbl(disk
, partno
);
295 ptbl
= disk
->part_tbl
;
297 if (ptbl
->part
[partno
])
298 return ERR_PTR(-EBUSY
);
300 p
= kzalloc(sizeof(*p
), GFP_KERNEL
);
302 return ERR_PTR(-EBUSY
);
304 if (!init_part_stats(p
)) {
309 seqcount_init(&p
->nr_sects_seq
);
310 pdev
= part_to_dev(p
);
312 p
->start_sect
= start
;
313 p
->alignment_offset
=
314 queue_limit_alignment_offset(&disk
->queue
->limits
, start
);
315 p
->discard_alignment
=
316 queue_limit_discard_alignment(&disk
->queue
->limits
, start
);
319 p
->policy
= get_disk_ro(disk
);
322 struct partition_meta_info
*pinfo
= alloc_part_info(disk
);
325 memcpy(pinfo
, info
, sizeof(*info
));
329 dname
= dev_name(ddev
);
330 if (isdigit(dname
[strlen(dname
) - 1]))
331 dev_set_name(pdev
, "%sp%d", dname
, partno
);
333 dev_set_name(pdev
, "%s%d", dname
, partno
);
335 device_initialize(pdev
);
336 pdev
->class = &block_class
;
337 pdev
->type
= &part_type
;
340 err
= blk_alloc_devt(p
, &devt
);
345 /* delay uevent until 'holders' subdir is created */
346 dev_set_uevent_suppress(pdev
, 1);
347 err
= device_add(pdev
);
352 p
->holder_dir
= kobject_create_and_add("holders", &pdev
->kobj
);
356 dev_set_uevent_suppress(pdev
, 0);
357 if (flags
& ADDPART_FLAG_WHOLEDISK
) {
358 err
= device_create_file(pdev
, &dev_attr_whole_disk
);
363 /* everything is up and running, commence */
364 rcu_assign_pointer(ptbl
->part
[partno
], p
);
366 /* suppress uevent if the disk suppresses it */
367 if (!dev_get_uevent_suppress(ddev
))
368 kobject_uevent(&pdev
->kobj
, KOBJ_ADD
);
381 kobject_put(p
->holder_dir
);
389 static bool disk_unlock_native_capacity(struct gendisk
*disk
)
391 const struct block_device_operations
*bdops
= disk
->fops
;
393 if (bdops
->unlock_native_capacity
&&
394 !(disk
->flags
& GENHD_FL_NATIVE_CAPACITY
)) {
395 printk(KERN_CONT
"enabling native capacity\n");
396 bdops
->unlock_native_capacity(disk
);
397 disk
->flags
|= GENHD_FL_NATIVE_CAPACITY
;
400 printk(KERN_CONT
"truncated\n");
405 static int drop_partitions(struct gendisk
*disk
, struct block_device
*bdev
)
407 struct disk_part_iter piter
;
408 struct hd_struct
*part
;
411 if (bdev
->bd_part_count
)
413 res
= invalidate_partition(disk
, 0);
417 disk_part_iter_init(&piter
, disk
, DISK_PITER_INCL_EMPTY
);
418 while ((part
= disk_part_iter_next(&piter
)))
419 delete_partition(disk
, part
->partno
);
420 disk_part_iter_exit(&piter
);
425 int rescan_partitions(struct gendisk
*disk
, struct block_device
*bdev
)
427 struct parsed_partitions
*state
= NULL
;
428 struct hd_struct
*part
;
431 if (state
&& !IS_ERR(state
)) {
432 free_partitions(state
);
436 res
= drop_partitions(disk
, bdev
);
440 if (disk
->fops
->revalidate_disk
)
441 disk
->fops
->revalidate_disk(disk
);
442 check_disk_size_change(disk
, bdev
);
443 bdev
->bd_invalidated
= 0;
444 if (!get_capacity(disk
) || !(state
= check_partition(disk
, bdev
)))
448 * I/O error reading the partition table. If any
449 * partition code tried to read beyond EOD, retry
450 * after unlocking native capacity.
452 if (PTR_ERR(state
) == -ENOSPC
) {
453 printk(KERN_WARNING
"%s: partition table beyond EOD, ",
455 if (disk_unlock_native_capacity(disk
))
461 * If any partition code tried to read beyond EOD, try
462 * unlocking native capacity even if partition table is
463 * successfully read as we could be missing some partitions.
465 if (state
->access_beyond_eod
) {
467 "%s: partition table partially beyond EOD, ",
469 if (disk_unlock_native_capacity(disk
))
473 /* tell userspace that the media / partition table may have changed */
474 kobject_uevent(&disk_to_dev(disk
)->kobj
, KOBJ_CHANGE
);
476 /* Detect the highest partition number and preallocate
477 * disk->part_tbl. This is an optimization and not strictly
480 for (p
= 1, highest
= 0; p
< state
->limit
; p
++)
481 if (state
->parts
[p
].size
)
484 disk_expand_part_tbl(disk
, highest
);
487 for (p
= 1; p
< state
->limit
; p
++) {
489 struct partition_meta_info
*info
= NULL
;
491 size
= state
->parts
[p
].size
;
495 from
= state
->parts
[p
].from
;
496 if (from
>= get_capacity(disk
)) {
498 "%s: p%d start %llu is beyond EOD, ",
499 disk
->disk_name
, p
, (unsigned long long) from
);
500 if (disk_unlock_native_capacity(disk
))
505 if (from
+ size
> get_capacity(disk
)) {
507 "%s: p%d size %llu extends beyond EOD, ",
508 disk
->disk_name
, p
, (unsigned long long) size
);
510 if (disk_unlock_native_capacity(disk
)) {
511 /* free state and restart */
515 * we can not ignore partitions of broken tables
516 * created by for example camera firmware, but
517 * we limit them to the end of the disk to avoid
518 * creating invalid block devices
520 size
= get_capacity(disk
) - from
;
524 if (state
->parts
[p
].has_info
)
525 info
= &state
->parts
[p
].info
;
526 printk("add_partition==[%s:p%d]==start = %llu,size = %llu\n", disk
->disk_name
, p
, (unsigned long long)from
, (unsigned long long)size
);
527 part
= add_partition(disk
, p
, from
, size
,
528 state
->parts
[p
].flags
,
529 &state
->parts
[p
].info
);
531 printk(KERN_ERR
" %s: p%d could not be added: %ld\n",
532 disk
->disk_name
, p
, -PTR_ERR(part
));
535 #ifdef CONFIG_BLK_DEV_MD
536 if (state
->parts
[p
].flags
& ADDPART_FLAG_RAID
)
537 md_autodetect_dev(part_to_dev(part
)->devt
);
540 free_partitions(state
);
544 int invalidate_partitions(struct gendisk
*disk
, struct block_device
*bdev
)
548 if (!bdev
->bd_invalidated
)
551 res
= drop_partitions(disk
, bdev
);
555 set_capacity(disk
, 0);
556 check_disk_size_change(disk
, bdev
);
557 bdev
->bd_invalidated
= 0;
558 /* tell userspace that the media / partition table may have changed */
559 kobject_uevent(&disk_to_dev(disk
)->kobj
, KOBJ_CHANGE
);
564 unsigned char *read_dev_sector(struct block_device
*bdev
, sector_t n
, Sector
*p
)
566 struct address_space
*mapping
= bdev
->bd_inode
->i_mapping
;
569 page
= read_mapping_page(mapping
, (pgoff_t
)(n
>> (PAGE_CACHE_SHIFT
-9)),
575 return (unsigned char *)page_address(page
) + ((n
& ((1 << (PAGE_CACHE_SHIFT
- 9)) - 1)) << 9);
577 page_cache_release(page
);
583 EXPORT_SYMBOL(read_dev_sector
);