1387048bfSChristoph Hellwig // SPDX-License-Identifier: GPL-2.0
2387048bfSChristoph Hellwig /*
3387048bfSChristoph Hellwig * Copyright (C) 1991-1998 Linus Torvalds
4387048bfSChristoph Hellwig * Re-organised Feb 1998 Russell King
57b51e703SChristoph Hellwig * Copyright (C) 2020 Christoph Hellwig
6387048bfSChristoph Hellwig */
7387048bfSChristoph Hellwig #include <linux/fs.h>
8b81e0c23SChristoph Hellwig #include <linux/major.h>
9387048bfSChristoph Hellwig #include <linux/slab.h>
10387048bfSChristoph Hellwig #include <linux/ctype.h>
11387048bfSChristoph Hellwig #include <linux/vmalloc.h>
12387048bfSChristoph Hellwig #include <linux/raid/detect.h>
13387048bfSChristoph Hellwig #include "check.h"
14387048bfSChristoph Hellwig
15539050f9SThomas Weißschuh static int (*const check_part[])(struct parsed_partitions *) = {
16387048bfSChristoph Hellwig /*
17387048bfSChristoph Hellwig * Probe partition formats with tables at disk address 0
18387048bfSChristoph Hellwig * that also have an ADFS boot block at 0xdc0.
19387048bfSChristoph Hellwig */
20387048bfSChristoph Hellwig #ifdef CONFIG_ACORN_PARTITION_ICS
21387048bfSChristoph Hellwig adfspart_check_ICS,
22387048bfSChristoph Hellwig #endif
23387048bfSChristoph Hellwig #ifdef CONFIG_ACORN_PARTITION_POWERTEC
24387048bfSChristoph Hellwig adfspart_check_POWERTEC,
25387048bfSChristoph Hellwig #endif
26387048bfSChristoph Hellwig #ifdef CONFIG_ACORN_PARTITION_EESOX
27387048bfSChristoph Hellwig adfspart_check_EESOX,
28387048bfSChristoph Hellwig #endif
29387048bfSChristoph Hellwig
30387048bfSChristoph Hellwig /*
31387048bfSChristoph Hellwig * Now move on to formats that only have partition info at
32387048bfSChristoph Hellwig * disk address 0xdc0. Since these may also have stale
33387048bfSChristoph Hellwig * PC/BIOS partition tables, they need to come before
34387048bfSChristoph Hellwig * the msdos entry.
35387048bfSChristoph Hellwig */
36387048bfSChristoph Hellwig #ifdef CONFIG_ACORN_PARTITION_CUMANA
37387048bfSChristoph Hellwig adfspart_check_CUMANA,
38387048bfSChristoph Hellwig #endif
39387048bfSChristoph Hellwig #ifdef CONFIG_ACORN_PARTITION_ADFS
40387048bfSChristoph Hellwig adfspart_check_ADFS,
41387048bfSChristoph Hellwig #endif
42387048bfSChristoph Hellwig
43387048bfSChristoph Hellwig #ifdef CONFIG_CMDLINE_PARTITION
44387048bfSChristoph Hellwig cmdline_partition,
45387048bfSChristoph Hellwig #endif
46387048bfSChristoph Hellwig #ifdef CONFIG_EFI_PARTITION
47387048bfSChristoph Hellwig efi_partition, /* this must come before msdos */
48387048bfSChristoph Hellwig #endif
49387048bfSChristoph Hellwig #ifdef CONFIG_SGI_PARTITION
50387048bfSChristoph Hellwig sgi_partition,
51387048bfSChristoph Hellwig #endif
52387048bfSChristoph Hellwig #ifdef CONFIG_LDM_PARTITION
53387048bfSChristoph Hellwig ldm_partition, /* this must come before msdos */
54387048bfSChristoph Hellwig #endif
55387048bfSChristoph Hellwig #ifdef CONFIG_MSDOS_PARTITION
56387048bfSChristoph Hellwig msdos_partition,
57387048bfSChristoph Hellwig #endif
58387048bfSChristoph Hellwig #ifdef CONFIG_OSF_PARTITION
59387048bfSChristoph Hellwig osf_partition,
60387048bfSChristoph Hellwig #endif
61387048bfSChristoph Hellwig #ifdef CONFIG_SUN_PARTITION
62387048bfSChristoph Hellwig sun_partition,
63387048bfSChristoph Hellwig #endif
64387048bfSChristoph Hellwig #ifdef CONFIG_AMIGA_PARTITION
65387048bfSChristoph Hellwig amiga_partition,
66387048bfSChristoph Hellwig #endif
67387048bfSChristoph Hellwig #ifdef CONFIG_ATARI_PARTITION
68387048bfSChristoph Hellwig atari_partition,
69387048bfSChristoph Hellwig #endif
70387048bfSChristoph Hellwig #ifdef CONFIG_MAC_PARTITION
71387048bfSChristoph Hellwig mac_partition,
72387048bfSChristoph Hellwig #endif
73387048bfSChristoph Hellwig #ifdef CONFIG_ULTRIX_PARTITION
74387048bfSChristoph Hellwig ultrix_partition,
75387048bfSChristoph Hellwig #endif
76387048bfSChristoph Hellwig #ifdef CONFIG_IBM_PARTITION
77387048bfSChristoph Hellwig ibm_partition,
78387048bfSChristoph Hellwig #endif
79387048bfSChristoph Hellwig #ifdef CONFIG_KARMA_PARTITION
80387048bfSChristoph Hellwig karma_partition,
81387048bfSChristoph Hellwig #endif
82387048bfSChristoph Hellwig #ifdef CONFIG_SYSV68_PARTITION
83387048bfSChristoph Hellwig sysv68_partition,
84387048bfSChristoph Hellwig #endif
85387048bfSChristoph Hellwig NULL
86387048bfSChristoph Hellwig };
87387048bfSChristoph Hellwig
allocate_partitions(struct gendisk * hd)88387048bfSChristoph Hellwig static struct parsed_partitions *allocate_partitions(struct gendisk *hd)
89387048bfSChristoph Hellwig {
90387048bfSChristoph Hellwig struct parsed_partitions *state;
911ebe2e5fSChristoph Hellwig int nr = DISK_MAX_PARTS;
92387048bfSChristoph Hellwig
93387048bfSChristoph Hellwig state = kzalloc(sizeof(*state), GFP_KERNEL);
94387048bfSChristoph Hellwig if (!state)
95387048bfSChristoph Hellwig return NULL;
96387048bfSChristoph Hellwig
97387048bfSChristoph Hellwig state->parts = vzalloc(array_size(nr, sizeof(state->parts[0])));
98387048bfSChristoph Hellwig if (!state->parts) {
99387048bfSChristoph Hellwig kfree(state);
100387048bfSChristoph Hellwig return NULL;
101387048bfSChristoph Hellwig }
102387048bfSChristoph Hellwig
103387048bfSChristoph Hellwig state->limit = nr;
104387048bfSChristoph Hellwig
105387048bfSChristoph Hellwig return state;
106387048bfSChristoph Hellwig }
107387048bfSChristoph Hellwig
free_partitions(struct parsed_partitions * state)108387048bfSChristoph Hellwig static void free_partitions(struct parsed_partitions *state)
109387048bfSChristoph Hellwig {
110387048bfSChristoph Hellwig vfree(state->parts);
111387048bfSChristoph Hellwig kfree(state);
112387048bfSChristoph Hellwig }
113387048bfSChristoph Hellwig
check_partition(struct gendisk * hd)1140384264eSChristoph Hellwig static struct parsed_partitions *check_partition(struct gendisk *hd)
115387048bfSChristoph Hellwig {
116387048bfSChristoph Hellwig struct parsed_partitions *state;
117387048bfSChristoph Hellwig int i, res, err;
118387048bfSChristoph Hellwig
119387048bfSChristoph Hellwig state = allocate_partitions(hd);
120387048bfSChristoph Hellwig if (!state)
121387048bfSChristoph Hellwig return NULL;
122387048bfSChristoph Hellwig state->pp_buf = (char *)__get_free_page(GFP_KERNEL);
123387048bfSChristoph Hellwig if (!state->pp_buf) {
124387048bfSChristoph Hellwig free_partitions(state);
125387048bfSChristoph Hellwig return NULL;
126387048bfSChristoph Hellwig }
127387048bfSChristoph Hellwig state->pp_buf[0] = '\0';
128387048bfSChristoph Hellwig
129a08aa9bcSChristoph Hellwig state->disk = hd;
1301d703547SChristoph Hellwig snprintf(state->name, BDEVNAME_SIZE, "%s", hd->disk_name);
131387048bfSChristoph Hellwig snprintf(state->pp_buf, PAGE_SIZE, " %s:", state->name);
132387048bfSChristoph Hellwig if (isdigit(state->name[strlen(state->name)-1]))
133387048bfSChristoph Hellwig sprintf(state->name, "p");
134387048bfSChristoph Hellwig
135387048bfSChristoph Hellwig i = res = err = 0;
136387048bfSChristoph Hellwig while (!res && check_part[i]) {
137387048bfSChristoph Hellwig memset(state->parts, 0, state->limit * sizeof(state->parts[0]));
138387048bfSChristoph Hellwig res = check_part[i++](state);
139387048bfSChristoph Hellwig if (res < 0) {
140387048bfSChristoph Hellwig /*
141387048bfSChristoph Hellwig * We have hit an I/O error which we don't report now.
142387048bfSChristoph Hellwig * But record it, and let the others do their job.
143387048bfSChristoph Hellwig */
144387048bfSChristoph Hellwig err = res;
145387048bfSChristoph Hellwig res = 0;
146387048bfSChristoph Hellwig }
147387048bfSChristoph Hellwig
148387048bfSChristoph Hellwig }
149387048bfSChristoph Hellwig if (res > 0) {
150387048bfSChristoph Hellwig printk(KERN_INFO "%s", state->pp_buf);
151387048bfSChristoph Hellwig
152387048bfSChristoph Hellwig free_page((unsigned long)state->pp_buf);
153387048bfSChristoph Hellwig return state;
154387048bfSChristoph Hellwig }
155387048bfSChristoph Hellwig if (state->access_beyond_eod)
156387048bfSChristoph Hellwig err = -ENOSPC;
157387048bfSChristoph Hellwig /*
158387048bfSChristoph Hellwig * The partition is unrecognized. So report I/O errors if there were any
159387048bfSChristoph Hellwig */
160387048bfSChristoph Hellwig if (err)
161387048bfSChristoph Hellwig res = err;
162387048bfSChristoph Hellwig if (res) {
163387048bfSChristoph Hellwig strlcat(state->pp_buf,
164387048bfSChristoph Hellwig " unable to read partition table\n", PAGE_SIZE);
165387048bfSChristoph Hellwig printk(KERN_INFO "%s", state->pp_buf);
166387048bfSChristoph Hellwig }
167387048bfSChristoph Hellwig
168387048bfSChristoph Hellwig free_page((unsigned long)state->pp_buf);
169387048bfSChristoph Hellwig free_partitions(state);
170387048bfSChristoph Hellwig return ERR_PTR(res);
171387048bfSChristoph Hellwig }
172387048bfSChristoph Hellwig
part_partition_show(struct device * dev,struct device_attribute * attr,char * buf)173387048bfSChristoph Hellwig static ssize_t part_partition_show(struct device *dev,
174387048bfSChristoph Hellwig struct device_attribute *attr, char *buf)
175387048bfSChristoph Hellwig {
176b8c873edSAl Viro return sprintf(buf, "%d\n", bdev_partno(dev_to_bdev(dev)));
177387048bfSChristoph Hellwig }
178387048bfSChristoph Hellwig
part_start_show(struct device * dev,struct device_attribute * attr,char * buf)179387048bfSChristoph Hellwig static ssize_t part_start_show(struct device *dev,
180387048bfSChristoph Hellwig struct device_attribute *attr, char *buf)
181387048bfSChristoph Hellwig {
1820d02129eSChristoph Hellwig return sprintf(buf, "%llu\n", dev_to_bdev(dev)->bd_start_sect);
183387048bfSChristoph Hellwig }
184387048bfSChristoph Hellwig
part_ro_show(struct device * dev,struct device_attribute * attr,char * buf)185387048bfSChristoph Hellwig static ssize_t part_ro_show(struct device *dev,
186387048bfSChristoph Hellwig struct device_attribute *attr, char *buf)
187387048bfSChristoph Hellwig {
18852f019d4SChristoph Hellwig return sprintf(buf, "%d\n", bdev_read_only(dev_to_bdev(dev)));
189387048bfSChristoph Hellwig }
190387048bfSChristoph Hellwig
part_alignment_offset_show(struct device * dev,struct device_attribute * attr,char * buf)191387048bfSChristoph Hellwig static ssize_t part_alignment_offset_show(struct device *dev,
192387048bfSChristoph Hellwig struct device_attribute *attr, char *buf)
193387048bfSChristoph Hellwig {
19464dcc7c2SChristoph Hellwig return sprintf(buf, "%u\n", bdev_alignment_offset(dev_to_bdev(dev)));
195387048bfSChristoph Hellwig }
196387048bfSChristoph Hellwig
part_discard_alignment_show(struct device * dev,struct device_attribute * attr,char * buf)197387048bfSChristoph Hellwig static ssize_t part_discard_alignment_show(struct device *dev,
198387048bfSChristoph Hellwig struct device_attribute *attr, char *buf)
199387048bfSChristoph Hellwig {
200f0f975a4SChristoph Hellwig return sprintf(buf, "%u\n", bdev_discard_alignment(dev_to_bdev(dev)));
201387048bfSChristoph Hellwig }
202387048bfSChristoph Hellwig
203387048bfSChristoph Hellwig static DEVICE_ATTR(partition, 0444, part_partition_show, NULL);
204387048bfSChristoph Hellwig static DEVICE_ATTR(start, 0444, part_start_show, NULL);
205387048bfSChristoph Hellwig static DEVICE_ATTR(size, 0444, part_size_show, NULL);
206387048bfSChristoph Hellwig static DEVICE_ATTR(ro, 0444, part_ro_show, NULL);
207387048bfSChristoph Hellwig static DEVICE_ATTR(alignment_offset, 0444, part_alignment_offset_show, NULL);
208387048bfSChristoph Hellwig static DEVICE_ATTR(discard_alignment, 0444, part_discard_alignment_show, NULL);
209387048bfSChristoph Hellwig static DEVICE_ATTR(stat, 0444, part_stat_show, NULL);
210387048bfSChristoph Hellwig static DEVICE_ATTR(inflight, 0444, part_inflight_show, NULL);
211387048bfSChristoph Hellwig #ifdef CONFIG_FAIL_MAKE_REQUEST
212387048bfSChristoph Hellwig static struct device_attribute dev_attr_fail =
213387048bfSChristoph Hellwig __ATTR(make-it-fail, 0644, part_fail_show, part_fail_store);
214387048bfSChristoph Hellwig #endif
215387048bfSChristoph Hellwig
216387048bfSChristoph Hellwig static struct attribute *part_attrs[] = {
217387048bfSChristoph Hellwig &dev_attr_partition.attr,
218387048bfSChristoph Hellwig &dev_attr_start.attr,
219387048bfSChristoph Hellwig &dev_attr_size.attr,
220387048bfSChristoph Hellwig &dev_attr_ro.attr,
221387048bfSChristoph Hellwig &dev_attr_alignment_offset.attr,
222387048bfSChristoph Hellwig &dev_attr_discard_alignment.attr,
223387048bfSChristoph Hellwig &dev_attr_stat.attr,
224387048bfSChristoph Hellwig &dev_attr_inflight.attr,
225387048bfSChristoph Hellwig #ifdef CONFIG_FAIL_MAKE_REQUEST
226387048bfSChristoph Hellwig &dev_attr_fail.attr,
227387048bfSChristoph Hellwig #endif
228387048bfSChristoph Hellwig NULL
229387048bfSChristoph Hellwig };
230387048bfSChristoph Hellwig
2310bd47800SThomas Weißschuh static const struct attribute_group part_attr_group = {
232387048bfSChristoph Hellwig .attrs = part_attrs,
233387048bfSChristoph Hellwig };
234387048bfSChristoph Hellwig
235387048bfSChristoph Hellwig static const struct attribute_group *part_attr_groups[] = {
236387048bfSChristoph Hellwig &part_attr_group,
237387048bfSChristoph Hellwig #ifdef CONFIG_BLK_DEV_IO_TRACE
238387048bfSChristoph Hellwig &blk_trace_attr_group,
239387048bfSChristoph Hellwig #endif
240387048bfSChristoph Hellwig NULL
241387048bfSChristoph Hellwig };
242387048bfSChristoph Hellwig
part_release(struct device * dev)243387048bfSChristoph Hellwig static void part_release(struct device *dev)
244387048bfSChristoph Hellwig {
2459d3b8813SChristoph Hellwig put_disk(dev_to_bdev(dev)->bd_disk);
2462638c208SAl Viro bdev_drop(dev_to_bdev(dev));
247387048bfSChristoph Hellwig }
248387048bfSChristoph Hellwig
part_uevent(const struct device * dev,struct kobj_uevent_env * env)249162736b0SGreg Kroah-Hartman static int part_uevent(const struct device *dev, struct kobj_uevent_env *env)
250387048bfSChristoph Hellwig {
251162736b0SGreg Kroah-Hartman const struct block_device *part = dev_to_bdev(dev);
252387048bfSChristoph Hellwig
253b8c873edSAl Viro add_uevent_var(env, "PARTN=%u", bdev_partno(part));
2540d02129eSChristoph Hellwig if (part->bd_meta_info && part->bd_meta_info->volname[0])
2550d02129eSChristoph Hellwig add_uevent_var(env, "PARTNAME=%s", part->bd_meta_info->volname);
256387048bfSChristoph Hellwig return 0;
257387048bfSChristoph Hellwig }
258387048bfSChristoph Hellwig
259cdb37f73SThomas Weißschuh const struct device_type part_type = {
260387048bfSChristoph Hellwig .name = "partition",
261387048bfSChristoph Hellwig .groups = part_attr_groups,
262387048bfSChristoph Hellwig .release = part_release,
263387048bfSChristoph Hellwig .uevent = part_uevent,
264387048bfSChristoph Hellwig };
265387048bfSChristoph Hellwig
drop_partition(struct block_device * part)266eec1be4cSChristoph Hellwig void drop_partition(struct block_device *part)
267387048bfSChristoph Hellwig {
268a45e43caSChristoph Hellwig lockdep_assert_held(&part->bd_disk->open_mutex);
269a45e43caSChristoph Hellwig
270b8c873edSAl Viro xa_erase(&part->bd_disk->part_tbl, bdev_partno(part));
271eec1be4cSChristoph Hellwig kobject_put(part->bd_holder_dir);
272eec1be4cSChristoph Hellwig
273eec1be4cSChristoph Hellwig device_del(&part->bd_device);
274eec1be4cSChristoph Hellwig put_device(&part->bd_device);
275eec1be4cSChristoph Hellwig }
276eec1be4cSChristoph Hellwig
whole_disk_show(struct device * dev,struct device_attribute * attr,char * buf)277387048bfSChristoph Hellwig static ssize_t whole_disk_show(struct device *dev,
278387048bfSChristoph Hellwig struct device_attribute *attr, char *buf)
279387048bfSChristoph Hellwig {
280387048bfSChristoph Hellwig return 0;
281387048bfSChristoph Hellwig }
282a378f6a4SThomas Weißschuh static const DEVICE_ATTR(whole_disk, 0444, whole_disk_show, NULL);
283387048bfSChristoph Hellwig
284387048bfSChristoph Hellwig /*
285a8698707SChristoph Hellwig * Must be called either with open_mutex held, before a disk can be opened or
286387048bfSChristoph Hellwig * after all disk users are gone.
287387048bfSChristoph Hellwig */
add_partition(struct gendisk * disk,int partno,sector_t start,sector_t len,int flags,struct partition_meta_info * info)2880d02129eSChristoph Hellwig static struct block_device *add_partition(struct gendisk *disk, int partno,
289387048bfSChristoph Hellwig sector_t start, sector_t len, int flags,
290387048bfSChristoph Hellwig struct partition_meta_info *info)
291387048bfSChristoph Hellwig {
292387048bfSChristoph Hellwig dev_t devt = MKDEV(0, 0);
293387048bfSChristoph Hellwig struct device *ddev = disk_to_dev(disk);
294387048bfSChristoph Hellwig struct device *pdev;
29522ae8ce8SChristoph Hellwig struct block_device *bdev;
296387048bfSChristoph Hellwig const char *dname;
297387048bfSChristoph Hellwig int err;
298387048bfSChristoph Hellwig
2990e0ccdecSChristoph Hellwig lockdep_assert_held(&disk->open_mutex);
3000e0ccdecSChristoph Hellwig
3011ebe2e5fSChristoph Hellwig if (partno >= DISK_MAX_PARTS)
302e82fc785SMing Lei return ERR_PTR(-EINVAL);
303e82fc785SMing Lei
304e82fc785SMing Lei /*
305387048bfSChristoph Hellwig * Partitions are not supported on zoned block devices that are used as
306387048bfSChristoph Hellwig * such.
307387048bfSChristoph Hellwig */
3087437bb73SChristoph Hellwig if (bdev_is_zoned(disk->part0)) {
309387048bfSChristoph Hellwig pr_warn("%s: partitions not supported on host managed zoned block device\n",
310387048bfSChristoph Hellwig disk->disk_name);
311387048bfSChristoph Hellwig return ERR_PTR(-ENXIO);
312387048bfSChristoph Hellwig }
313387048bfSChristoph Hellwig
314a33df75cSChristoph Hellwig if (xa_load(&disk->part_tbl, partno))
315387048bfSChristoph Hellwig return ERR_PTR(-EBUSY);
316387048bfSChristoph Hellwig
3179d3b8813SChristoph Hellwig /* ensure we always have a reference to the whole disk */
3189d3b8813SChristoph Hellwig get_device(disk_to_dev(disk));
3199d3b8813SChristoph Hellwig
3209d3b8813SChristoph Hellwig err = -ENOMEM;
32122ae8ce8SChristoph Hellwig bdev = bdev_alloc(disk, partno);
32222ae8ce8SChristoph Hellwig if (!bdev)
3239d3b8813SChristoph Hellwig goto out_put_disk;
324387048bfSChristoph Hellwig
32529ff57c6SChristoph Hellwig bdev->bd_start_sect = start;
326a782483cSChristoph Hellwig bdev_set_nr_sectors(bdev, len);
327387048bfSChristoph Hellwig
3280d02129eSChristoph Hellwig pdev = &bdev->bd_device;
329387048bfSChristoph Hellwig dname = dev_name(ddev);
330387048bfSChristoph Hellwig if (isdigit(dname[strlen(dname) - 1]))
331387048bfSChristoph Hellwig dev_set_name(pdev, "%sp%d", dname, partno);
332387048bfSChristoph Hellwig else
333387048bfSChristoph Hellwig dev_set_name(pdev, "%s%d", dname, partno);
334387048bfSChristoph Hellwig
335387048bfSChristoph Hellwig device_initialize(pdev);
336387048bfSChristoph Hellwig pdev->class = &block_class;
337387048bfSChristoph Hellwig pdev->type = &part_type;
338387048bfSChristoph Hellwig pdev->parent = ddev;
339387048bfSChristoph Hellwig
3407c3f828bSChristoph Hellwig /* in consecutive minor range? */
341b8c873edSAl Viro if (bdev_partno(bdev) < disk->minors) {
342b8c873edSAl Viro devt = MKDEV(disk->major, disk->first_minor + bdev_partno(bdev));
3437c3f828bSChristoph Hellwig } else {
3447c3f828bSChristoph Hellwig err = blk_alloc_ext_minor();
3457c3f828bSChristoph Hellwig if (err < 0)
346ef49d40bSDinghao Liu goto out_put;
3477c3f828bSChristoph Hellwig devt = MKDEV(BLOCK_EXT_MAJOR, err);
3487c3f828bSChristoph Hellwig }
349387048bfSChristoph Hellwig pdev->devt = devt;
350387048bfSChristoph Hellwig
3510468c532SChristoph Hellwig if (info) {
3520468c532SChristoph Hellwig err = -ENOMEM;
3530468c532SChristoph Hellwig bdev->bd_meta_info = kmemdup(info, sizeof(*info), GFP_KERNEL);
3540468c532SChristoph Hellwig if (!bdev->bd_meta_info)
3550468c532SChristoph Hellwig goto out_put;
3560468c532SChristoph Hellwig }
3570468c532SChristoph Hellwig
358387048bfSChristoph Hellwig /* delay uevent until 'holders' subdir is created */
359387048bfSChristoph Hellwig dev_set_uevent_suppress(pdev, 1);
360387048bfSChristoph Hellwig err = device_add(pdev);
361387048bfSChristoph Hellwig if (err)
362387048bfSChristoph Hellwig goto out_put;
363387048bfSChristoph Hellwig
364387048bfSChristoph Hellwig err = -ENOMEM;
3651bdd5ae0SChristoph Hellwig bdev->bd_holder_dir = kobject_create_and_add("holders", &pdev->kobj);
3661bdd5ae0SChristoph Hellwig if (!bdev->bd_holder_dir)
367387048bfSChristoph Hellwig goto out_del;
368387048bfSChristoph Hellwig
369387048bfSChristoph Hellwig dev_set_uevent_suppress(pdev, 0);
370387048bfSChristoph Hellwig if (flags & ADDPART_FLAG_WHOLEDISK) {
371387048bfSChristoph Hellwig err = device_create_file(pdev, &dev_attr_whole_disk);
372387048bfSChristoph Hellwig if (err)
373387048bfSChristoph Hellwig goto out_del;
374387048bfSChristoph Hellwig }
375387048bfSChristoph Hellwig
376387048bfSChristoph Hellwig /* everything is up and running, commence */
377a33df75cSChristoph Hellwig err = xa_insert(&disk->part_tbl, partno, bdev, GFP_KERNEL);
378a33df75cSChristoph Hellwig if (err)
379a33df75cSChristoph Hellwig goto out_del;
38022ae8ce8SChristoph Hellwig bdev_add(bdev, devt);
381387048bfSChristoph Hellwig
382387048bfSChristoph Hellwig /* suppress uevent if the disk suppresses it */
383387048bfSChristoph Hellwig if (!dev_get_uevent_suppress(ddev))
384387048bfSChristoph Hellwig kobject_uevent(&pdev->kobj, KOBJ_ADD);
3850d02129eSChristoph Hellwig return bdev;
386387048bfSChristoph Hellwig
387387048bfSChristoph Hellwig out_del:
3881bdd5ae0SChristoph Hellwig kobject_put(bdev->bd_holder_dir);
389387048bfSChristoph Hellwig device_del(pdev);
390387048bfSChristoph Hellwig out_put:
391387048bfSChristoph Hellwig put_device(pdev);
3929fbfabfdSZqiang return ERR_PTR(err);
3939d3b8813SChristoph Hellwig out_put_disk:
3949d3b8813SChristoph Hellwig put_disk(disk);
395387048bfSChristoph Hellwig return ERR_PTR(err);
396387048bfSChristoph Hellwig }
397387048bfSChristoph Hellwig
partition_overlaps(struct gendisk * disk,sector_t start,sector_t length,int skip_partno)398fa9156aeSChristoph Hellwig static bool partition_overlaps(struct gendisk *disk, sector_t start,
399fa9156aeSChristoph Hellwig sector_t length, int skip_partno)
400fa9156aeSChristoph Hellwig {
401ad1eaa53SChristoph Hellwig struct block_device *part;
402fa9156aeSChristoph Hellwig bool overlap = false;
403e3069123SChristoph Hellwig unsigned long idx;
404fa9156aeSChristoph Hellwig
405e3069123SChristoph Hellwig rcu_read_lock();
406e3069123SChristoph Hellwig xa_for_each_start(&disk->part_tbl, idx, part, 1) {
407b8c873edSAl Viro if (bdev_partno(part) != skip_partno &&
408e3069123SChristoph Hellwig start < part->bd_start_sect + bdev_nr_sectors(part) &&
409e3069123SChristoph Hellwig start + length > part->bd_start_sect) {
410fa9156aeSChristoph Hellwig overlap = true;
411fa9156aeSChristoph Hellwig break;
412fa9156aeSChristoph Hellwig }
413e3069123SChristoph Hellwig }
414e3069123SChristoph Hellwig rcu_read_unlock();
415fa9156aeSChristoph Hellwig
416fa9156aeSChristoph Hellwig return overlap;
417fa9156aeSChristoph Hellwig }
418fa9156aeSChristoph Hellwig
bdev_add_partition(struct gendisk * disk,int partno,sector_t start,sector_t length)4197f6be376SChristoph Hellwig int bdev_add_partition(struct gendisk *disk, int partno, sector_t start,
4207f6be376SChristoph Hellwig sector_t length)
421fa9156aeSChristoph Hellwig {
4220d02129eSChristoph Hellwig struct block_device *part;
423b5cfbd35SYufen Yu int ret;
424fa9156aeSChristoph Hellwig
425b5cfbd35SYufen Yu mutex_lock(&disk->open_mutex);
42650b4aecfSChristoph Hellwig if (!disk_live(disk)) {
427b5cfbd35SYufen Yu ret = -ENXIO;
428b5cfbd35SYufen Yu goto out;
429fa9156aeSChristoph Hellwig }
430fa9156aeSChristoph Hellwig
4317777f47fSLi Lingfeng if (disk->flags & GENHD_FL_NO_PART) {
4327777f47fSLi Lingfeng ret = -EINVAL;
4337777f47fSLi Lingfeng goto out;
4347777f47fSLi Lingfeng }
4357777f47fSLi Lingfeng
436b5cfbd35SYufen Yu if (partition_overlaps(disk, start, length, -1)) {
437b5cfbd35SYufen Yu ret = -EBUSY;
438b5cfbd35SYufen Yu goto out;
439b5cfbd35SYufen Yu }
440b5cfbd35SYufen Yu
441b5cfbd35SYufen Yu part = add_partition(disk, partno, start, length,
442fa9156aeSChristoph Hellwig ADDPART_FLAG_NONE, NULL);
443b5cfbd35SYufen Yu ret = PTR_ERR_OR_ZERO(part);
444b5cfbd35SYufen Yu out:
445b5cfbd35SYufen Yu mutex_unlock(&disk->open_mutex);
446b5cfbd35SYufen Yu return ret;
447fa9156aeSChristoph Hellwig }
448fa9156aeSChristoph Hellwig
bdev_del_partition(struct gendisk * disk,int partno)449926fbb16SChristoph Hellwig int bdev_del_partition(struct gendisk *disk, int partno)
450fa9156aeSChristoph Hellwig {
4510e0ccdecSChristoph Hellwig struct block_device *part = NULL;
4520e0ccdecSChristoph Hellwig int ret = -ENXIO;
453fa9156aeSChristoph Hellwig
454926fbb16SChristoph Hellwig mutex_lock(&disk->open_mutex);
455926fbb16SChristoph Hellwig part = xa_load(&disk->part_tbl, partno);
4560e0ccdecSChristoph Hellwig if (!part)
4570e0ccdecSChristoph Hellwig goto out_unlock;
45808fc1ab6SChristoph Hellwig
459fa9156aeSChristoph Hellwig ret = -EBUSY;
4609acf381fSChristoph Hellwig if (atomic_read(&part->bd_openers))
461fa9156aeSChristoph Hellwig goto out_unlock;
462fa9156aeSChristoph Hellwig
463c30b9787SChristian Brauner /*
464c30b9787SChristian Brauner * We verified that @part->bd_openers is zero above and so
465c30b9787SChristian Brauner * @part->bd_holder{_ops} can't be set. And since we hold
466c30b9787SChristian Brauner * @disk->open_mutex the device can't be claimed by anyone.
467c30b9787SChristian Brauner *
468c30b9787SChristian Brauner * So no need to call @part->bd_holder_ops->mark_dead() here.
469c30b9787SChristian Brauner * Just delete the partition and invalidate it.
470c30b9787SChristian Brauner */
471c30b9787SChristian Brauner
4722638c208SAl Viro bdev_unhash(part);
473c30b9787SChristian Brauner invalidate_bdev(part);
474c30b9787SChristian Brauner drop_partition(part);
475fa9156aeSChristoph Hellwig ret = 0;
476fa9156aeSChristoph Hellwig out_unlock:
477926fbb16SChristoph Hellwig mutex_unlock(&disk->open_mutex);
478fa9156aeSChristoph Hellwig return ret;
479fa9156aeSChristoph Hellwig }
480fa9156aeSChristoph Hellwig
bdev_resize_partition(struct gendisk * disk,int partno,sector_t start,sector_t length)4813d2e7989SChristoph Hellwig int bdev_resize_partition(struct gendisk *disk, int partno, sector_t start,
4823d2e7989SChristoph Hellwig sector_t length)
483fa9156aeSChristoph Hellwig {
4840e0ccdecSChristoph Hellwig struct block_device *part = NULL;
4850e0ccdecSChristoph Hellwig int ret = -ENXIO;
486fa9156aeSChristoph Hellwig
4873d2e7989SChristoph Hellwig mutex_lock(&disk->open_mutex);
4883d2e7989SChristoph Hellwig part = xa_load(&disk->part_tbl, partno);
4890e0ccdecSChristoph Hellwig if (!part)
4900e0ccdecSChristoph Hellwig goto out_unlock;
4910e0ccdecSChristoph Hellwig
492fa9156aeSChristoph Hellwig ret = -EINVAL;
4930d02129eSChristoph Hellwig if (start != part->bd_start_sect)
494fa9156aeSChristoph Hellwig goto out_unlock;
495fa9156aeSChristoph Hellwig
496fa9156aeSChristoph Hellwig ret = -EBUSY;
4973d2e7989SChristoph Hellwig if (partition_overlaps(disk, start, length, partno))
498fa9156aeSChristoph Hellwig goto out_unlock;
499fa9156aeSChristoph Hellwig
5000d02129eSChristoph Hellwig bdev_set_nr_sectors(part, length);
501fa9156aeSChristoph Hellwig
502fa9156aeSChristoph Hellwig ret = 0;
503fa9156aeSChristoph Hellwig out_unlock:
5043d2e7989SChristoph Hellwig mutex_unlock(&disk->open_mutex);
505fa9156aeSChristoph Hellwig return ret;
506fa9156aeSChristoph Hellwig }
507fa9156aeSChristoph Hellwig
disk_unlock_native_capacity(struct gendisk * disk)508387048bfSChristoph Hellwig static bool disk_unlock_native_capacity(struct gendisk *disk)
509387048bfSChristoph Hellwig {
51086416916SChristoph Hellwig if (!disk->fops->unlock_native_capacity ||
51186416916SChristoph Hellwig test_and_set_bit(GD_NATIVE_CAPACITY, &disk->state)) {
512387048bfSChristoph Hellwig printk(KERN_CONT "truncated\n");
513387048bfSChristoph Hellwig return false;
514387048bfSChristoph Hellwig }
51586416916SChristoph Hellwig
51686416916SChristoph Hellwig printk(KERN_CONT "enabling native capacity\n");
51786416916SChristoph Hellwig disk->fops->unlock_native_capacity(disk);
51886416916SChristoph Hellwig return true;
519387048bfSChristoph Hellwig }
520387048bfSChristoph Hellwig
blk_add_partition(struct gendisk * disk,struct parsed_partitions * state,int p)5210384264eSChristoph Hellwig static bool blk_add_partition(struct gendisk *disk,
522387048bfSChristoph Hellwig struct parsed_partitions *state, int p)
523387048bfSChristoph Hellwig {
524387048bfSChristoph Hellwig sector_t size = state->parts[p].size;
525387048bfSChristoph Hellwig sector_t from = state->parts[p].from;
5260d02129eSChristoph Hellwig struct block_device *part;
527387048bfSChristoph Hellwig
528387048bfSChristoph Hellwig if (!size)
529387048bfSChristoph Hellwig return true;
530387048bfSChristoph Hellwig
531387048bfSChristoph Hellwig if (from >= get_capacity(disk)) {
532387048bfSChristoph Hellwig printk(KERN_WARNING
533387048bfSChristoph Hellwig "%s: p%d start %llu is beyond EOD, ",
534387048bfSChristoph Hellwig disk->disk_name, p, (unsigned long long) from);
535387048bfSChristoph Hellwig if (disk_unlock_native_capacity(disk))
536387048bfSChristoph Hellwig return false;
537387048bfSChristoph Hellwig return true;
538387048bfSChristoph Hellwig }
539387048bfSChristoph Hellwig
540387048bfSChristoph Hellwig if (from + size > get_capacity(disk)) {
541387048bfSChristoph Hellwig printk(KERN_WARNING
542387048bfSChristoph Hellwig "%s: p%d size %llu extends beyond EOD, ",
543387048bfSChristoph Hellwig disk->disk_name, p, (unsigned long long) size);
544387048bfSChristoph Hellwig
545387048bfSChristoph Hellwig if (disk_unlock_native_capacity(disk))
546387048bfSChristoph Hellwig return false;
547387048bfSChristoph Hellwig
548387048bfSChristoph Hellwig /*
549387048bfSChristoph Hellwig * We can not ignore partitions of broken tables created by for
550387048bfSChristoph Hellwig * example camera firmware, but we limit them to the end of the
551387048bfSChristoph Hellwig * disk to avoid creating invalid block devices.
552387048bfSChristoph Hellwig */
553387048bfSChristoph Hellwig size = get_capacity(disk) - from;
554387048bfSChristoph Hellwig }
555387048bfSChristoph Hellwig
556387048bfSChristoph Hellwig part = add_partition(disk, p, from, size, state->parts[p].flags,
557387048bfSChristoph Hellwig &state->parts[p].info);
558*26e197b7SRiyan Dhiman if (IS_ERR(part)) {
559*26e197b7SRiyan Dhiman if (PTR_ERR(part) != -ENXIO) {
56025c1772aSChristian Heusel printk(KERN_ERR " %s: p%d could not be added: %pe\n",
56125c1772aSChristian Heusel disk->disk_name, p, part);
562*26e197b7SRiyan Dhiman }
563387048bfSChristoph Hellwig return true;
564387048bfSChristoph Hellwig }
565387048bfSChristoph Hellwig
566387048bfSChristoph Hellwig if (IS_BUILTIN(CONFIG_BLK_DEV_MD) &&
567387048bfSChristoph Hellwig (state->parts[p].flags & ADDPART_FLAG_RAID))
5680d02129eSChristoph Hellwig md_autodetect_dev(part->bd_dev);
569387048bfSChristoph Hellwig
570387048bfSChristoph Hellwig return true;
571387048bfSChristoph Hellwig }
572387048bfSChristoph Hellwig
blk_add_partitions(struct gendisk * disk)5730384264eSChristoph Hellwig static int blk_add_partitions(struct gendisk *disk)
574387048bfSChristoph Hellwig {
575387048bfSChristoph Hellwig struct parsed_partitions *state;
576a33df75cSChristoph Hellwig int ret = -EAGAIN, p;
577387048bfSChristoph Hellwig
578140ce28dSChristoph Hellwig if (!disk_has_partscan(disk))
579748008e1SMing Lei return 0;
580748008e1SMing Lei
5810384264eSChristoph Hellwig state = check_partition(disk);
582387048bfSChristoph Hellwig if (!state)
583387048bfSChristoph Hellwig return 0;
584387048bfSChristoph Hellwig if (IS_ERR(state)) {
585387048bfSChristoph Hellwig /*
586387048bfSChristoph Hellwig * I/O error reading the partition table. If we tried to read
587387048bfSChristoph Hellwig * beyond EOD, retry after unlocking the native capacity.
588387048bfSChristoph Hellwig */
589387048bfSChristoph Hellwig if (PTR_ERR(state) == -ENOSPC) {
590387048bfSChristoph Hellwig printk(KERN_WARNING "%s: partition table beyond EOD, ",
591387048bfSChristoph Hellwig disk->disk_name);
592387048bfSChristoph Hellwig if (disk_unlock_native_capacity(disk))
593387048bfSChristoph Hellwig return -EAGAIN;
594387048bfSChristoph Hellwig }
595387048bfSChristoph Hellwig return -EIO;
596387048bfSChristoph Hellwig }
597387048bfSChristoph Hellwig
598387048bfSChristoph Hellwig /*
599387048bfSChristoph Hellwig * Partitions are not supported on host managed zoned block devices.
600387048bfSChristoph Hellwig */
6017437bb73SChristoph Hellwig if (bdev_is_zoned(disk->part0)) {
602387048bfSChristoph Hellwig pr_warn("%s: ignoring partition table on host managed zoned block device\n",
603387048bfSChristoph Hellwig disk->disk_name);
604387048bfSChristoph Hellwig ret = 0;
605387048bfSChristoph Hellwig goto out_free_state;
606387048bfSChristoph Hellwig }
607387048bfSChristoph Hellwig
608387048bfSChristoph Hellwig /*
609387048bfSChristoph Hellwig * If we read beyond EOD, try unlocking native capacity even if the
610387048bfSChristoph Hellwig * partition table was successfully read as we could be missing some
611387048bfSChristoph Hellwig * partitions.
612387048bfSChristoph Hellwig */
613387048bfSChristoph Hellwig if (state->access_beyond_eod) {
614387048bfSChristoph Hellwig printk(KERN_WARNING
615387048bfSChristoph Hellwig "%s: partition table partially beyond EOD, ",
616387048bfSChristoph Hellwig disk->disk_name);
617387048bfSChristoph Hellwig if (disk_unlock_native_capacity(disk))
618387048bfSChristoph Hellwig goto out_free_state;
619387048bfSChristoph Hellwig }
620387048bfSChristoph Hellwig
621387048bfSChristoph Hellwig /* tell userspace that the media / partition table may have changed */
622387048bfSChristoph Hellwig kobject_uevent(&disk_to_dev(disk)->kobj, KOBJ_CHANGE);
623387048bfSChristoph Hellwig
624387048bfSChristoph Hellwig for (p = 1; p < state->limit; p++)
6250384264eSChristoph Hellwig if (!blk_add_partition(disk, state, p))
626387048bfSChristoph Hellwig goto out_free_state;
627387048bfSChristoph Hellwig
628387048bfSChristoph Hellwig ret = 0;
629387048bfSChristoph Hellwig out_free_state:
630387048bfSChristoph Hellwig free_partitions(state);
631387048bfSChristoph Hellwig return ret;
632387048bfSChristoph Hellwig }
633387048bfSChristoph Hellwig
bdev_disk_changed(struct gendisk * disk,bool invalidate)6340384264eSChristoph Hellwig int bdev_disk_changed(struct gendisk *disk, bool invalidate)
635630161cfSChristoph Hellwig {
63600080f7fSChristoph Hellwig struct block_device *part;
63700080f7fSChristoph Hellwig unsigned long idx;
638630161cfSChristoph Hellwig int ret = 0;
639630161cfSChristoph Hellwig
640630161cfSChristoph Hellwig lockdep_assert_held(&disk->open_mutex);
641630161cfSChristoph Hellwig
64250b4aecfSChristoph Hellwig if (!disk_live(disk))
643630161cfSChristoph Hellwig return -ENXIO;
644630161cfSChristoph Hellwig
645630161cfSChristoph Hellwig rescan:
646630161cfSChristoph Hellwig if (disk->open_partitions)
647630161cfSChristoph Hellwig return -EBUSY;
6480384264eSChristoph Hellwig sync_blockdev(disk->part0);
6490384264eSChristoph Hellwig invalidate_bdev(disk->part0);
650630161cfSChristoph Hellwig
65151b4cb4fSChristian Brauner xa_for_each_start(&disk->part_tbl, idx, part, 1) {
65251b4cb4fSChristian Brauner /*
65351b4cb4fSChristian Brauner * Remove the block device from the inode hash, so that
65451b4cb4fSChristian Brauner * it cannot be looked up any more even when openers
65551b4cb4fSChristian Brauner * still hold references.
65651b4cb4fSChristian Brauner */
6572638c208SAl Viro bdev_unhash(part);
65851b4cb4fSChristian Brauner
65951b4cb4fSChristian Brauner /*
66051b4cb4fSChristian Brauner * If @disk->open_partitions isn't elevated but there's
66151b4cb4fSChristian Brauner * still an active holder of that block device things
66251b4cb4fSChristian Brauner * are broken.
66351b4cb4fSChristian Brauner */
66451b4cb4fSChristian Brauner WARN_ON_ONCE(atomic_read(&part->bd_openers));
66551b4cb4fSChristian Brauner invalidate_bdev(part);
66651b4cb4fSChristian Brauner drop_partition(part);
66751b4cb4fSChristian Brauner }
668630161cfSChristoph Hellwig clear_bit(GD_NEED_PART_SCAN, &disk->state);
669630161cfSChristoph Hellwig
670630161cfSChristoph Hellwig /*
671630161cfSChristoph Hellwig * Historically we only set the capacity to zero for devices that
672630161cfSChristoph Hellwig * support partitions (independ of actually having partitions created).
673630161cfSChristoph Hellwig * Doing that is rather inconsistent, but changing it broke legacy
674630161cfSChristoph Hellwig * udisks polling for legacy ide-cdrom devices. Use the crude check
675630161cfSChristoph Hellwig * below to get the sane behavior for most device while not breaking
676630161cfSChristoph Hellwig * userspace for this particular setup.
677630161cfSChristoph Hellwig */
678630161cfSChristoph Hellwig if (invalidate) {
6791ebe2e5fSChristoph Hellwig if (!(disk->flags & GENHD_FL_NO_PART) ||
680630161cfSChristoph Hellwig !(disk->flags & GENHD_FL_REMOVABLE))
681630161cfSChristoph Hellwig set_capacity(disk, 0);
682630161cfSChristoph Hellwig }
683630161cfSChristoph Hellwig
684630161cfSChristoph Hellwig if (get_capacity(disk)) {
6850384264eSChristoph Hellwig ret = blk_add_partitions(disk);
686630161cfSChristoph Hellwig if (ret == -EAGAIN)
687630161cfSChristoph Hellwig goto rescan;
688630161cfSChristoph Hellwig } else if (invalidate) {
689630161cfSChristoph Hellwig /*
690630161cfSChristoph Hellwig * Tell userspace that the media / partition table may have
691630161cfSChristoph Hellwig * changed.
692630161cfSChristoph Hellwig */
693630161cfSChristoph Hellwig kobject_uevent(&disk_to_dev(disk)->kobj, KOBJ_CHANGE);
694630161cfSChristoph Hellwig }
695630161cfSChristoph Hellwig
696630161cfSChristoph Hellwig return ret;
697630161cfSChristoph Hellwig }
698630161cfSChristoph Hellwig /*
699630161cfSChristoph Hellwig * Only exported for loop and dasd for historic reasons. Don't use in new
700630161cfSChristoph Hellwig * code!
701630161cfSChristoph Hellwig */
702630161cfSChristoph Hellwig EXPORT_SYMBOL_GPL(bdev_disk_changed);
703630161cfSChristoph Hellwig
read_part_sector(struct parsed_partitions * state,sector_t n,Sector * p)704387048bfSChristoph Hellwig void *read_part_sector(struct parsed_partitions *state, sector_t n, Sector *p)
705387048bfSChristoph Hellwig {
706224941e8SAl Viro struct address_space *mapping = state->disk->part0->bd_mapping;
7074fdc08d4SMatthew Wilcox (Oracle) struct folio *folio;
708387048bfSChristoph Hellwig
709a08aa9bcSChristoph Hellwig if (n >= get_capacity(state->disk)) {
710387048bfSChristoph Hellwig state->access_beyond_eod = true;
71198d8ba69SMatthew Wilcox (Oracle) goto out;
712387048bfSChristoph Hellwig }
713387048bfSChristoph Hellwig
7144fdc08d4SMatthew Wilcox (Oracle) folio = read_mapping_folio(mapping, n >> PAGE_SECTORS_SHIFT, NULL);
7154fdc08d4SMatthew Wilcox (Oracle) if (IS_ERR(folio))
716387048bfSChristoph Hellwig goto out;
717387048bfSChristoph Hellwig
7184fdc08d4SMatthew Wilcox (Oracle) p->v = folio;
7194fdc08d4SMatthew Wilcox (Oracle) return folio_address(folio) + offset_in_folio(folio, n * SECTOR_SIZE);
720387048bfSChristoph Hellwig out:
721387048bfSChristoph Hellwig p->v = NULL;
722387048bfSChristoph Hellwig return NULL;
723387048bfSChristoph Hellwig }
724