1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (C) 1991-1998 Linus Torvalds 4 * Re-organised Feb 1998 Russell King 5 */ 6 #include <linux/fs.h> 7 #include <linux/slab.h> 8 #include <linux/ctype.h> 9 #include <linux/genhd.h> 10 #include <linux/vmalloc.h> 11 #include <linux/blktrace_api.h> 12 #include <linux/raid/detect.h> 13 #include "check.h" 14 15 static int (*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_EFI_PARTITION 47 efi_partition, /* this must come before msdos */ 48 #endif 49 #ifdef CONFIG_SGI_PARTITION 50 sgi_partition, 51 #endif 52 #ifdef CONFIG_LDM_PARTITION 53 ldm_partition, /* this must come before msdos */ 54 #endif 55 #ifdef CONFIG_MSDOS_PARTITION 56 msdos_partition, 57 #endif 58 #ifdef CONFIG_OSF_PARTITION 59 osf_partition, 60 #endif 61 #ifdef CONFIG_SUN_PARTITION 62 sun_partition, 63 #endif 64 #ifdef CONFIG_AMIGA_PARTITION 65 amiga_partition, 66 #endif 67 #ifdef CONFIG_ATARI_PARTITION 68 atari_partition, 69 #endif 70 #ifdef CONFIG_MAC_PARTITION 71 mac_partition, 72 #endif 73 #ifdef CONFIG_ULTRIX_PARTITION 74 ultrix_partition, 75 #endif 76 #ifdef CONFIG_IBM_PARTITION 77 ibm_partition, 78 #endif 79 #ifdef CONFIG_KARMA_PARTITION 80 karma_partition, 81 #endif 82 #ifdef CONFIG_SYSV68_PARTITION 83 sysv68_partition, 84 #endif 85 NULL 86 }; 87 88 static struct parsed_partitions *allocate_partitions(struct gendisk *hd) 89 { 90 struct parsed_partitions *state; 91 int nr; 92 93 state = kzalloc(sizeof(*state), GFP_KERNEL); 94 if (!state) 95 return NULL; 96 97 nr = disk_max_parts(hd); 98 state->parts = vzalloc(array_size(nr, sizeof(state->parts[0]))); 99 if (!state->parts) { 100 kfree(state); 101 return NULL; 102 } 103 104 state->limit = nr; 105 106 return state; 107 } 108 109 static void free_partitions(struct parsed_partitions *state) 110 { 111 vfree(state->parts); 112 kfree(state); 113 } 114 115 static struct parsed_partitions *check_partition(struct gendisk *hd, 116 struct block_device *bdev) 117 { 118 struct parsed_partitions *state; 119 int i, res, err; 120 121 state = allocate_partitions(hd); 122 if (!state) 123 return NULL; 124 state->pp_buf = (char *)__get_free_page(GFP_KERNEL); 125 if (!state->pp_buf) { 126 free_partitions(state); 127 return NULL; 128 } 129 state->pp_buf[0] = '\0'; 130 131 state->bdev = bdev; 132 disk_name(hd, 0, state->name); 133 snprintf(state->pp_buf, PAGE_SIZE, " %s:", state->name); 134 if (isdigit(state->name[strlen(state->name)-1])) 135 sprintf(state->name, "p"); 136 137 i = res = err = 0; 138 while (!res && check_part[i]) { 139 memset(state->parts, 0, state->limit * sizeof(state->parts[0])); 140 res = check_part[i++](state); 141 if (res < 0) { 142 /* 143 * We have hit an I/O error which we don't report now. 144 * But record it, and let the others do their job. 145 */ 146 err = res; 147 res = 0; 148 } 149 150 } 151 if (res > 0) { 152 printk(KERN_INFO "%s", state->pp_buf); 153 154 free_page((unsigned long)state->pp_buf); 155 return state; 156 } 157 if (state->access_beyond_eod) 158 err = -ENOSPC; 159 /* 160 * The partition is unrecognized. So report I/O errors if there were any 161 */ 162 if (err) 163 res = err; 164 if (res) { 165 strlcat(state->pp_buf, 166 " unable to read partition table\n", PAGE_SIZE); 167 printk(KERN_INFO "%s", state->pp_buf); 168 } 169 170 free_page((unsigned long)state->pp_buf); 171 free_partitions(state); 172 return ERR_PTR(res); 173 } 174 175 static ssize_t part_partition_show(struct device *dev, 176 struct device_attribute *attr, char *buf) 177 { 178 struct hd_struct *p = dev_to_part(dev); 179 180 return sprintf(buf, "%d\n", p->partno); 181 } 182 183 static ssize_t part_start_show(struct device *dev, 184 struct device_attribute *attr, char *buf) 185 { 186 struct hd_struct *p = dev_to_part(dev); 187 188 return sprintf(buf, "%llu\n",(unsigned long long)p->start_sect); 189 } 190 191 static ssize_t part_ro_show(struct device *dev, 192 struct device_attribute *attr, char *buf) 193 { 194 struct hd_struct *p = dev_to_part(dev); 195 return sprintf(buf, "%d\n", p->policy ? 1 : 0); 196 } 197 198 static ssize_t part_alignment_offset_show(struct device *dev, 199 struct device_attribute *attr, char *buf) 200 { 201 struct hd_struct *p = dev_to_part(dev); 202 return sprintf(buf, "%llu\n", (unsigned long long)p->alignment_offset); 203 } 204 205 static ssize_t part_discard_alignment_show(struct device *dev, 206 struct device_attribute *attr, char *buf) 207 { 208 struct hd_struct *p = dev_to_part(dev); 209 return sprintf(buf, "%u\n", p->discard_alignment); 210 } 211 212 static DEVICE_ATTR(partition, 0444, part_partition_show, NULL); 213 static DEVICE_ATTR(start, 0444, part_start_show, NULL); 214 static DEVICE_ATTR(size, 0444, part_size_show, NULL); 215 static DEVICE_ATTR(ro, 0444, part_ro_show, NULL); 216 static DEVICE_ATTR(alignment_offset, 0444, part_alignment_offset_show, NULL); 217 static DEVICE_ATTR(discard_alignment, 0444, part_discard_alignment_show, NULL); 218 static DEVICE_ATTR(stat, 0444, part_stat_show, NULL); 219 static DEVICE_ATTR(inflight, 0444, part_inflight_show, NULL); 220 #ifdef CONFIG_FAIL_MAKE_REQUEST 221 static struct device_attribute dev_attr_fail = 222 __ATTR(make-it-fail, 0644, part_fail_show, part_fail_store); 223 #endif 224 225 static struct attribute *part_attrs[] = { 226 &dev_attr_partition.attr, 227 &dev_attr_start.attr, 228 &dev_attr_size.attr, 229 &dev_attr_ro.attr, 230 &dev_attr_alignment_offset.attr, 231 &dev_attr_discard_alignment.attr, 232 &dev_attr_stat.attr, 233 &dev_attr_inflight.attr, 234 #ifdef CONFIG_FAIL_MAKE_REQUEST 235 &dev_attr_fail.attr, 236 #endif 237 NULL 238 }; 239 240 static struct attribute_group part_attr_group = { 241 .attrs = part_attrs, 242 }; 243 244 static const struct attribute_group *part_attr_groups[] = { 245 &part_attr_group, 246 #ifdef CONFIG_BLK_DEV_IO_TRACE 247 &blk_trace_attr_group, 248 #endif 249 NULL 250 }; 251 252 static void part_release(struct device *dev) 253 { 254 struct hd_struct *p = dev_to_part(dev); 255 blk_free_devt(dev->devt); 256 hd_free_part(p); 257 kfree(p); 258 } 259 260 static int part_uevent(struct device *dev, struct kobj_uevent_env *env) 261 { 262 struct hd_struct *part = dev_to_part(dev); 263 264 add_uevent_var(env, "PARTN=%u", part->partno); 265 if (part->info && part->info->volname[0]) 266 add_uevent_var(env, "PARTNAME=%s", part->info->volname); 267 return 0; 268 } 269 270 struct device_type part_type = { 271 .name = "partition", 272 .groups = part_attr_groups, 273 .release = part_release, 274 .uevent = part_uevent, 275 }; 276 277 static void hd_struct_free_work(struct work_struct *work) 278 { 279 struct hd_struct *part = 280 container_of(to_rcu_work(work), struct hd_struct, rcu_work); 281 282 part->start_sect = 0; 283 part->nr_sects = 0; 284 part_stat_set_all(part, 0); 285 put_device(part_to_dev(part)); 286 } 287 288 static void hd_struct_free(struct percpu_ref *ref) 289 { 290 struct hd_struct *part = container_of(ref, struct hd_struct, ref); 291 struct gendisk *disk = part_to_disk(part); 292 struct disk_part_tbl *ptbl = 293 rcu_dereference_protected(disk->part_tbl, 1); 294 295 rcu_assign_pointer(ptbl->last_lookup, NULL); 296 put_device(disk_to_dev(disk)); 297 298 INIT_RCU_WORK(&part->rcu_work, hd_struct_free_work); 299 queue_rcu_work(system_wq, &part->rcu_work); 300 } 301 302 int hd_ref_init(struct hd_struct *part) 303 { 304 if (percpu_ref_init(&part->ref, hd_struct_free, 0, GFP_KERNEL)) 305 return -ENOMEM; 306 return 0; 307 } 308 309 /* 310 * Must be called either with bd_mutex held, before a disk can be opened or 311 * after all disk users are gone. 312 */ 313 void delete_partition(struct gendisk *disk, struct hd_struct *part) 314 { 315 struct disk_part_tbl *ptbl = 316 rcu_dereference_protected(disk->part_tbl, 1); 317 318 /* 319 * ->part_tbl is referenced in this part's release handler, so 320 * we have to hold the disk device 321 */ 322 get_device(disk_to_dev(part_to_disk(part))); 323 rcu_assign_pointer(ptbl->part[part->partno], NULL); 324 kobject_put(part->holder_dir); 325 device_del(part_to_dev(part)); 326 327 /* 328 * Remove gendisk pointer from idr so that it cannot be looked up 329 * while RCU period before freeing gendisk is running to prevent 330 * use-after-free issues. Note that the device number stays 331 * "in-use" until we really free the gendisk. 332 */ 333 blk_invalidate_devt(part_devt(part)); 334 percpu_ref_kill(&part->ref); 335 } 336 337 static ssize_t whole_disk_show(struct device *dev, 338 struct device_attribute *attr, char *buf) 339 { 340 return 0; 341 } 342 static DEVICE_ATTR(whole_disk, 0444, whole_disk_show, NULL); 343 344 /* 345 * Must be called either with bd_mutex held, before a disk can be opened or 346 * after all disk users are gone. 347 */ 348 static struct hd_struct *add_partition(struct gendisk *disk, int partno, 349 sector_t start, sector_t len, int flags, 350 struct partition_meta_info *info) 351 { 352 struct hd_struct *p; 353 dev_t devt = MKDEV(0, 0); 354 struct device *ddev = disk_to_dev(disk); 355 struct device *pdev; 356 struct disk_part_tbl *ptbl; 357 const char *dname; 358 int err; 359 360 /* 361 * Partitions are not supported on zoned block devices that are used as 362 * such. 363 */ 364 switch (disk->queue->limits.zoned) { 365 case BLK_ZONED_HM: 366 pr_warn("%s: partitions not supported on host managed zoned block device\n", 367 disk->disk_name); 368 return ERR_PTR(-ENXIO); 369 case BLK_ZONED_HA: 370 pr_info("%s: disabling host aware zoned block device support due to partitions\n", 371 disk->disk_name); 372 disk->queue->limits.zoned = BLK_ZONED_NONE; 373 break; 374 case BLK_ZONED_NONE: 375 break; 376 } 377 378 err = disk_expand_part_tbl(disk, partno); 379 if (err) 380 return ERR_PTR(err); 381 ptbl = rcu_dereference_protected(disk->part_tbl, 1); 382 383 if (ptbl->part[partno]) 384 return ERR_PTR(-EBUSY); 385 386 p = kzalloc(sizeof(*p), GFP_KERNEL); 387 if (!p) 388 return ERR_PTR(-EBUSY); 389 390 p->dkstats = alloc_percpu(struct disk_stats); 391 if (!p->dkstats) { 392 err = -ENOMEM; 393 goto out_free; 394 } 395 396 hd_sects_seq_init(p); 397 pdev = part_to_dev(p); 398 399 p->start_sect = start; 400 p->alignment_offset = 401 queue_limit_alignment_offset(&disk->queue->limits, start); 402 p->discard_alignment = 403 queue_limit_discard_alignment(&disk->queue->limits, start); 404 p->nr_sects = len; 405 p->partno = partno; 406 p->policy = get_disk_ro(disk); 407 408 if (info) { 409 struct partition_meta_info *pinfo; 410 411 pinfo = kzalloc_node(sizeof(*pinfo), GFP_KERNEL, disk->node_id); 412 if (!pinfo) { 413 err = -ENOMEM; 414 goto out_free_stats; 415 } 416 memcpy(pinfo, info, sizeof(*info)); 417 p->info = pinfo; 418 } 419 420 dname = dev_name(ddev); 421 if (isdigit(dname[strlen(dname) - 1])) 422 dev_set_name(pdev, "%sp%d", dname, partno); 423 else 424 dev_set_name(pdev, "%s%d", dname, partno); 425 426 device_initialize(pdev); 427 pdev->class = &block_class; 428 pdev->type = &part_type; 429 pdev->parent = ddev; 430 431 err = blk_alloc_devt(p, &devt); 432 if (err) 433 goto out_free_info; 434 pdev->devt = devt; 435 436 /* delay uevent until 'holders' subdir is created */ 437 dev_set_uevent_suppress(pdev, 1); 438 err = device_add(pdev); 439 if (err) 440 goto out_put; 441 442 err = -ENOMEM; 443 p->holder_dir = kobject_create_and_add("holders", &pdev->kobj); 444 if (!p->holder_dir) 445 goto out_del; 446 447 dev_set_uevent_suppress(pdev, 0); 448 if (flags & ADDPART_FLAG_WHOLEDISK) { 449 err = device_create_file(pdev, &dev_attr_whole_disk); 450 if (err) 451 goto out_del; 452 } 453 454 err = hd_ref_init(p); 455 if (err) { 456 if (flags & ADDPART_FLAG_WHOLEDISK) 457 goto out_remove_file; 458 goto out_del; 459 } 460 461 /* everything is up and running, commence */ 462 rcu_assign_pointer(ptbl->part[partno], p); 463 464 /* suppress uevent if the disk suppresses it */ 465 if (!dev_get_uevent_suppress(ddev)) 466 kobject_uevent(&pdev->kobj, KOBJ_ADD); 467 return p; 468 469 out_free_info: 470 kfree(p->info); 471 out_free_stats: 472 free_percpu(p->dkstats); 473 out_free: 474 kfree(p); 475 return ERR_PTR(err); 476 out_remove_file: 477 device_remove_file(pdev, &dev_attr_whole_disk); 478 out_del: 479 kobject_put(p->holder_dir); 480 device_del(pdev); 481 out_put: 482 put_device(pdev); 483 return ERR_PTR(err); 484 } 485 486 static bool partition_overlaps(struct gendisk *disk, sector_t start, 487 sector_t length, int skip_partno) 488 { 489 struct disk_part_iter piter; 490 struct hd_struct *part; 491 bool overlap = false; 492 493 disk_part_iter_init(&piter, disk, DISK_PITER_INCL_EMPTY); 494 while ((part = disk_part_iter_next(&piter))) { 495 if (part->partno == skip_partno || 496 start >= part->start_sect + part->nr_sects || 497 start + length <= part->start_sect) 498 continue; 499 overlap = true; 500 break; 501 } 502 503 disk_part_iter_exit(&piter); 504 return overlap; 505 } 506 507 int bdev_add_partition(struct block_device *bdev, int partno, 508 sector_t start, sector_t length) 509 { 510 struct hd_struct *part; 511 512 mutex_lock(&bdev->bd_mutex); 513 if (partition_overlaps(bdev->bd_disk, start, length, -1)) { 514 mutex_unlock(&bdev->bd_mutex); 515 return -EBUSY; 516 } 517 518 part = add_partition(bdev->bd_disk, partno, start, length, 519 ADDPART_FLAG_NONE, NULL); 520 mutex_unlock(&bdev->bd_mutex); 521 return PTR_ERR_OR_ZERO(part); 522 } 523 524 int bdev_del_partition(struct block_device *bdev, int partno) 525 { 526 struct block_device *bdevp; 527 struct hd_struct *part; 528 int ret = 0; 529 530 part = disk_get_part(bdev->bd_disk, partno); 531 if (!part) 532 return -ENXIO; 533 534 ret = -ENOMEM; 535 bdevp = bdget(part_devt(part)); 536 if (!bdevp) 537 goto out_put_part; 538 539 mutex_lock(&bdevp->bd_mutex); 540 541 ret = -EBUSY; 542 if (bdevp->bd_openers) 543 goto out_unlock; 544 545 sync_blockdev(bdevp); 546 invalidate_bdev(bdevp); 547 548 mutex_lock_nested(&bdev->bd_mutex, 1); 549 delete_partition(bdev->bd_disk, part); 550 mutex_unlock(&bdev->bd_mutex); 551 552 ret = 0; 553 out_unlock: 554 mutex_unlock(&bdevp->bd_mutex); 555 bdput(bdevp); 556 out_put_part: 557 disk_put_part(part); 558 return ret; 559 } 560 561 int bdev_resize_partition(struct block_device *bdev, int partno, 562 sector_t start, sector_t length) 563 { 564 struct block_device *bdevp; 565 struct hd_struct *part; 566 int ret = 0; 567 568 part = disk_get_part(bdev->bd_disk, partno); 569 if (!part) 570 return -ENXIO; 571 572 ret = -ENOMEM; 573 bdevp = bdget(part_devt(part)); 574 if (!bdevp) 575 goto out_put_part; 576 577 mutex_lock(&bdevp->bd_mutex); 578 mutex_lock_nested(&bdev->bd_mutex, 1); 579 580 ret = -EINVAL; 581 if (start != part->start_sect) 582 goto out_unlock; 583 584 ret = -EBUSY; 585 if (partition_overlaps(bdev->bd_disk, start, length, partno)) 586 goto out_unlock; 587 588 part_nr_sects_write(part, (sector_t)length); 589 i_size_write(bdevp->bd_inode, length << SECTOR_SHIFT); 590 591 ret = 0; 592 out_unlock: 593 mutex_unlock(&bdevp->bd_mutex); 594 mutex_unlock(&bdev->bd_mutex); 595 bdput(bdevp); 596 out_put_part: 597 disk_put_part(part); 598 return ret; 599 } 600 601 static bool disk_unlock_native_capacity(struct gendisk *disk) 602 { 603 const struct block_device_operations *bdops = disk->fops; 604 605 if (bdops->unlock_native_capacity && 606 !(disk->flags & GENHD_FL_NATIVE_CAPACITY)) { 607 printk(KERN_CONT "enabling native capacity\n"); 608 bdops->unlock_native_capacity(disk); 609 disk->flags |= GENHD_FL_NATIVE_CAPACITY; 610 return true; 611 } else { 612 printk(KERN_CONT "truncated\n"); 613 return false; 614 } 615 } 616 617 int blk_drop_partitions(struct block_device *bdev) 618 { 619 struct disk_part_iter piter; 620 struct hd_struct *part; 621 622 if (bdev->bd_part_count) 623 return -EBUSY; 624 625 sync_blockdev(bdev); 626 invalidate_bdev(bdev); 627 628 disk_part_iter_init(&piter, bdev->bd_disk, DISK_PITER_INCL_EMPTY); 629 while ((part = disk_part_iter_next(&piter))) 630 delete_partition(bdev->bd_disk, part); 631 disk_part_iter_exit(&piter); 632 633 return 0; 634 } 635 #ifdef CONFIG_S390 636 /* for historic reasons in the DASD driver */ 637 EXPORT_SYMBOL_GPL(blk_drop_partitions); 638 #endif 639 640 static bool blk_add_partition(struct gendisk *disk, struct block_device *bdev, 641 struct parsed_partitions *state, int p) 642 { 643 sector_t size = state->parts[p].size; 644 sector_t from = state->parts[p].from; 645 struct hd_struct *part; 646 647 if (!size) 648 return true; 649 650 if (from >= get_capacity(disk)) { 651 printk(KERN_WARNING 652 "%s: p%d start %llu is beyond EOD, ", 653 disk->disk_name, p, (unsigned long long) from); 654 if (disk_unlock_native_capacity(disk)) 655 return false; 656 return true; 657 } 658 659 if (from + size > get_capacity(disk)) { 660 printk(KERN_WARNING 661 "%s: p%d size %llu extends beyond EOD, ", 662 disk->disk_name, p, (unsigned long long) size); 663 664 if (disk_unlock_native_capacity(disk)) 665 return false; 666 667 /* 668 * We can not ignore partitions of broken tables created by for 669 * example camera firmware, but we limit them to the end of the 670 * disk to avoid creating invalid block devices. 671 */ 672 size = get_capacity(disk) - from; 673 } 674 675 part = add_partition(disk, p, from, size, state->parts[p].flags, 676 &state->parts[p].info); 677 if (IS_ERR(part) && PTR_ERR(part) != -ENXIO) { 678 printk(KERN_ERR " %s: p%d could not be added: %ld\n", 679 disk->disk_name, p, -PTR_ERR(part)); 680 return true; 681 } 682 683 if (IS_BUILTIN(CONFIG_BLK_DEV_MD) && 684 (state->parts[p].flags & ADDPART_FLAG_RAID)) 685 md_autodetect_dev(part_to_dev(part)->devt); 686 687 return true; 688 } 689 690 int blk_add_partitions(struct gendisk *disk, struct block_device *bdev) 691 { 692 struct parsed_partitions *state; 693 int ret = -EAGAIN, p, highest; 694 695 if (!disk_part_scan_enabled(disk)) 696 return 0; 697 698 state = check_partition(disk, bdev); 699 if (!state) 700 return 0; 701 if (IS_ERR(state)) { 702 /* 703 * I/O error reading the partition table. If we tried to read 704 * beyond EOD, retry after unlocking the native capacity. 705 */ 706 if (PTR_ERR(state) == -ENOSPC) { 707 printk(KERN_WARNING "%s: partition table beyond EOD, ", 708 disk->disk_name); 709 if (disk_unlock_native_capacity(disk)) 710 return -EAGAIN; 711 } 712 return -EIO; 713 } 714 715 /* 716 * Partitions are not supported on host managed zoned block devices. 717 */ 718 if (disk->queue->limits.zoned == BLK_ZONED_HM) { 719 pr_warn("%s: ignoring partition table on host managed zoned block device\n", 720 disk->disk_name); 721 ret = 0; 722 goto out_free_state; 723 } 724 725 /* 726 * If we read beyond EOD, try unlocking native capacity even if the 727 * partition table was successfully read as we could be missing some 728 * partitions. 729 */ 730 if (state->access_beyond_eod) { 731 printk(KERN_WARNING 732 "%s: partition table partially beyond EOD, ", 733 disk->disk_name); 734 if (disk_unlock_native_capacity(disk)) 735 goto out_free_state; 736 } 737 738 /* tell userspace that the media / partition table may have changed */ 739 kobject_uevent(&disk_to_dev(disk)->kobj, KOBJ_CHANGE); 740 741 /* 742 * Detect the highest partition number and preallocate disk->part_tbl. 743 * This is an optimization and not strictly necessary. 744 */ 745 for (p = 1, highest = 0; p < state->limit; p++) 746 if (state->parts[p].size) 747 highest = p; 748 disk_expand_part_tbl(disk, highest); 749 750 for (p = 1; p < state->limit; p++) 751 if (!blk_add_partition(disk, bdev, state, p)) 752 goto out_free_state; 753 754 ret = 0; 755 out_free_state: 756 free_partitions(state); 757 return ret; 758 } 759 760 void *read_part_sector(struct parsed_partitions *state, sector_t n, Sector *p) 761 { 762 struct address_space *mapping = state->bdev->bd_inode->i_mapping; 763 struct page *page; 764 765 if (n >= get_capacity(state->bdev->bd_disk)) { 766 state->access_beyond_eod = true; 767 return NULL; 768 } 769 770 page = read_mapping_page(mapping, 771 (pgoff_t)(n >> (PAGE_SHIFT - 9)), NULL); 772 if (IS_ERR(page)) 773 goto out; 774 if (PageError(page)) 775 goto out_put_page; 776 777 p->v = page; 778 return (unsigned char *)page_address(page) + 779 ((n & ((1 << (PAGE_SHIFT - 9)) - 1)) << SECTOR_SHIFT); 780 out_put_page: 781 put_page(page); 782 out: 783 p->v = NULL; 784 return NULL; 785 } 786