Line data Source code
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/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 :
16 : static int (*check_part[])(struct parsed_partitions *) = {
17 : /*
18 : * Probe partition formats with tables at disk address 0
19 : * that also have an ADFS boot block at 0xdc0.
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 : * Now move on to formats that only have partition info at
33 : * disk address 0xdc0. Since these may also have stale
34 : * PC/BIOS partition tables, they need to come before
35 : * the msdos entry.
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, /* this must come before msdos */
49 : #endif
50 : #ifdef CONFIG_SGI_PARTITION
51 : sgi_partition,
52 : #endif
53 : #ifdef CONFIG_LDM_PARTITION
54 : ldm_partition, /* this must come before msdos */
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 :
89 1 : static void bdev_set_nr_sectors(struct block_device *bdev, sector_t sectors)
90 : {
91 1 : spin_lock(&bdev->bd_size_lock);
92 1 : i_size_write(bdev->bd_inode, (loff_t)sectors << SECTOR_SHIFT);
93 1 : spin_unlock(&bdev->bd_size_lock);
94 1 : }
95 :
96 1 : static struct parsed_partitions *allocate_partitions(struct gendisk *hd)
97 : {
98 1 : struct parsed_partitions *state;
99 1 : int nr;
100 :
101 1 : state = kzalloc(sizeof(*state), GFP_KERNEL);
102 1 : if (!state)
103 : return NULL;
104 :
105 1 : nr = disk_max_parts(hd);
106 1 : state->parts = vzalloc(array_size(nr, sizeof(state->parts[0])));
107 1 : if (!state->parts) {
108 0 : kfree(state);
109 0 : return NULL;
110 : }
111 :
112 1 : state->limit = nr;
113 :
114 1 : return state;
115 : }
116 :
117 1 : static void free_partitions(struct parsed_partitions *state)
118 : {
119 1 : vfree(state->parts);
120 1 : kfree(state);
121 1 : }
122 :
123 1 : static struct parsed_partitions *check_partition(struct gendisk *hd,
124 : struct block_device *bdev)
125 : {
126 1 : struct parsed_partitions *state;
127 1 : int i, res, err;
128 :
129 1 : state = allocate_partitions(hd);
130 1 : if (!state)
131 : return NULL;
132 1 : state->pp_buf = (char *)__get_free_page(GFP_KERNEL);
133 1 : if (!state->pp_buf) {
134 0 : free_partitions(state);
135 0 : return NULL;
136 : }
137 1 : state->pp_buf[0] = '\0';
138 :
139 1 : state->bdev = bdev;
140 1 : disk_name(hd, 0, state->name);
141 1 : snprintf(state->pp_buf, PAGE_SIZE, " %s:", state->name);
142 1 : if (isdigit(state->name[strlen(state->name)-1]))
143 0 : sprintf(state->name, "p");
144 :
145 : i = res = err = 0;
146 2 : while (!res && check_part[i]) {
147 1 : memset(state->parts, 0, state->limit * sizeof(state->parts[0]));
148 1 : res = check_part[i++](state);
149 1 : if (res < 0) {
150 : /*
151 : * We have hit an I/O error which we don't report now.
152 : * But record it, and let the others do their job.
153 : */
154 0 : err = res;
155 0 : res = 0;
156 : }
157 :
158 : }
159 1 : if (res > 0) {
160 1 : printk(KERN_INFO "%s", state->pp_buf);
161 :
162 1 : free_page((unsigned long)state->pp_buf);
163 1 : return state;
164 : }
165 0 : if (state->access_beyond_eod)
166 : err = -ENOSPC;
167 : /*
168 : * The partition is unrecognized. So report I/O errors if there were any
169 : */
170 0 : if (err)
171 : res = err;
172 0 : if (res) {
173 0 : strlcat(state->pp_buf,
174 : " unable to read partition table\n", PAGE_SIZE);
175 0 : printk(KERN_INFO "%s", state->pp_buf);
176 : }
177 :
178 0 : free_page((unsigned long)state->pp_buf);
179 0 : free_partitions(state);
180 0 : return ERR_PTR(res);
181 : }
182 :
183 0 : static ssize_t part_partition_show(struct device *dev,
184 : struct device_attribute *attr, char *buf)
185 : {
186 0 : return sprintf(buf, "%d\n", dev_to_bdev(dev)->bd_partno);
187 : }
188 :
189 3 : static ssize_t part_start_show(struct device *dev,
190 : struct device_attribute *attr, char *buf)
191 : {
192 3 : return sprintf(buf, "%llu\n", dev_to_bdev(dev)->bd_start_sect);
193 : }
194 :
195 0 : static ssize_t part_ro_show(struct device *dev,
196 : struct device_attribute *attr, char *buf)
197 : {
198 0 : return sprintf(buf, "%d\n", bdev_read_only(dev_to_bdev(dev)));
199 : }
200 :
201 0 : static ssize_t part_alignment_offset_show(struct device *dev,
202 : struct device_attribute *attr, char *buf)
203 : {
204 0 : struct block_device *bdev = dev_to_bdev(dev);
205 :
206 0 : return sprintf(buf, "%u\n",
207 0 : queue_limit_alignment_offset(&bdev->bd_disk->queue->limits,
208 : bdev->bd_start_sect));
209 : }
210 :
211 0 : static ssize_t part_discard_alignment_show(struct device *dev,
212 : struct device_attribute *attr, char *buf)
213 : {
214 0 : struct block_device *bdev = dev_to_bdev(dev);
215 :
216 0 : return sprintf(buf, "%u\n",
217 0 : queue_limit_discard_alignment(&bdev->bd_disk->queue->limits,
218 : bdev->bd_start_sect));
219 : }
220 :
221 : static DEVICE_ATTR(partition, 0444, part_partition_show, NULL);
222 : static DEVICE_ATTR(start, 0444, part_start_show, NULL);
223 : static DEVICE_ATTR(size, 0444, part_size_show, NULL);
224 : static DEVICE_ATTR(ro, 0444, part_ro_show, NULL);
225 : static DEVICE_ATTR(alignment_offset, 0444, part_alignment_offset_show, NULL);
226 : static DEVICE_ATTR(discard_alignment, 0444, part_discard_alignment_show, NULL);
227 : static DEVICE_ATTR(stat, 0444, part_stat_show, NULL);
228 : static DEVICE_ATTR(inflight, 0444, part_inflight_show, NULL);
229 : #ifdef CONFIG_FAIL_MAKE_REQUEST
230 : static struct device_attribute dev_attr_fail =
231 : __ATTR(make-it-fail, 0644, part_fail_show, part_fail_store);
232 : #endif
233 :
234 : static struct attribute *part_attrs[] = {
235 : &dev_attr_partition.attr,
236 : &dev_attr_start.attr,
237 : &dev_attr_size.attr,
238 : &dev_attr_ro.attr,
239 : &dev_attr_alignment_offset.attr,
240 : &dev_attr_discard_alignment.attr,
241 : &dev_attr_stat.attr,
242 : &dev_attr_inflight.attr,
243 : #ifdef CONFIG_FAIL_MAKE_REQUEST
244 : &dev_attr_fail.attr,
245 : #endif
246 : NULL
247 : };
248 :
249 : static struct attribute_group part_attr_group = {
250 : .attrs = part_attrs,
251 : };
252 :
253 : static const struct attribute_group *part_attr_groups[] = {
254 : &part_attr_group,
255 : #ifdef CONFIG_BLK_DEV_IO_TRACE
256 : &blk_trace_attr_group,
257 : #endif
258 : NULL
259 : };
260 :
261 0 : static void part_release(struct device *dev)
262 : {
263 0 : blk_free_devt(dev->devt);
264 0 : bdput(dev_to_bdev(dev));
265 0 : }
266 :
267 133 : static int part_uevent(struct device *dev, struct kobj_uevent_env *env)
268 : {
269 133 : struct block_device *part = dev_to_bdev(dev);
270 :
271 133 : add_uevent_var(env, "PARTN=%u", part->bd_partno);
272 133 : if (part->bd_meta_info && part->bd_meta_info->volname[0])
273 0 : add_uevent_var(env, "PARTNAME=%s", part->bd_meta_info->volname);
274 133 : return 0;
275 : }
276 :
277 : struct device_type part_type = {
278 : .name = "partition",
279 : .groups = part_attr_groups,
280 : .release = part_release,
281 : .uevent = part_uevent,
282 : };
283 :
284 : /*
285 : * Must be called either with bd_mutex held, before a disk can be opened or
286 : * after all disk users are gone.
287 : */
288 0 : void delete_partition(struct block_device *part)
289 : {
290 0 : xa_erase(&part->bd_disk->part_tbl, part->bd_partno);
291 0 : kobject_put(part->bd_holder_dir);
292 0 : device_del(&part->bd_device);
293 :
294 : /*
295 : * Remove the block device from the inode hash, so that it cannot be
296 : * looked up any more even when openers still hold references.
297 : */
298 0 : remove_inode_hash(part->bd_inode);
299 :
300 0 : put_device(&part->bd_device);
301 0 : }
302 :
303 0 : static ssize_t whole_disk_show(struct device *dev,
304 : struct device_attribute *attr, char *buf)
305 : {
306 0 : return 0;
307 : }
308 : static DEVICE_ATTR(whole_disk, 0444, whole_disk_show, NULL);
309 :
310 : /*
311 : * Must be called either with bd_mutex held, before a disk can be opened or
312 : * after all disk users are gone.
313 : */
314 1 : static 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 1 : dev_t devt = MKDEV(0, 0);
319 1 : struct device *ddev = disk_to_dev(disk);
320 1 : struct device *pdev;
321 1 : struct block_device *bdev;
322 1 : const char *dname;
323 1 : int err;
324 :
325 : /*
326 : * Partitions are not supported on zoned block devices that are used as
327 : * such.
328 : */
329 1 : switch (disk->queue->limits.zoned) {
330 0 : case BLK_ZONED_HM:
331 0 : pr_warn("%s: partitions not supported on host managed zoned block device\n",
332 : disk->disk_name);
333 0 : return ERR_PTR(-ENXIO);
334 0 : case BLK_ZONED_HA:
335 0 : pr_info("%s: disabling host aware zoned block device support due to partitions\n",
336 : disk->disk_name);
337 0 : blk_queue_set_zoned(disk, BLK_ZONED_NONE);
338 0 : break;
339 : case BLK_ZONED_NONE:
340 : break;
341 : }
342 :
343 1 : if (xa_load(&disk->part_tbl, partno))
344 1 : return ERR_PTR(-EBUSY);
345 :
346 1 : bdev = bdev_alloc(disk, partno);
347 1 : if (!bdev)
348 1 : return ERR_PTR(-ENOMEM);
349 :
350 1 : bdev->bd_start_sect = start;
351 1 : bdev_set_nr_sectors(bdev, len);
352 :
353 1 : if (info) {
354 1 : err = -ENOMEM;
355 1 : bdev->bd_meta_info = kmemdup(info, sizeof(*info), GFP_KERNEL);
356 1 : if (!bdev->bd_meta_info)
357 0 : goto out_bdput;
358 : }
359 :
360 1 : pdev = &bdev->bd_device;
361 1 : dname = dev_name(ddev);
362 1 : if (isdigit(dname[strlen(dname) - 1]))
363 0 : dev_set_name(pdev, "%sp%d", dname, partno);
364 : else
365 1 : dev_set_name(pdev, "%s%d", dname, partno);
366 :
367 1 : device_initialize(pdev);
368 1 : pdev->class = &block_class;
369 1 : pdev->type = &part_type;
370 1 : pdev->parent = ddev;
371 :
372 1 : err = blk_alloc_devt(bdev, &devt);
373 1 : if (err)
374 0 : goto out_put;
375 1 : pdev->devt = devt;
376 :
377 : /* delay uevent until 'holders' subdir is created */
378 1 : dev_set_uevent_suppress(pdev, 1);
379 1 : err = device_add(pdev);
380 1 : if (err)
381 0 : goto out_put;
382 :
383 1 : err = -ENOMEM;
384 1 : bdev->bd_holder_dir = kobject_create_and_add("holders", &pdev->kobj);
385 1 : if (!bdev->bd_holder_dir)
386 0 : goto out_del;
387 :
388 1 : dev_set_uevent_suppress(pdev, 0);
389 1 : if (flags & ADDPART_FLAG_WHOLEDISK) {
390 0 : err = device_create_file(pdev, &dev_attr_whole_disk);
391 0 : if (err)
392 0 : goto out_del;
393 : }
394 :
395 : /* everything is up and running, commence */
396 1 : err = xa_insert(&disk->part_tbl, partno, bdev, GFP_KERNEL);
397 1 : if (err)
398 0 : goto out_del;
399 1 : bdev_add(bdev, devt);
400 :
401 : /* suppress uevent if the disk suppresses it */
402 1 : if (!dev_get_uevent_suppress(ddev))
403 0 : kobject_uevent(&pdev->kobj, KOBJ_ADD);
404 : return bdev;
405 :
406 0 : out_bdput:
407 0 : bdput(bdev);
408 0 : return ERR_PTR(err);
409 0 : out_del:
410 0 : kobject_put(bdev->bd_holder_dir);
411 0 : device_del(pdev);
412 0 : out_put:
413 0 : put_device(pdev);
414 0 : return ERR_PTR(err);
415 : }
416 :
417 0 : static bool partition_overlaps(struct gendisk *disk, sector_t start,
418 : sector_t length, int skip_partno)
419 : {
420 0 : struct disk_part_iter piter;
421 0 : struct block_device *part;
422 0 : bool overlap = false;
423 :
424 0 : disk_part_iter_init(&piter, disk, DISK_PITER_INCL_EMPTY);
425 0 : while ((part = disk_part_iter_next(&piter))) {
426 0 : if (part->bd_partno == skip_partno ||
427 0 : start >= part->bd_start_sect + bdev_nr_sectors(part) ||
428 0 : start + length <= part->bd_start_sect)
429 0 : continue;
430 : overlap = true;
431 : break;
432 : }
433 :
434 0 : disk_part_iter_exit(&piter);
435 0 : return overlap;
436 : }
437 :
438 0 : int bdev_add_partition(struct block_device *bdev, int partno,
439 : sector_t start, sector_t length)
440 : {
441 0 : struct block_device *part;
442 :
443 0 : mutex_lock(&bdev->bd_mutex);
444 0 : if (partition_overlaps(bdev->bd_disk, start, length, -1)) {
445 0 : mutex_unlock(&bdev->bd_mutex);
446 0 : return -EBUSY;
447 : }
448 :
449 0 : part = add_partition(bdev->bd_disk, partno, start, length,
450 : ADDPART_FLAG_NONE, NULL);
451 0 : mutex_unlock(&bdev->bd_mutex);
452 0 : return PTR_ERR_OR_ZERO(part);
453 : }
454 :
455 0 : int bdev_del_partition(struct block_device *bdev, int partno)
456 : {
457 0 : struct block_device *part;
458 0 : int ret;
459 :
460 0 : part = bdget_disk(bdev->bd_disk, partno);
461 0 : if (!part)
462 : return -ENXIO;
463 :
464 0 : mutex_lock(&part->bd_mutex);
465 0 : mutex_lock_nested(&bdev->bd_mutex, 1);
466 :
467 0 : ret = -EBUSY;
468 0 : if (part->bd_openers)
469 0 : goto out_unlock;
470 :
471 0 : sync_blockdev(part);
472 0 : invalidate_bdev(part);
473 :
474 0 : delete_partition(part);
475 0 : ret = 0;
476 0 : out_unlock:
477 0 : mutex_unlock(&bdev->bd_mutex);
478 0 : mutex_unlock(&part->bd_mutex);
479 0 : bdput(part);
480 0 : return ret;
481 : }
482 :
483 0 : int bdev_resize_partition(struct block_device *bdev, int partno,
484 : sector_t start, sector_t length)
485 : {
486 0 : struct block_device *part;
487 0 : int ret = 0;
488 :
489 0 : part = bdget_disk(bdev->bd_disk, partno);
490 0 : if (!part)
491 : return -ENXIO;
492 :
493 0 : mutex_lock(&part->bd_mutex);
494 0 : mutex_lock_nested(&bdev->bd_mutex, 1);
495 0 : ret = -EINVAL;
496 0 : if (start != part->bd_start_sect)
497 0 : goto out_unlock;
498 :
499 0 : ret = -EBUSY;
500 0 : if (partition_overlaps(bdev->bd_disk, start, length, partno))
501 0 : goto out_unlock;
502 :
503 0 : bdev_set_nr_sectors(part, length);
504 :
505 0 : ret = 0;
506 0 : out_unlock:
507 0 : mutex_unlock(&part->bd_mutex);
508 0 : mutex_unlock(&bdev->bd_mutex);
509 0 : bdput(part);
510 0 : return ret;
511 : }
512 :
513 0 : static bool disk_unlock_native_capacity(struct gendisk *disk)
514 : {
515 0 : const struct block_device_operations *bdops = disk->fops;
516 :
517 0 : if (bdops->unlock_native_capacity &&
518 0 : !(disk->flags & GENHD_FL_NATIVE_CAPACITY)) {
519 0 : printk(KERN_CONT "enabling native capacity\n");
520 0 : bdops->unlock_native_capacity(disk);
521 0 : disk->flags |= GENHD_FL_NATIVE_CAPACITY;
522 0 : return true;
523 : } else {
524 0 : printk(KERN_CONT "truncated\n");
525 0 : return false;
526 : }
527 : }
528 :
529 1 : int blk_drop_partitions(struct block_device *bdev)
530 : {
531 1 : struct disk_part_iter piter;
532 1 : struct block_device *part;
533 :
534 1 : if (bdev->bd_part_count)
535 : return -EBUSY;
536 :
537 1 : sync_blockdev(bdev);
538 1 : invalidate_bdev(bdev);
539 :
540 1 : disk_part_iter_init(&piter, bdev->bd_disk, DISK_PITER_INCL_EMPTY);
541 1 : while ((part = disk_part_iter_next(&piter)))
542 0 : delete_partition(part);
543 1 : disk_part_iter_exit(&piter);
544 :
545 1 : return 0;
546 : }
547 : #ifdef CONFIG_S390
548 : /* for historic reasons in the DASD driver */
549 : EXPORT_SYMBOL_GPL(blk_drop_partitions);
550 : #endif
551 :
552 255 : static bool blk_add_partition(struct gendisk *disk, struct block_device *bdev,
553 : struct parsed_partitions *state, int p)
554 : {
555 255 : sector_t size = state->parts[p].size;
556 255 : sector_t from = state->parts[p].from;
557 255 : struct block_device *part;
558 :
559 255 : if (!size)
560 : return true;
561 :
562 1 : if (from >= get_capacity(disk)) {
563 0 : printk(KERN_WARNING
564 : "%s: p%d start %llu is beyond EOD, ",
565 0 : disk->disk_name, p, (unsigned long long) from);
566 0 : if (disk_unlock_native_capacity(disk))
567 : return false;
568 0 : return true;
569 : }
570 :
571 1 : if (from + size > get_capacity(disk)) {
572 0 : printk(KERN_WARNING
573 : "%s: p%d size %llu extends beyond EOD, ",
574 0 : disk->disk_name, p, (unsigned long long) size);
575 :
576 0 : if (disk_unlock_native_capacity(disk))
577 : return false;
578 :
579 : /*
580 : * We can not ignore partitions of broken tables created by for
581 : * example camera firmware, but we limit them to the end of the
582 : * disk to avoid creating invalid block devices.
583 : */
584 0 : size = get_capacity(disk) - from;
585 : }
586 :
587 2 : part = add_partition(disk, p, from, size, state->parts[p].flags,
588 1 : &state->parts[p].info);
589 1 : if (IS_ERR(part) && PTR_ERR(part) != -ENXIO) {
590 0 : printk(KERN_ERR " %s: p%d could not be added: %ld\n",
591 0 : disk->disk_name, p, -PTR_ERR(part));
592 0 : return true;
593 : }
594 :
595 : if (IS_BUILTIN(CONFIG_BLK_DEV_MD) &&
596 : (state->parts[p].flags & ADDPART_FLAG_RAID))
597 : md_autodetect_dev(part->bd_dev);
598 :
599 : return true;
600 : }
601 :
602 1 : int blk_add_partitions(struct gendisk *disk, struct block_device *bdev)
603 : {
604 1 : struct parsed_partitions *state;
605 1 : int ret = -EAGAIN, p;
606 :
607 2 : if (!disk_part_scan_enabled(disk))
608 : return 0;
609 :
610 1 : state = check_partition(disk, bdev);
611 1 : if (!state)
612 : return 0;
613 1 : if (IS_ERR(state)) {
614 : /*
615 : * I/O error reading the partition table. If we tried to read
616 : * beyond EOD, retry after unlocking the native capacity.
617 : */
618 0 : if (PTR_ERR(state) == -ENOSPC) {
619 0 : printk(KERN_WARNING "%s: partition table beyond EOD, ",
620 0 : disk->disk_name);
621 0 : if (disk_unlock_native_capacity(disk))
622 : return -EAGAIN;
623 : }
624 0 : return -EIO;
625 : }
626 :
627 : /*
628 : * Partitions are not supported on host managed zoned block devices.
629 : */
630 1 : if (disk->queue->limits.zoned == BLK_ZONED_HM) {
631 0 : pr_warn("%s: ignoring partition table on host managed zoned block device\n",
632 : disk->disk_name);
633 0 : ret = 0;
634 0 : goto out_free_state;
635 : }
636 :
637 : /*
638 : * If we read beyond EOD, try unlocking native capacity even if the
639 : * partition table was successfully read as we could be missing some
640 : * partitions.
641 : */
642 1 : if (state->access_beyond_eod) {
643 0 : printk(KERN_WARNING
644 : "%s: partition table partially beyond EOD, ",
645 0 : disk->disk_name);
646 0 : if (disk_unlock_native_capacity(disk))
647 0 : goto out_free_state;
648 : }
649 :
650 : /* tell userspace that the media / partition table may have changed */
651 1 : kobject_uevent(&disk_to_dev(disk)->kobj, KOBJ_CHANGE);
652 :
653 257 : for (p = 1; p < state->limit; p++)
654 255 : if (!blk_add_partition(disk, bdev, state, p))
655 0 : goto out_free_state;
656 :
657 : ret = 0;
658 1 : out_free_state:
659 1 : free_partitions(state);
660 1 : return ret;
661 : }
662 :
663 1 : void *read_part_sector(struct parsed_partitions *state, sector_t n, Sector *p)
664 : {
665 1 : struct address_space *mapping = state->bdev->bd_inode->i_mapping;
666 1 : struct page *page;
667 :
668 1 : if (n >= get_capacity(state->bdev->bd_disk)) {
669 0 : state->access_beyond_eod = true;
670 0 : return NULL;
671 : }
672 :
673 2 : page = read_mapping_page(mapping,
674 1 : (pgoff_t)(n >> (PAGE_SHIFT - 9)), NULL);
675 1 : if (IS_ERR(page))
676 0 : goto out;
677 2 : if (PageError(page))
678 0 : goto out_put_page;
679 :
680 1 : p->v = page;
681 1 : return (unsigned char *)page_address(page) +
682 1 : ((n & ((1 << (PAGE_SHIFT - 9)) - 1)) << SECTOR_SHIFT);
683 0 : out_put_page:
684 0 : put_page(page);
685 0 : out:
686 0 : p->v = NULL;
687 0 : return NULL;
688 : }
|
