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 (!disk_part_scan_enabled(bdev->bd_disk)) 623 return 0; 624 if (bdev->bd_part_count) 625 return -EBUSY; 626 627 sync_blockdev(bdev); 628 invalidate_bdev(bdev); 629 630 disk_part_iter_init(&piter, bdev->bd_disk, DISK_PITER_INCL_EMPTY); 631 while ((part = disk_part_iter_next(&piter))) 632 delete_partition(bdev->bd_disk, part); 633 disk_part_iter_exit(&piter); 634 635 return 0; 636 } 637 #ifdef CONFIG_S390 638 /* for historic reasons in the DASD driver */ 639 EXPORT_SYMBOL_GPL(blk_drop_partitions); 640 #endif 641 642 static bool blk_add_partition(struct gendisk *disk, struct block_device *bdev, 643 struct parsed_partitions *state, int p) 644 { 645 sector_t size = state->parts[p].size; 646 sector_t from = state->parts[p].from; 647 struct hd_struct *part; 648 649 if (!size) 650 return true; 651 652 if (from >= get_capacity(disk)) { 653 printk(KERN_WARNING 654 "%s: p%d start %llu is beyond EOD, ", 655 disk->disk_name, p, (unsigned long long) from); 656 if (disk_unlock_native_capacity(disk)) 657 return false; 658 return true; 659 } 660 661 if (from + size > get_capacity(disk)) { 662 printk(KERN_WARNING 663 "%s: p%d size %llu extends beyond EOD, ", 664 disk->disk_name, p, (unsigned long long) size); 665 666 if (disk_unlock_native_capacity(disk)) 667 return false; 668 669 /* 670 * We can not ignore partitions of broken tables created by for 671 * example camera firmware, but we limit them to the end of the 672 * disk to avoid creating invalid block devices. 673 */ 674 size = get_capacity(disk) - from; 675 } 676 677 part = add_partition(disk, p, from, size, state->parts[p].flags, 678 &state->parts[p].info); 679 if (IS_ERR(part) && PTR_ERR(part) != -ENXIO) { 680 printk(KERN_ERR " %s: p%d could not be added: %ld\n", 681 disk->disk_name, p, -PTR_ERR(part)); 682 return true; 683 } 684 685 if (IS_BUILTIN(CONFIG_BLK_DEV_MD) && 686 (state->parts[p].flags & ADDPART_FLAG_RAID)) 687 md_autodetect_dev(part_to_dev(part)->devt); 688 689 return true; 690 } 691 692 int blk_add_partitions(struct gendisk *disk, struct block_device *bdev) 693 { 694 struct parsed_partitions *state; 695 int ret = -EAGAIN, p, highest; 696 697 if (!disk_part_scan_enabled(disk)) 698 return 0; 699 700 state = check_partition(disk, bdev); 701 if (!state) 702 return 0; 703 if (IS_ERR(state)) { 704 /* 705 * I/O error reading the partition table. If we tried to read 706 * beyond EOD, retry after unlocking the native capacity. 707 */ 708 if (PTR_ERR(state) == -ENOSPC) { 709 printk(KERN_WARNING "%s: partition table beyond EOD, ", 710 disk->disk_name); 711 if (disk_unlock_native_capacity(disk)) 712 return -EAGAIN; 713 } 714 return -EIO; 715 } 716 717 /* 718 * Partitions are not supported on host managed zoned block devices. 719 */ 720 if (disk->queue->limits.zoned == BLK_ZONED_HM) { 721 pr_warn("%s: ignoring partition table on host managed zoned block device\n", 722 disk->disk_name); 723 ret = 0; 724 goto out_free_state; 725 } 726 727 /* 728 * If we read beyond EOD, try unlocking native capacity even if the 729 * partition table was successfully read as we could be missing some 730 * partitions. 731 */ 732 if (state->access_beyond_eod) { 733 printk(KERN_WARNING 734 "%s: partition table partially beyond EOD, ", 735 disk->disk_name); 736 if (disk_unlock_native_capacity(disk)) 737 goto out_free_state; 738 } 739 740 /* tell userspace that the media / partition table may have changed */ 741 kobject_uevent(&disk_to_dev(disk)->kobj, KOBJ_CHANGE); 742 743 /* 744 * Detect the highest partition number and preallocate disk->part_tbl. 745 * This is an optimization and not strictly necessary. 746 */ 747 for (p = 1, highest = 0; p < state->limit; p++) 748 if (state->parts[p].size) 749 highest = p; 750 disk_expand_part_tbl(disk, highest); 751 752 for (p = 1; p < state->limit; p++) 753 if (!blk_add_partition(disk, bdev, state, p)) 754 goto out_free_state; 755 756 ret = 0; 757 out_free_state: 758 free_partitions(state); 759 return ret; 760 } 761 762 void *read_part_sector(struct parsed_partitions *state, sector_t n, Sector *p) 763 { 764 struct address_space *mapping = state->bdev->bd_inode->i_mapping; 765 struct page *page; 766 767 if (n >= get_capacity(state->bdev->bd_disk)) { 768 state->access_beyond_eod = true; 769 return NULL; 770 } 771 772 page = read_mapping_page(mapping, 773 (pgoff_t)(n >> (PAGE_SHIFT - 9)), NULL); 774 if (IS_ERR(page)) 775 goto out; 776 if (PageError(page)) 777 goto out_put_page; 778 779 p->v = page; 780 return (unsigned char *)page_address(page) + 781 ((n & ((1 << (PAGE_SHIFT - 9)) - 1)) << SECTOR_SHIFT); 782 out_put_page: 783 put_page(page); 784 out: 785 p->v = NULL; 786 return NULL; 787 } 788