core.c

  1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * Copyright (C) 1991-1998  Linus Torvalds
  4 * Re-organised Feb 1998 Russell King
  5 * Copyright (C) 2020 Christoph Hellwig
  6 */
  7#include <linux/fs.h>
  8#include <linux/major.h>
  9#include <linux/slab.h>
 10#include <linux/ctype.h>
 11#include <linux/vmalloc.h>
 12#include <linux/raid/detect.h>
 13#include "check.h"
 14
 15static int (*const check_part[])(struct parsed_partitions *) = {
 16	/*
 17	 * Probe partition formats with tables at disk address 0
 18	 * that also have an ADFS boot block at 0xdc0.
 19	 */
 20#ifdef CONFIG_ACORN_PARTITION_ICS
 21	adfspart_check_ICS,
 22#endif
 23#ifdef CONFIG_ACORN_PARTITION_POWERTEC
 24	adfspart_check_POWERTEC,
 25#endif
 26#ifdef CONFIG_ACORN_PARTITION_EESOX
 27	adfspart_check_EESOX,
 28#endif
 29
 30	/*
 31	 * Now move on to formats that only have partition info at
 32	 * disk address 0xdc0.  Since these may also have stale
 33	 * PC/BIOS partition tables, they need to come before
 34	 * the msdos entry.
 35	 */
 36#ifdef CONFIG_ACORN_PARTITION_CUMANA
 37	adfspart_check_CUMANA,
 38#endif
 39#ifdef CONFIG_ACORN_PARTITION_ADFS
 40	adfspart_check_ADFS,
 41#endif
 42
 43#ifdef CONFIG_CMDLINE_PARTITION
 44	cmdline_partition,
 45#endif
 46#ifdef CONFIG_OF_PARTITION
 47	of_partition,		/* cmdline have priority to OF */
 48#endif
 49#ifdef CONFIG_EFI_PARTITION
 50	efi_partition,		/* this must come before msdos */
 51#endif
 52#ifdef CONFIG_SGI_PARTITION
 53	sgi_partition,
 54#endif
 55#ifdef CONFIG_LDM_PARTITION
 56	ldm_partition,		/* this must come before msdos */
 57#endif
 58#ifdef CONFIG_MSDOS_PARTITION
 59	msdos_partition,
 60#endif
 61#ifdef CONFIG_OSF_PARTITION
 62	osf_partition,
 63#endif
 64#ifdef CONFIG_SUN_PARTITION
 65	sun_partition,
 66#endif
 67#ifdef CONFIG_AMIGA_PARTITION
 68	amiga_partition,
 69#endif
 70#ifdef CONFIG_ATARI_PARTITION
 71	atari_partition,
 72#endif
 73#ifdef CONFIG_MAC_PARTITION
 74	mac_partition,
 75#endif
 76#ifdef CONFIG_ULTRIX_PARTITION
 77	ultrix_partition,
 78#endif
 79#ifdef CONFIG_IBM_PARTITION
 80	ibm_partition,
 81#endif
 82#ifdef CONFIG_KARMA_PARTITION
 83	karma_partition,
 84#endif
 85#ifdef CONFIG_SYSV68_PARTITION
 86	sysv68_partition,
 87#endif
 88	NULL
 89};
 90
 91static struct parsed_partitions *allocate_partitions(struct gendisk *hd)
 92{
 93	struct parsed_partitions *state;
 94	int nr = DISK_MAX_PARTS;
 95
 96	state = kzalloc(sizeof(*state), GFP_KERNEL);
 97	if (!state)
 98		return NULL;
 99
100	state->parts = vzalloc(array_size(nr, sizeof(state->parts[0])));
101	if (!state->parts) {
102		kfree(state);
103		return NULL;
104	}
105
106	state->limit = nr;
107
108	return state;
109}
110
111static void free_partitions(struct parsed_partitions *state)
112{
113	vfree(state->parts);
114	kfree(state);
115}
116
117static struct parsed_partitions *check_partition(struct gendisk *hd)
118{
119	struct parsed_partitions *state;
120	int i, res, err;
121
122	state = allocate_partitions(hd);
123	if (!state)
124		return NULL;
125	state->pp_buf = (char *)__get_free_page(GFP_KERNEL);
126	if (!state->pp_buf) {
127		free_partitions(state);
128		return NULL;
129	}
130	state->pp_buf[0] = '\0';
131
132	state->disk = hd;
133	snprintf(state->name, BDEVNAME_SIZE, "%s", hd->disk_name);
134	snprintf(state->pp_buf, PAGE_SIZE, " %s:", state->name);
135	if (isdigit(state->name[strlen(state->name)-1]))
136		sprintf(state->name, "p");
137
138	i = res = err = 0;
139	while (!res && check_part[i]) {
140		memset(state->parts, 0, state->limit * sizeof(state->parts[0]));
141		res = check_part[i++](state);
142		if (res < 0) {
143			/*
144			 * We have hit an I/O error which we don't report now.
145			 * But record it, and let the others do their job.
146			 */
147			err = res;
148			res = 0;
149		}
150
151	}
152	if (res > 0) {
153		printk(KERN_INFO "%s", state->pp_buf);
154
155		free_page((unsigned long)state->pp_buf);
156		return state;
157	}
158	if (state->access_beyond_eod)
159		err = -ENOSPC;
160	/*
161	 * The partition is unrecognized. So report I/O errors if there were any
162	 */
163	if (err)
164		res = err;
165	if (res) {
166		strlcat(state->pp_buf,
167			" unable to read partition table\n", PAGE_SIZE);
168		printk(KERN_INFO "%s", state->pp_buf);
169	}
170
171	free_page((unsigned long)state->pp_buf);
172	free_partitions(state);
173	return ERR_PTR(res);
174}
175
176static ssize_t part_partition_show(struct device *dev,
177				   struct device_attribute *attr, char *buf)
178{
179	return sprintf(buf, "%d\n", bdev_partno(dev_to_bdev(dev)));
180}
181
182static ssize_t part_start_show(struct device *dev,
183			       struct device_attribute *attr, char *buf)
184{
185	return sprintf(buf, "%llu\n", dev_to_bdev(dev)->bd_start_sect);
186}
187
188static ssize_t part_ro_show(struct device *dev,
189			    struct device_attribute *attr, char *buf)
190{
191	return sprintf(buf, "%d\n", bdev_read_only(dev_to_bdev(dev)));
192}
193
194static ssize_t part_alignment_offset_show(struct device *dev,
195					  struct device_attribute *attr, char *buf)
196{
197	return sprintf(buf, "%u\n", bdev_alignment_offset(dev_to_bdev(dev)));
198}
199
200static ssize_t part_discard_alignment_show(struct device *dev,
201					   struct device_attribute *attr, char *buf)
202{
203	return sprintf(buf, "%u\n", bdev_discard_alignment(dev_to_bdev(dev)));
204}
205
206static DEVICE_ATTR(partition, 0444, part_partition_show, NULL);
207static DEVICE_ATTR(start, 0444, part_start_show, NULL);
208static DEVICE_ATTR(size, 0444, part_size_show, NULL);
209static DEVICE_ATTR(ro, 0444, part_ro_show, NULL);
210static DEVICE_ATTR(alignment_offset, 0444, part_alignment_offset_show, NULL);
211static DEVICE_ATTR(discard_alignment, 0444, part_discard_alignment_show, NULL);
212static DEVICE_ATTR(stat, 0444, part_stat_show, NULL);
213static DEVICE_ATTR(inflight, 0444, part_inflight_show, NULL);
214#ifdef CONFIG_FAIL_MAKE_REQUEST
215static struct device_attribute dev_attr_fail =
216	__ATTR(make-it-fail, 0644, part_fail_show, part_fail_store);
217#endif
218
219static struct attribute *part_attrs[] = {
220	&dev_attr_partition.attr,
221	&dev_attr_start.attr,
222	&dev_attr_size.attr,
223	&dev_attr_ro.attr,
224	&dev_attr_alignment_offset.attr,
225	&dev_attr_discard_alignment.attr,
226	&dev_attr_stat.attr,
227	&dev_attr_inflight.attr,
228#ifdef CONFIG_FAIL_MAKE_REQUEST
229	&dev_attr_fail.attr,
230#endif
231	NULL
232};
233
234static const struct attribute_group part_attr_group = {
235	.attrs = part_attrs,
236};
237
238static const struct attribute_group *part_attr_groups[] = {
239	&part_attr_group,
240#ifdef CONFIG_BLK_DEV_IO_TRACE
241	&blk_trace_attr_group,
242#endif
243	NULL
244};
245
246static void part_release(struct device *dev)
247{
248	put_disk(dev_to_bdev(dev)->bd_disk);
249	bdev_drop(dev_to_bdev(dev));
250}
251
252static int part_uevent(const struct device *dev, struct kobj_uevent_env *env)
253{
254	const struct block_device *part = dev_to_bdev(dev);
255
256	add_uevent_var(env, "PARTN=%u", bdev_partno(part));
257	if (part->bd_meta_info && part->bd_meta_info->volname[0])
258		add_uevent_var(env, "PARTNAME=%s", part->bd_meta_info->volname);
259	if (part->bd_meta_info && part->bd_meta_info->uuid[0])
260		add_uevent_var(env, "PARTUUID=%s", part->bd_meta_info->uuid);
261	return 0;
262}
263
264const struct device_type part_type = {
265	.name		= "partition",
266	.groups		= part_attr_groups,
267	.release	= part_release,
268	.uevent		= part_uevent,
269};
270
271void drop_partition(struct block_device *part)
272{
273	lockdep_assert_held(&part->bd_disk->open_mutex);
274
275	xa_erase(&part->bd_disk->part_tbl, bdev_partno(part));
276	kobject_put(part->bd_holder_dir);
277
278	device_del(&part->bd_device);
279	put_device(&part->bd_device);
280}
281
282static ssize_t whole_disk_show(struct device *dev,
283			       struct device_attribute *attr, char *buf)
284{
285	return 0;
286}
287static const DEVICE_ATTR(whole_disk, 0444, whole_disk_show, NULL);
288
289/*
290 * Must be called either with open_mutex held, before a disk can be opened or
291 * after all disk users are gone.
292 */
293static struct block_device *add_partition(struct gendisk *disk, int partno,
294				sector_t start, sector_t len, int flags,
295				struct partition_meta_info *info)
296{
297	dev_t devt = MKDEV(0, 0);
298	struct device *ddev = disk_to_dev(disk);
299	struct device *pdev;
300	struct block_device *bdev;
301	const char *dname;
302	int err;
303
304	lockdep_assert_held(&disk->open_mutex);
305
306	if (partno >= DISK_MAX_PARTS)
307		return ERR_PTR(-EINVAL);
308
309	/*
310	 * Partitions are not supported on zoned block devices that are used as
311	 * such.
312	 */
313	if (bdev_is_zoned(disk->part0)) {
314		pr_warn("%s: partitions not supported on host managed zoned block device\n",
315			disk->disk_name);
316		return ERR_PTR(-ENXIO);
317	}
318
319	if (xa_load(&disk->part_tbl, partno))
320		return ERR_PTR(-EBUSY);
321
322	/* ensure we always have a reference to the whole disk */
323	get_device(disk_to_dev(disk));
324
325	err = -ENOMEM;
326	bdev = bdev_alloc(disk, partno);
327	if (!bdev)
328		goto out_put_disk;
329
330	bdev->bd_start_sect = start;
331	bdev_set_nr_sectors(bdev, len);
332
333	pdev = &bdev->bd_device;
334	dname = dev_name(ddev);
335	if (isdigit(dname[strlen(dname) - 1]))
336		dev_set_name(pdev, "%sp%d", dname, partno);
337	else
338		dev_set_name(pdev, "%s%d", dname, partno);
339
340	device_initialize(pdev);
341	pdev->class = &block_class;
342	pdev->type = &part_type;
343	pdev->parent = ddev;
344
345	/* in consecutive minor range? */
346	if (bdev_partno(bdev) < disk->minors) {
347		devt = MKDEV(disk->major, disk->first_minor + bdev_partno(bdev));
348	} else {
349		err = blk_alloc_ext_minor();
350		if (err < 0)
351			goto out_put;
352		devt = MKDEV(BLOCK_EXT_MAJOR, err);
353	}
354	pdev->devt = devt;
355
356	if (info) {
357		err = -ENOMEM;
358		bdev->bd_meta_info = kmemdup(info, sizeof(*info), GFP_KERNEL);
359		if (!bdev->bd_meta_info)
360			goto out_put;
361	}
362
363	/* delay uevent until 'holders' subdir is created */
364	dev_set_uevent_suppress(pdev, 1);
365	err = device_add(pdev);
366	if (err)
367		goto out_put;
368
369	err = -ENOMEM;
370	bdev->bd_holder_dir = kobject_create_and_add("holders", &pdev->kobj);
371	if (!bdev->bd_holder_dir)
372		goto out_del;
373
374	dev_set_uevent_suppress(pdev, 0);
375	if (flags & ADDPART_FLAG_WHOLEDISK) {
376		err = device_create_file(pdev, &dev_attr_whole_disk);
377		if (err)
378			goto out_del;
379	}
380
381	if (flags & ADDPART_FLAG_READONLY)
382		bdev_set_flag(bdev, BD_READ_ONLY);
383
384	/* everything is up and running, commence */
385	err = xa_insert(&disk->part_tbl, partno, bdev, GFP_KERNEL);
386	if (err)
387		goto out_del;
388	bdev_add(bdev, devt);
389
390	/* suppress uevent if the disk suppresses it */
391	if (!dev_get_uevent_suppress(ddev))
392		kobject_uevent(&pdev->kobj, KOBJ_ADD);
393	return bdev;
394
395out_del:
396	kobject_put(bdev->bd_holder_dir);
397	device_del(pdev);
398out_put:
399	put_device(pdev);
400	return ERR_PTR(err);
401out_put_disk:
402	put_disk(disk);
403	return ERR_PTR(err);
404}
405
406static bool partition_overlaps(struct gendisk *disk, sector_t start,
407		sector_t length, int skip_partno)
408{
409	struct block_device *part;
410	bool overlap = false;
411	unsigned long idx;
412
413	rcu_read_lock();
414	xa_for_each_start(&disk->part_tbl, idx, part, 1) {
415		if (bdev_partno(part) != skip_partno &&
416		    start < part->bd_start_sect + bdev_nr_sectors(part) &&
417		    start + length > part->bd_start_sect) {
418			overlap = true;
419			break;
420		}
421	}
422	rcu_read_unlock();
423
424	return overlap;
425}
426
427int bdev_add_partition(struct gendisk *disk, int partno, sector_t start,
428		sector_t length)
429{
430	struct block_device *part;
431	int ret;
432
433	mutex_lock(&disk->open_mutex);
434	if (!disk_live(disk)) {
435		ret = -ENXIO;
436		goto out;
437	}
438
439	if (disk->flags & GENHD_FL_NO_PART) {
440		ret = -EINVAL;
441		goto out;
442	}
443
444	if (partition_overlaps(disk, start, length, -1)) {
445		ret = -EBUSY;
446		goto out;
447	}
448
449	part = add_partition(disk, partno, start, length,
450			ADDPART_FLAG_NONE, NULL);
451	ret = PTR_ERR_OR_ZERO(part);
452out:
453	mutex_unlock(&disk->open_mutex);
454	return ret;
455}
456
457int bdev_del_partition(struct gendisk *disk, int partno)
458{
459	struct block_device *part = NULL;
460	int ret = -ENXIO;
461
462	mutex_lock(&disk->open_mutex);
463	part = xa_load(&disk->part_tbl, partno);
464	if (!part)
465		goto out_unlock;
466
467	ret = -EBUSY;
468	if (atomic_read(&part->bd_openers))
469		goto out_unlock;
470
471	/*
472	 * We verified that @part->bd_openers is zero above and so
473	 * @part->bd_holder{_ops} can't be set. And since we hold
474	 * @disk->open_mutex the device can't be claimed by anyone.
475	 *
476	 * So no need to call @part->bd_holder_ops->mark_dead() here.
477	 * Just delete the partition and invalidate it.
478	 */
479
480	bdev_unhash(part);
481	invalidate_bdev(part);
482	drop_partition(part);
483	ret = 0;
484out_unlock:
485	mutex_unlock(&disk->open_mutex);
486	return ret;
487}
488
489int bdev_resize_partition(struct gendisk *disk, int partno, sector_t start,
490		sector_t length)
491{
492	struct block_device *part = NULL;
493	int ret = -ENXIO;
494
495	mutex_lock(&disk->open_mutex);
496	part = xa_load(&disk->part_tbl, partno);
497	if (!part)
498		goto out_unlock;
499
500	ret = -EINVAL;
501	if (start != part->bd_start_sect)
502		goto out_unlock;
503
504	ret = -EBUSY;
505	if (partition_overlaps(disk, start, length, partno))
506		goto out_unlock;
507
508	bdev_set_nr_sectors(part, length);
509
510	ret = 0;
511out_unlock:
512	mutex_unlock(&disk->open_mutex);
513	return ret;
514}
515
516static bool disk_unlock_native_capacity(struct gendisk *disk)
517{
518	if (!disk->fops->unlock_native_capacity ||
519	    test_and_set_bit(GD_NATIVE_CAPACITY, &disk->state)) {
520		printk(KERN_CONT "truncated\n");
521		return false;
522	}
523
524	printk(KERN_CONT "enabling native capacity\n");
525	disk->fops->unlock_native_capacity(disk);
526	return true;
527}
528
529static bool blk_add_partition(struct gendisk *disk,
530		struct parsed_partitions *state, int p)
531{
532	sector_t size = state->parts[p].size;
533	sector_t from = state->parts[p].from;
534	struct block_device *part;
535
536	if (!size)
537		return true;
538
539	if (from >= get_capacity(disk)) {
540		printk(KERN_WARNING
541		       "%s: p%d start %llu is beyond EOD, ",
542		       disk->disk_name, p, (unsigned long long) from);
543		if (disk_unlock_native_capacity(disk))
544			return false;
545		return true;
546	}
547
548	if (from + size > get_capacity(disk)) {
549		printk(KERN_WARNING
550		       "%s: p%d size %llu extends beyond EOD, ",
551		       disk->disk_name, p, (unsigned long long) size);
552
553		if (disk_unlock_native_capacity(disk))
554			return false;
555
556		/*
557		 * We can not ignore partitions of broken tables created by for
558		 * example camera firmware, but we limit them to the end of the
559		 * disk to avoid creating invalid block devices.
560		 */
561		size = get_capacity(disk) - from;
562	}
563
564	part = add_partition(disk, p, from, size, state->parts[p].flags,
565			     &state->parts[p].info);
566	if (IS_ERR(part)) {
567		if (PTR_ERR(part) != -ENXIO) {
568			printk(KERN_ERR " %s: p%d could not be added: %pe\n",
569			       disk->disk_name, p, part);
570		}
571		return true;
572	}
573
574	if (IS_BUILTIN(CONFIG_BLK_DEV_MD) &&
575	    (state->parts[p].flags & ADDPART_FLAG_RAID))
576		md_autodetect_dev(part->bd_dev);
577
578	return true;
579}
580
581static int blk_add_partitions(struct gendisk *disk)
582{
583	struct parsed_partitions *state;
584	int ret = -EAGAIN, p;
585
586	if (!disk_has_partscan(disk))
587		return 0;
588
589	state = check_partition(disk);
590	if (!state)
591		return 0;
592	if (IS_ERR(state)) {
593		/*
594		 * I/O error reading the partition table.  If we tried to read
595		 * beyond EOD, retry after unlocking the native capacity.
596		 */
597		if (PTR_ERR(state) == -ENOSPC) {
598			printk(KERN_WARNING "%s: partition table beyond EOD, ",
599			       disk->disk_name);
600			if (disk_unlock_native_capacity(disk))
601				return -EAGAIN;
602		}
603		return -EIO;
604	}
605
606	/*
607	 * Partitions are not supported on host managed zoned block devices.
608	 */
609	if (bdev_is_zoned(disk->part0)) {
610		pr_warn("%s: ignoring partition table on host managed zoned block device\n",
611			disk->disk_name);
612		ret = 0;
613		goto out_free_state;
614	}
615
616	/*
617	 * If we read beyond EOD, try unlocking native capacity even if the
618	 * partition table was successfully read as we could be missing some
619	 * partitions.
620	 */
621	if (state->access_beyond_eod) {
622		printk(KERN_WARNING
623		       "%s: partition table partially beyond EOD, ",
624		       disk->disk_name);
625		if (disk_unlock_native_capacity(disk))
626			goto out_free_state;
627	}
628
629	/* tell userspace that the media / partition table may have changed */
630	kobject_uevent(&disk_to_dev(disk)->kobj, KOBJ_CHANGE);
631
632	for (p = 1; p < state->limit; p++)
633		if (!blk_add_partition(disk, state, p))
634			goto out_free_state;
635
636	ret = 0;
637out_free_state:
638	free_partitions(state);
639	return ret;
640}
641
642int bdev_disk_changed(struct gendisk *disk, bool invalidate)
643{
644	struct block_device *part;
645	unsigned long idx;
646	int ret = 0;
647
648	lockdep_assert_held(&disk->open_mutex);
649
650	if (!disk_live(disk))
651		return -ENXIO;
652
653rescan:
654	if (disk->open_partitions)
655		return -EBUSY;
656	sync_blockdev(disk->part0);
657	invalidate_bdev(disk->part0);
658
659	xa_for_each_start(&disk->part_tbl, idx, part, 1) {
660		/*
661		 * Remove the block device from the inode hash, so that
662		 * it cannot be looked up any more even when openers
663		 * still hold references.
664		 */
665		bdev_unhash(part);
666
667		/*
668		 * If @disk->open_partitions isn't elevated but there's
669		 * still an active holder of that block device things
670		 * are broken.
671		 */
672		WARN_ON_ONCE(atomic_read(&part->bd_openers));
673		invalidate_bdev(part);
674		drop_partition(part);
675	}
676	clear_bit(GD_NEED_PART_SCAN, &disk->state);
677
678	/*
679	 * Historically we only set the capacity to zero for devices that
680	 * support partitions (independ of actually having partitions created).
681	 * Doing that is rather inconsistent, but changing it broke legacy
682	 * udisks polling for legacy ide-cdrom devices.  Use the crude check
683	 * below to get the sane behavior for most device while not breaking
684	 * userspace for this particular setup.
685	 */
686	if (invalidate) {
687		if (!(disk->flags & GENHD_FL_NO_PART) ||
688		    !(disk->flags & GENHD_FL_REMOVABLE))
689			set_capacity(disk, 0);
690	}
691
692	if (get_capacity(disk)) {
693		ret = blk_add_partitions(disk);
694		if (ret == -EAGAIN)
695			goto rescan;
696	} else if (invalidate) {
697		/*
698		 * Tell userspace that the media / partition table may have
699		 * changed.
700		 */
701		kobject_uevent(&disk_to_dev(disk)->kobj, KOBJ_CHANGE);
702	}
703
704	return ret;
705}
706/*
707 * Only exported for loop and dasd for historic reasons.  Don't use in new
708 * code!
709 */
710EXPORT_SYMBOL_GPL(bdev_disk_changed);
711
712void *read_part_sector(struct parsed_partitions *state, sector_t n, Sector *p)
713{
714	struct address_space *mapping = state->disk->part0->bd_mapping;
715	struct folio *folio;
716
717	if (n >= get_capacity(state->disk)) {
718		state->access_beyond_eod = true;
719		goto out;
720	}
721
722	folio = read_mapping_folio(mapping, n >> PAGE_SECTORS_SHIFT, NULL);
723	if (IS_ERR(folio))
724		goto out;
725
726	p->v = folio;
727	return folio_address(folio) + offset_in_folio(folio, n * SECTOR_SIZE);
728out:
729	p->v = NULL;
730	return NULL;
731}