Merge tag 'defconfig-5.15' of git://git.kernel.org/pub/scm/linux/kernel/git/soc/soc

[linux-2.6-microblaze.git] / block / partitions / efi.c

diff --git a/block/partitions/efi.c b/block/partitions/efi.c
index e271679..7ca5c4c 100644 (file)
--- a/block/partitions/efi.c
+++ b/block/partitions/efi.c
@@ -124,19 +124,17 @@ efi_crc32(const void *buf, unsigned long len)
 
 /**
  * last_lba(): return number of last logical block of device
- * @bdev: block device
+ * @disk: block device
  * 
  * Description: Returns last LBA value on success, 0 on error.
  * This is stored (by sd and ide-geometry) in
  *  the part[0] entry for this disk, and is the number of
  *  physical sectors available on the disk.
  */
-static u64 last_lba(struct block_device *bdev)
+static u64 last_lba(struct gendisk *disk)
 {
-       if (!bdev || !bdev->bd_inode)
-               return 0;
-       return div_u64(bdev->bd_inode->i_size,
-                      bdev_logical_block_size(bdev)) - 1ULL;
+       return div_u64(disk->part0->bd_inode->i_size,
+                      queue_logical_block_size(disk->queue)) - 1ULL;
 }
 
 static inline int pmbr_part_valid(gpt_mbr_record *part)
@@ -231,17 +229,17 @@ done:
  * @buffer: destination buffer
  * @count: bytes to read
  *
- * Description: Reads @count bytes from @state->bdev into @buffer.
+ * Description: Reads @count bytes from @state->disk into @buffer.
  * Returns number of bytes read on success, 0 on error.
  */
 static size_t read_lba(struct parsed_partitions *state,
                       u64 lba, u8 *buffer, size_t count)
 {
        size_t totalreadcount = 0;
-       struct block_device *bdev = state->bdev;
-       sector_t n = lba * (bdev_logical_block_size(bdev) / 512);
+       sector_t n = lba *
+               (queue_logical_block_size(state->disk->queue) / 512);
 
-       if (!buffer || lba > last_lba(bdev))
+       if (!buffer || lba > last_lba(state->disk))
                 return 0;
 
        while (count) {
@@ -302,14 +300,14 @@ static gpt_entry *alloc_read_gpt_entries(struct parsed_partitions *state,
  * @lba: the Logical Block Address of the partition table
  * 
  * Description: returns GPT header on success, NULL on error.   Allocates
- * and fills a GPT header starting at @ from @state->bdev.
+ * and fills a GPT header starting at @ from @state->disk.
  * Note: remember to free gpt when finished with it.
  */
 static gpt_header *alloc_read_gpt_header(struct parsed_partitions *state,
                                         u64 lba)
 {
        gpt_header *gpt;
-       unsigned ssz = bdev_logical_block_size(state->bdev);
+       unsigned ssz = queue_logical_block_size(state->disk->queue);
 
        gpt = kmalloc(ssz, GFP_KERNEL);
        if (!gpt)
@@ -356,10 +354,10 @@ static int is_gpt_valid(struct parsed_partitions *state, u64 lba,
 
        /* Check the GUID Partition Table header size is too big */
        if (le32_to_cpu((*gpt)->header_size) >
-                       bdev_logical_block_size(state->bdev)) {
+                       queue_logical_block_size(state->disk->queue)) {
                pr_debug("GUID Partition Table Header size is too large: %u > %u\n",
                        le32_to_cpu((*gpt)->header_size),
-                       bdev_logical_block_size(state->bdev));
+                       queue_logical_block_size(state->disk->queue));
                goto fail;
        }
 
@@ -395,7 +393,7 @@ static int is_gpt_valid(struct parsed_partitions *state, u64 lba,
        /* Check the first_usable_lba and last_usable_lba are
         * within the disk.
         */
-       lastlba = last_lba(state->bdev);
+       lastlba = last_lba(state->disk);
        if (le64_to_cpu((*gpt)->first_usable_lba) > lastlba) {
                pr_debug("GPT: first_usable_lba incorrect: %lld > %lld\n",
                         (unsigned long long)le64_to_cpu((*gpt)->first_usable_lba),
@@ -587,13 +585,15 @@ static int find_valid_gpt(struct parsed_partitions *state, gpt_header **gpt,
        gpt_header *pgpt = NULL, *agpt = NULL;
        gpt_entry *pptes = NULL, *aptes = NULL;
        legacy_mbr *legacymbr;
-       sector_t total_sectors = i_size_read(state->bdev->bd_inode) >> 9;
+       struct gendisk *disk = state->disk;
+       const struct block_device_operations *fops = disk->fops;
+       sector_t total_sectors = get_capacity(state->disk);
        u64 lastlba;
 
        if (!ptes)
                return 0;
 
-       lastlba = last_lba(state->bdev);
+       lastlba = last_lba(state->disk);
         if (!force_gpt) {
                /* This will be added to the EFI Spec. per Intel after v1.02. */
                legacymbr = kzalloc(sizeof(*legacymbr), GFP_KERNEL);
@@ -621,6 +621,16 @@ static int find_valid_gpt(struct parsed_partitions *state, gpt_header **gpt,
         if (!good_agpt && force_gpt)
                 good_agpt = is_gpt_valid(state, lastlba, &agpt, &aptes);
 
+       if (!good_agpt && force_gpt && fops->alternative_gpt_sector) {
+               sector_t agpt_sector;
+               int err;
+
+               err = fops->alternative_gpt_sector(disk, &agpt_sector);
+               if (!err)
+                       good_agpt = is_gpt_valid(state, agpt_sector,
+                                                &agpt, &aptes);
+       }
+
         /* The obviously unsuccessful case */
         if (!good_pgpt && !good_agpt)
                 goto fail;
@@ -705,7 +715,7 @@ int efi_partition(struct parsed_partitions *state)
        gpt_header *gpt = NULL;
        gpt_entry *ptes = NULL;
        u32 i;
-       unsigned ssz = bdev_logical_block_size(state->bdev) / 512;
+       unsigned ssz = queue_logical_block_size(state->disk->queue) / 512;
 
        if (!find_valid_gpt(state, &gpt, &ptes) || !gpt || !ptes) {
                kfree(gpt);
@@ -722,7 +732,7 @@ int efi_partition(struct parsed_partitions *state)
                u64 size = le64_to_cpu(ptes[i].ending_lba) -
                           le64_to_cpu(ptes[i].starting_lba) + 1ULL;
 
-               if (!is_pte_valid(&ptes[i], last_lba(state->bdev)))
+               if (!is_pte_valid(&ptes[i], last_lba(state->disk)))
                        continue;
 
                put_partition(state, i+1, start * ssz, size * ssz);