1
2
3
4
5
6
7#include <linux/fs.h>
8#include <linux/slab.h>
9#include <linux/ctype.h>
10#include <linux/genhd.h>
11#include <linux/vmalloc.h>
12#include <linux/blktrace_api.h>
13#include <linux/raid/detect.h>
14#include "check.h"
15
16static int (*check_part[])(struct parsed_partitions *) = {
17
18
19
20
21#ifdef CONFIG_ACORN_PARTITION_ICS
22 adfspart_check_ICS,
23#endif
24#ifdef CONFIG_ACORN_PARTITION_POWERTEC
25 adfspart_check_POWERTEC,
26#endif
27#ifdef CONFIG_ACORN_PARTITION_EESOX
28 adfspart_check_EESOX,
29#endif
30
31
32
33
34
35
36
37#ifdef CONFIG_ACORN_PARTITION_CUMANA
38 adfspart_check_CUMANA,
39#endif
40#ifdef CONFIG_ACORN_PARTITION_ADFS
41 adfspart_check_ADFS,
42#endif
43
44#ifdef CONFIG_CMDLINE_PARTITION
45 cmdline_partition,
46#endif
47#ifdef CONFIG_EFI_PARTITION
48 efi_partition,
49#endif
50#ifdef CONFIG_SGI_PARTITION
51 sgi_partition,
52#endif
53#ifdef CONFIG_LDM_PARTITION
54 ldm_partition,
55#endif
56#ifdef CONFIG_MSDOS_PARTITION
57 msdos_partition,
58#endif
59#ifdef CONFIG_OSF_PARTITION
60 osf_partition,
61#endif
62#ifdef CONFIG_SUN_PARTITION
63 sun_partition,
64#endif
65#ifdef CONFIG_AMIGA_PARTITION
66 amiga_partition,
67#endif
68#ifdef CONFIG_ATARI_PARTITION
69 atari_partition,
70#endif
71#ifdef CONFIG_MAC_PARTITION
72 mac_partition,
73#endif
74#ifdef CONFIG_ULTRIX_PARTITION
75 ultrix_partition,
76#endif
77#ifdef CONFIG_IBM_PARTITION
78 ibm_partition,
79#endif
80#ifdef CONFIG_KARMA_PARTITION
81 karma_partition,
82#endif
83#ifdef CONFIG_SYSV68_PARTITION
84 sysv68_partition,
85#endif
86 NULL
87};
88
89static void bdev_set_nr_sectors(struct block_device *bdev, sector_t sectors)
90{
91 spin_lock(&bdev->bd_size_lock);
92 i_size_write(bdev->bd_inode, (loff_t)sectors << SECTOR_SHIFT);
93 spin_unlock(&bdev->bd_size_lock);
94}
95
96static struct parsed_partitions *allocate_partitions(struct gendisk *hd)
97{
98 struct parsed_partitions *state;
99 int nr;
100
101 state = kzalloc(sizeof(*state), GFP_KERNEL);
102 if (!state)
103 return NULL;
104
105 nr = disk_max_parts(hd);
106 state->parts = vzalloc(array_size(nr, sizeof(state->parts[0])));
107 if (!state->parts) {
108 kfree(state);
109 return NULL;
110 }
111
112 state->limit = nr;
113
114 return state;
115}
116
117static void free_partitions(struct parsed_partitions *state)
118{
119 vfree(state->parts);
120 kfree(state);
121}
122
123static struct parsed_partitions *check_partition(struct gendisk *hd)
124{
125 struct parsed_partitions *state;
126 int i, res, err;
127
128 state = allocate_partitions(hd);
129 if (!state)
130 return NULL;
131 state->pp_buf = (char *)__get_free_page(GFP_KERNEL);
132 if (!state->pp_buf) {
133 free_partitions(state);
134 return NULL;
135 }
136 state->pp_buf[0] = '\0';
137
138 state->disk = hd;
139 snprintf(state->name, BDEVNAME_SIZE, "%s", hd->disk_name);
140 snprintf(state->pp_buf, PAGE_SIZE, " %s:", state->name);
141 if (isdigit(state->name[strlen(state->name)-1]))
142 sprintf(state->name, "p");
143
144 i = res = err = 0;
145 while (!res && check_part[i]) {
146 memset(state->parts, 0, state->limit * sizeof(state->parts[0]));
147 res = check_part[i++](state);
148 if (res < 0) {
149
150
151
152
153 err = res;
154 res = 0;
155 }
156
157 }
158 if (res > 0) {
159 printk(KERN_INFO "%s", state->pp_buf);
160
161 free_page((unsigned long)state->pp_buf);
162 return state;
163 }
164 if (state->access_beyond_eod)
165 err = -ENOSPC;
166
167
168
169 if (err)
170 res = err;
171 if (res) {
172 strlcat(state->pp_buf,
173 " unable to read partition table\n", PAGE_SIZE);
174 printk(KERN_INFO "%s", state->pp_buf);
175 }
176
177 free_page((unsigned long)state->pp_buf);
178 free_partitions(state);
179 return ERR_PTR(res);
180}
181
182static ssize_t part_partition_show(struct device *dev,
183 struct device_attribute *attr, char *buf)
184{
185 return sprintf(buf, "%d\n", dev_to_bdev(dev)->bd_partno);
186}
187
188static ssize_t part_start_show(struct device *dev,
189 struct device_attribute *attr, char *buf)
190{
191 return sprintf(buf, "%llu\n", dev_to_bdev(dev)->bd_start_sect);
192}
193
194static ssize_t part_ro_show(struct device *dev,
195 struct device_attribute *attr, char *buf)
196{
197 return sprintf(buf, "%d\n", bdev_read_only(dev_to_bdev(dev)));
198}
199
200static ssize_t part_alignment_offset_show(struct device *dev,
201 struct device_attribute *attr, char *buf)
202{
203 struct block_device *bdev = dev_to_bdev(dev);
204
205 return sprintf(buf, "%u\n",
206 queue_limit_alignment_offset(&bdev->bd_disk->queue->limits,
207 bdev->bd_start_sect));
208}
209
210static ssize_t part_discard_alignment_show(struct device *dev,
211 struct device_attribute *attr, char *buf)
212{
213 struct block_device *bdev = dev_to_bdev(dev);
214
215 return sprintf(buf, "%u\n",
216 queue_limit_discard_alignment(&bdev->bd_disk->queue->limits,
217 bdev->bd_start_sect));
218}
219
220static DEVICE_ATTR(partition, 0444, part_partition_show, NULL);
221static DEVICE_ATTR(start, 0444, part_start_show, NULL);
222static DEVICE_ATTR(size, 0444, part_size_show, NULL);
223static DEVICE_ATTR(ro, 0444, part_ro_show, NULL);
224static DEVICE_ATTR(alignment_offset, 0444, part_alignment_offset_show, NULL);
225static DEVICE_ATTR(discard_alignment, 0444, part_discard_alignment_show, NULL);
226static DEVICE_ATTR(stat, 0444, part_stat_show, NULL);
227static DEVICE_ATTR(inflight, 0444, part_inflight_show, NULL);
228#ifdef CONFIG_FAIL_MAKE_REQUEST
229static struct device_attribute dev_attr_fail =
230 __ATTR(make-it-fail, 0644, part_fail_show, part_fail_store);
231#endif
232
233static struct attribute *part_attrs[] = {
234 &dev_attr_partition.attr,
235 &dev_attr_start.attr,
236 &dev_attr_size.attr,
237 &dev_attr_ro.attr,
238 &dev_attr_alignment_offset.attr,
239 &dev_attr_discard_alignment.attr,
240 &dev_attr_stat.attr,
241 &dev_attr_inflight.attr,
242#ifdef CONFIG_FAIL_MAKE_REQUEST
243 &dev_attr_fail.attr,
244#endif
245 NULL
246};
247
248static struct attribute_group part_attr_group = {
249 .attrs = part_attrs,
250};
251
252static const struct attribute_group *part_attr_groups[] = {
253 &part_attr_group,
254#ifdef CONFIG_BLK_DEV_IO_TRACE
255 &blk_trace_attr_group,
256#endif
257 NULL
258};
259
260static void part_release(struct device *dev)
261{
262 put_disk(dev_to_bdev(dev)->bd_disk);
263 iput(dev_to_bdev(dev)->bd_inode);
264}
265
266static int part_uevent(struct device *dev, struct kobj_uevent_env *env)
267{
268 struct block_device *part = dev_to_bdev(dev);
269
270 add_uevent_var(env, "PARTN=%u", part->bd_partno);
271 if (part->bd_meta_info && part->bd_meta_info->volname[0])
272 add_uevent_var(env, "PARTNAME=%s", part->bd_meta_info->volname);
273 return 0;
274}
275
276struct device_type part_type = {
277 .name = "partition",
278 .groups = part_attr_groups,
279 .release = part_release,
280 .uevent = part_uevent,
281};
282
283static void delete_partition(struct block_device *part)
284{
285 lockdep_assert_held(&part->bd_disk->open_mutex);
286
287 fsync_bdev(part);
288 __invalidate_device(part, true);
289
290 xa_erase(&part->bd_disk->part_tbl, part->bd_partno);
291 kobject_put(part->bd_holder_dir);
292 device_del(&part->bd_device);
293
294
295
296
297
298 remove_inode_hash(part->bd_inode);
299
300 put_device(&part->bd_device);
301}
302
303static ssize_t whole_disk_show(struct device *dev,
304 struct device_attribute *attr, char *buf)
305{
306 return 0;
307}
308static DEVICE_ATTR(whole_disk, 0444, whole_disk_show, NULL);
309
310
311
312
313
314static struct block_device *add_partition(struct gendisk *disk, int partno,
315 sector_t start, sector_t len, int flags,
316 struct partition_meta_info *info)
317{
318 dev_t devt = MKDEV(0, 0);
319 struct device *ddev = disk_to_dev(disk);
320 struct device *pdev;
321 struct block_device *bdev;
322 const char *dname;
323 int err;
324
325 lockdep_assert_held(&disk->open_mutex);
326
327 if (partno >= disk_max_parts(disk))
328 return ERR_PTR(-EINVAL);
329
330
331
332
333
334 switch (disk->queue->limits.zoned) {
335 case BLK_ZONED_HM:
336 pr_warn("%s: partitions not supported on host managed zoned block device\n",
337 disk->disk_name);
338 return ERR_PTR(-ENXIO);
339 case BLK_ZONED_HA:
340 pr_info("%s: disabling host aware zoned block device support due to partitions\n",
341 disk->disk_name);
342 blk_queue_set_zoned(disk, BLK_ZONED_NONE);
343 break;
344 case BLK_ZONED_NONE:
345 break;
346 }
347
348 if (xa_load(&disk->part_tbl, partno))
349 return ERR_PTR(-EBUSY);
350
351
352 get_device(disk_to_dev(disk));
353
354 err = -ENOMEM;
355 bdev = bdev_alloc(disk, partno);
356 if (!bdev)
357 goto out_put_disk;
358
359 bdev->bd_start_sect = start;
360 bdev_set_nr_sectors(bdev, len);
361
362 pdev = &bdev->bd_device;
363 dname = dev_name(ddev);
364 if (isdigit(dname[strlen(dname) - 1]))
365 dev_set_name(pdev, "%sp%d", dname, partno);
366 else
367 dev_set_name(pdev, "%s%d", dname, partno);
368
369 device_initialize(pdev);
370 pdev->class = &block_class;
371 pdev->type = &part_type;
372 pdev->parent = ddev;
373
374
375 if (bdev->bd_partno < disk->minors) {
376 devt = MKDEV(disk->major, disk->first_minor + bdev->bd_partno);
377 } else {
378 err = blk_alloc_ext_minor();
379 if (err < 0)
380 goto out_put;
381 devt = MKDEV(BLOCK_EXT_MAJOR, err);
382 }
383 pdev->devt = devt;
384
385 if (info) {
386 err = -ENOMEM;
387 bdev->bd_meta_info = kmemdup(info, sizeof(*info), GFP_KERNEL);
388 if (!bdev->bd_meta_info)
389 goto out_put;
390 }
391
392
393 dev_set_uevent_suppress(pdev, 1);
394 err = device_add(pdev);
395 if (err)
396 goto out_put;
397
398 err = -ENOMEM;
399 bdev->bd_holder_dir = kobject_create_and_add("holders", &pdev->kobj);
400 if (!bdev->bd_holder_dir)
401 goto out_del;
402
403 dev_set_uevent_suppress(pdev, 0);
404 if (flags & ADDPART_FLAG_WHOLEDISK) {
405 err = device_create_file(pdev, &dev_attr_whole_disk);
406 if (err)
407 goto out_del;
408 }
409
410
411 err = xa_insert(&disk->part_tbl, partno, bdev, GFP_KERNEL);
412 if (err)
413 goto out_del;
414 bdev_add(bdev, devt);
415
416
417 if (!dev_get_uevent_suppress(ddev))
418 kobject_uevent(&pdev->kobj, KOBJ_ADD);
419 return bdev;
420
421out_del:
422 kobject_put(bdev->bd_holder_dir);
423 device_del(pdev);
424out_put:
425 put_device(pdev);
426 return ERR_PTR(err);
427out_put_disk:
428 put_disk(disk);
429 return ERR_PTR(err);
430}
431
432static bool partition_overlaps(struct gendisk *disk, sector_t start,
433 sector_t length, int skip_partno)
434{
435 struct block_device *part;
436 bool overlap = false;
437 unsigned long idx;
438
439 rcu_read_lock();
440 xa_for_each_start(&disk->part_tbl, idx, part, 1) {
441 if (part->bd_partno != skip_partno &&
442 start < part->bd_start_sect + bdev_nr_sectors(part) &&
443 start + length > part->bd_start_sect) {
444 overlap = true;
445 break;
446 }
447 }
448 rcu_read_unlock();
449
450 return overlap;
451}
452
453int bdev_add_partition(struct gendisk *disk, int partno, sector_t start,
454 sector_t length)
455{
456 struct block_device *part;
457 int ret;
458
459 mutex_lock(&disk->open_mutex);
460 if (!disk_live(disk)) {
461 ret = -ENXIO;
462 goto out;
463 }
464
465 if (partition_overlaps(disk, start, length, -1)) {
466 ret = -EBUSY;
467 goto out;
468 }
469
470 part = add_partition(disk, partno, start, length,
471 ADDPART_FLAG_NONE, NULL);
472 ret = PTR_ERR_OR_ZERO(part);
473out:
474 mutex_unlock(&disk->open_mutex);
475 return ret;
476}
477
478int bdev_del_partition(struct gendisk *disk, int partno)
479{
480 struct block_device *part = NULL;
481 int ret = -ENXIO;
482
483 mutex_lock(&disk->open_mutex);
484 part = xa_load(&disk->part_tbl, partno);
485 if (!part)
486 goto out_unlock;
487
488 ret = -EBUSY;
489 if (part->bd_openers)
490 goto out_unlock;
491
492 delete_partition(part);
493 ret = 0;
494out_unlock:
495 mutex_unlock(&disk->open_mutex);
496 return ret;
497}
498
499int bdev_resize_partition(struct gendisk *disk, int partno, sector_t start,
500 sector_t length)
501{
502 struct block_device *part = NULL;
503 int ret = -ENXIO;
504
505 mutex_lock(&disk->open_mutex);
506 part = xa_load(&disk->part_tbl, partno);
507 if (!part)
508 goto out_unlock;
509
510 ret = -EINVAL;
511 if (start != part->bd_start_sect)
512 goto out_unlock;
513
514 ret = -EBUSY;
515 if (partition_overlaps(disk, start, length, partno))
516 goto out_unlock;
517
518 bdev_set_nr_sectors(part, length);
519
520 ret = 0;
521out_unlock:
522 mutex_unlock(&disk->open_mutex);
523 return ret;
524}
525
526static bool disk_unlock_native_capacity(struct gendisk *disk)
527{
528 const struct block_device_operations *bdops = disk->fops;
529
530 if (bdops->unlock_native_capacity &&
531 !(disk->flags & GENHD_FL_NATIVE_CAPACITY)) {
532 printk(KERN_CONT "enabling native capacity\n");
533 bdops->unlock_native_capacity(disk);
534 disk->flags |= GENHD_FL_NATIVE_CAPACITY;
535 return true;
536 } else {
537 printk(KERN_CONT "truncated\n");
538 return false;
539 }
540}
541
542void blk_drop_partitions(struct gendisk *disk)
543{
544 struct block_device *part;
545 unsigned long idx;
546
547 lockdep_assert_held(&disk->open_mutex);
548
549 xa_for_each_start(&disk->part_tbl, idx, part, 1)
550 delete_partition(part);
551}
552
553static bool blk_add_partition(struct gendisk *disk,
554 struct parsed_partitions *state, int p)
555{
556 sector_t size = state->parts[p].size;
557 sector_t from = state->parts[p].from;
558 struct block_device *part;
559
560 if (!size)
561 return true;
562
563 if (from >= get_capacity(disk)) {
564 printk(KERN_WARNING
565 "%s: p%d start %llu is beyond EOD, ",
566 disk->disk_name, p, (unsigned long long) from);
567 if (disk_unlock_native_capacity(disk))
568 return false;
569 return true;
570 }
571
572 if (from + size > get_capacity(disk)) {
573 printk(KERN_WARNING
574 "%s: p%d size %llu extends beyond EOD, ",
575 disk->disk_name, p, (unsigned long long) size);
576
577 if (disk_unlock_native_capacity(disk))
578 return false;
579
580
581
582
583
584
585 size = get_capacity(disk) - from;
586 }
587
588 part = add_partition(disk, p, from, size, state->parts[p].flags,
589 &state->parts[p].info);
590 if (IS_ERR(part) && PTR_ERR(part) != -ENXIO) {
591 printk(KERN_ERR " %s: p%d could not be added: %ld\n",
592 disk->disk_name, p, -PTR_ERR(part));
593 return true;
594 }
595
596 if (IS_BUILTIN(CONFIG_BLK_DEV_MD) &&
597 (state->parts[p].flags & ADDPART_FLAG_RAID))
598 md_autodetect_dev(part->bd_dev);
599
600 return true;
601}
602
603static int blk_add_partitions(struct gendisk *disk)
604{
605 struct parsed_partitions *state;
606 int ret = -EAGAIN, p;
607
608 if (!disk_part_scan_enabled(disk))
609 return 0;
610
611 state = check_partition(disk);
612 if (!state)
613 return 0;
614 if (IS_ERR(state)) {
615
616
617
618
619 if (PTR_ERR(state) == -ENOSPC) {
620 printk(KERN_WARNING "%s: partition table beyond EOD, ",
621 disk->disk_name);
622 if (disk_unlock_native_capacity(disk))
623 return -EAGAIN;
624 }
625 return -EIO;
626 }
627
628
629
630
631 if (disk->queue->limits.zoned == BLK_ZONED_HM) {
632 pr_warn("%s: ignoring partition table on host managed zoned block device\n",
633 disk->disk_name);
634 ret = 0;
635 goto out_free_state;
636 }
637
638
639
640
641
642
643 if (state->access_beyond_eod) {
644 printk(KERN_WARNING
645 "%s: partition table partially beyond EOD, ",
646 disk->disk_name);
647 if (disk_unlock_native_capacity(disk))
648 goto out_free_state;
649 }
650
651
652 kobject_uevent(&disk_to_dev(disk)->kobj, KOBJ_CHANGE);
653
654 for (p = 1; p < state->limit; p++)
655 if (!blk_add_partition(disk, state, p))
656 goto out_free_state;
657
658 ret = 0;
659out_free_state:
660 free_partitions(state);
661 return ret;
662}
663
664int bdev_disk_changed(struct gendisk *disk, bool invalidate)
665{
666 int ret = 0;
667
668 lockdep_assert_held(&disk->open_mutex);
669
670 if (!disk_live(disk))
671 return -ENXIO;
672
673rescan:
674 if (disk->open_partitions)
675 return -EBUSY;
676 sync_blockdev(disk->part0);
677 invalidate_bdev(disk->part0);
678 blk_drop_partitions(disk);
679
680 clear_bit(GD_NEED_PART_SCAN, &disk->state);
681
682
683
684
685
686
687
688
689
690 if (invalidate) {
691 if (disk_part_scan_enabled(disk) ||
692 !(disk->flags & GENHD_FL_REMOVABLE))
693 set_capacity(disk, 0);
694 }
695
696 if (get_capacity(disk)) {
697 ret = blk_add_partitions(disk);
698 if (ret == -EAGAIN)
699 goto rescan;
700 } else if (invalidate) {
701
702
703
704
705 kobject_uevent(&disk_to_dev(disk)->kobj, KOBJ_CHANGE);
706 }
707
708 return ret;
709}
710
711
712
713
714EXPORT_SYMBOL_GPL(bdev_disk_changed);
715
716void *read_part_sector(struct parsed_partitions *state, sector_t n, Sector *p)
717{
718 struct address_space *mapping = state->disk->part0->bd_inode->i_mapping;
719 struct page *page;
720
721 if (n >= get_capacity(state->disk)) {
722 state->access_beyond_eod = true;
723 return NULL;
724 }
725
726 page = read_mapping_page(mapping,
727 (pgoff_t)(n >> (PAGE_SHIFT - 9)), NULL);
728 if (IS_ERR(page))
729 goto out;
730 if (PageError(page))
731 goto out_put_page;
732
733 p->v = page;
734 return (unsigned char *)page_address(page) +
735 ((n & ((1 << (PAGE_SHIFT - 9)) - 1)) << SECTOR_SHIFT);
736out_put_page:
737 put_page(page);
738out:
739 p->v = NULL;
740 return NULL;
741}
742