linux/block/partitions/efi.c
<<
>>
Prefs
   1/************************************************************
   2 * EFI GUID Partition Table handling
   3 *
   4 * http://www.uefi.org/specs/
   5 * http://www.intel.com/technology/efi/
   6 *
   7 * efi.[ch] by Matt Domsch <Matt_Domsch@dell.com>
   8 *   Copyright 2000,2001,2002,2004 Dell Inc.
   9 *
  10 *  This program is free software; you can redistribute it and/or modify
  11 *  it under the terms of the GNU General Public License as published by
  12 *  the Free Software Foundation; either version 2 of the License, or
  13 *  (at your option) any later version.
  14 *
  15 *  This program is distributed in the hope that it will be useful,
  16 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 *  GNU General Public License for more details.
  19 *
  20 *  You should have received a copy of the GNU General Public License
  21 *  along with this program; if not, write to the Free Software
  22 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  23 *
  24 *
  25 * TODO:
  26 *
  27 * Changelog:
  28 * Mon Nov 09 2004 Matt Domsch <Matt_Domsch@dell.com>
  29 * - test for valid PMBR and valid PGPT before ever reading
  30 *   AGPT, allow override with 'gpt' kernel command line option.
  31 * - check for first/last_usable_lba outside of size of disk
  32 *
  33 * Tue  Mar 26 2002 Matt Domsch <Matt_Domsch@dell.com>
  34 * - Ported to 2.5.7-pre1 and 2.5.7-dj2
  35 * - Applied patch to avoid fault in alternate header handling
  36 * - cleaned up find_valid_gpt
  37 * - On-disk structure and copy in memory is *always* LE now - 
  38 *   swab fields as needed
  39 * - remove print_gpt_header()
  40 * - only use first max_p partition entries, to keep the kernel minor number
  41 *   and partition numbers tied.
  42 *
  43 * Mon  Feb 04 2002 Matt Domsch <Matt_Domsch@dell.com>
  44 * - Removed __PRIPTR_PREFIX - not being used
  45 *
  46 * Mon  Jan 14 2002 Matt Domsch <Matt_Domsch@dell.com>
  47 * - Ported to 2.5.2-pre11 + library crc32 patch Linus applied
  48 *
  49 * Thu Dec 6 2001 Matt Domsch <Matt_Domsch@dell.com>
  50 * - Added compare_gpts().
  51 * - moved le_efi_guid_to_cpus() back into this file.  GPT is the only
  52 *   thing that keeps EFI GUIDs on disk.
  53 * - Changed gpt structure names and members to be simpler and more Linux-like.
  54 * 
  55 * Wed Oct 17 2001 Matt Domsch <Matt_Domsch@dell.com>
  56 * - Removed CONFIG_DEVFS_VOLUMES_UUID code entirely per Martin Wilck
  57 *
  58 * Wed Oct 10 2001 Matt Domsch <Matt_Domsch@dell.com>
  59 * - Changed function comments to DocBook style per Andreas Dilger suggestion.
  60 *
  61 * Mon Oct 08 2001 Matt Domsch <Matt_Domsch@dell.com>
  62 * - Change read_lba() to use the page cache per Al Viro's work.
  63 * - print u64s properly on all architectures
  64 * - fixed debug_printk(), now Dprintk()
  65 *
  66 * Mon Oct 01 2001 Matt Domsch <Matt_Domsch@dell.com>
  67 * - Style cleanups
  68 * - made most functions static
  69 * - Endianness addition
  70 * - remove test for second alternate header, as it's not per spec,
  71 *   and is unnecessary.  There's now a method to read/write the last
  72 *   sector of an odd-sized disk from user space.  No tools have ever
  73 *   been released which used this code, so it's effectively dead.
  74 * - Per Asit Mallick of Intel, added a test for a valid PMBR.
  75 * - Added kernel command line option 'gpt' to override valid PMBR test.
  76 *
  77 * Wed Jun  6 2001 Martin Wilck <Martin.Wilck@Fujitsu-Siemens.com>
  78 * - added devfs volume UUID support (/dev/volumes/uuids) for
  79 *   mounting file systems by the partition GUID. 
  80 *
  81 * Tue Dec  5 2000 Matt Domsch <Matt_Domsch@dell.com>
  82 * - Moved crc32() to linux/lib, added efi_crc32().
  83 *
  84 * Thu Nov 30 2000 Matt Domsch <Matt_Domsch@dell.com>
  85 * - Replaced Intel's CRC32 function with an equivalent
  86 *   non-license-restricted version.
  87 *
  88 * Wed Oct 25 2000 Matt Domsch <Matt_Domsch@dell.com>
  89 * - Fixed the last_lba() call to return the proper last block
  90 *
  91 * Thu Oct 12 2000 Matt Domsch <Matt_Domsch@dell.com>
  92 * - Thanks to Andries Brouwer for his debugging assistance.
  93 * - Code works, detects all the partitions.
  94 *
  95 ************************************************************/
  96#include <linux/crc32.h>
  97#include <linux/ctype.h>
  98#include <linux/math64.h>
  99#include <linux/slab.h>
 100#include "check.h"
 101#include "efi.h"
 102
 103/* This allows a kernel command line option 'gpt' to override
 104 * the test for invalid PMBR.  Not __initdata because reloading
 105 * the partition tables happens after init too.
 106 */
 107static int force_gpt;
 108static int __init
 109force_gpt_fn(char *str)
 110{
 111        force_gpt = 1;
 112        return 1;
 113}
 114__setup("gpt", force_gpt_fn);
 115
 116
 117/**
 118 * efi_crc32() - EFI version of crc32 function
 119 * @buf: buffer to calculate crc32 of
 120 * @len - length of buf
 121 *
 122 * Description: Returns EFI-style CRC32 value for @buf
 123 * 
 124 * This function uses the little endian Ethernet polynomial
 125 * but seeds the function with ~0, and xor's with ~0 at the end.
 126 * Note, the EFI Specification, v1.02, has a reference to
 127 * Dr. Dobbs Journal, May 1994 (actually it's in May 1992).
 128 */
 129static inline u32
 130efi_crc32(const void *buf, unsigned long len)
 131{
 132        return (crc32(~0L, buf, len) ^ ~0L);
 133}
 134
 135/**
 136 * last_lba(): return number of last logical block of device
 137 * @bdev: block device
 138 * 
 139 * Description: Returns last LBA value on success, 0 on error.
 140 * This is stored (by sd and ide-geometry) in
 141 *  the part[0] entry for this disk, and is the number of
 142 *  physical sectors available on the disk.
 143 */
 144static u64 last_lba(struct block_device *bdev)
 145{
 146        if (!bdev || !bdev->bd_inode)
 147                return 0;
 148        return div_u64(bdev->bd_inode->i_size,
 149                       bdev_logical_block_size(bdev)) - 1ULL;
 150}
 151
 152static inline int
 153pmbr_part_valid(struct partition *part)
 154{
 155        if (part->sys_ind == EFI_PMBR_OSTYPE_EFI_GPT &&
 156            le32_to_cpu(part->start_sect) == 1UL)
 157                return 1;
 158        return 0;
 159}
 160
 161/**
 162 * is_pmbr_valid(): test Protective MBR for validity
 163 * @mbr: pointer to a legacy mbr structure
 164 *
 165 * Description: Returns 1 if PMBR is valid, 0 otherwise.
 166 * Validity depends on two things:
 167 *  1) MSDOS signature is in the last two bytes of the MBR
 168 *  2) One partition of type 0xEE is found
 169 */
 170static int
 171is_pmbr_valid(legacy_mbr *mbr)
 172{
 173        int i;
 174        if (!mbr || le16_to_cpu(mbr->signature) != MSDOS_MBR_SIGNATURE)
 175                return 0;
 176        for (i = 0; i < 4; i++)
 177                if (pmbr_part_valid(&mbr->partition_record[i]))
 178                        return 1;
 179        return 0;
 180}
 181
 182/**
 183 * read_lba(): Read bytes from disk, starting at given LBA
 184 * @state
 185 * @lba
 186 * @buffer
 187 * @size_t
 188 *
 189 * Description: Reads @count bytes from @state->bdev into @buffer.
 190 * Returns number of bytes read on success, 0 on error.
 191 */
 192static size_t read_lba(struct parsed_partitions *state,
 193                       u64 lba, u8 *buffer, size_t count)
 194{
 195        size_t totalreadcount = 0;
 196        struct block_device *bdev = state->bdev;
 197        sector_t n = lba * (bdev_logical_block_size(bdev) / 512);
 198
 199        if (!buffer || lba > last_lba(bdev))
 200                return 0;
 201
 202        while (count) {
 203                int copied = 512;
 204                Sector sect;
 205                unsigned char *data = read_part_sector(state, n++, &sect);
 206                if (!data)
 207                        break;
 208                if (copied > count)
 209                        copied = count;
 210                memcpy(buffer, data, copied);
 211                put_dev_sector(sect);
 212                buffer += copied;
 213                totalreadcount +=copied;
 214                count -= copied;
 215        }
 216        return totalreadcount;
 217}
 218
 219/**
 220 * alloc_read_gpt_entries(): reads partition entries from disk
 221 * @state
 222 * @gpt - GPT header
 223 * 
 224 * Description: Returns ptes on success,  NULL on error.
 225 * Allocates space for PTEs based on information found in @gpt.
 226 * Notes: remember to free pte when you're done!
 227 */
 228static gpt_entry *alloc_read_gpt_entries(struct parsed_partitions *state,
 229                                         gpt_header *gpt)
 230{
 231        size_t count;
 232        gpt_entry *pte;
 233
 234        if (!gpt)
 235                return NULL;
 236
 237        count = le32_to_cpu(gpt->num_partition_entries) *
 238                le32_to_cpu(gpt->sizeof_partition_entry);
 239        if (!count)
 240                return NULL;
 241        pte = kzalloc(count, GFP_KERNEL);
 242        if (!pte)
 243                return NULL;
 244
 245        if (read_lba(state, le64_to_cpu(gpt->partition_entry_lba),
 246                     (u8 *) pte,
 247                     count) < count) {
 248                kfree(pte);
 249                pte=NULL;
 250                return NULL;
 251        }
 252        return pte;
 253}
 254
 255/**
 256 * alloc_read_gpt_header(): Allocates GPT header, reads into it from disk
 257 * @state
 258 * @lba is the Logical Block Address of the partition table
 259 * 
 260 * Description: returns GPT header on success, NULL on error.   Allocates
 261 * and fills a GPT header starting at @ from @state->bdev.
 262 * Note: remember to free gpt when finished with it.
 263 */
 264static gpt_header *alloc_read_gpt_header(struct parsed_partitions *state,
 265                                         u64 lba)
 266{
 267        gpt_header *gpt;
 268        unsigned ssz = bdev_logical_block_size(state->bdev);
 269
 270        gpt = kzalloc(ssz, GFP_KERNEL);
 271        if (!gpt)
 272                return NULL;
 273
 274        if (read_lba(state, lba, (u8 *) gpt, ssz) < ssz) {
 275                kfree(gpt);
 276                gpt=NULL;
 277                return NULL;
 278        }
 279
 280        return gpt;
 281}
 282
 283/**
 284 * is_gpt_valid() - tests one GPT header and PTEs for validity
 285 * @state
 286 * @lba is the logical block address of the GPT header to test
 287 * @gpt is a GPT header ptr, filled on return.
 288 * @ptes is a PTEs ptr, filled on return.
 289 *
 290 * Description: returns 1 if valid,  0 on error.
 291 * If valid, returns pointers to newly allocated GPT header and PTEs.
 292 */
 293static int is_gpt_valid(struct parsed_partitions *state, u64 lba,
 294                        gpt_header **gpt, gpt_entry **ptes)
 295{
 296        u32 crc, origcrc;
 297        u64 lastlba;
 298
 299        if (!ptes)
 300                return 0;
 301        if (!(*gpt = alloc_read_gpt_header(state, lba)))
 302                return 0;
 303
 304        /* Check the GUID Partition Table signature */
 305        if (le64_to_cpu((*gpt)->signature) != GPT_HEADER_SIGNATURE) {
 306                pr_debug("GUID Partition Table Header signature is wrong:"
 307                         "%lld != %lld\n",
 308                         (unsigned long long)le64_to_cpu((*gpt)->signature),
 309                         (unsigned long long)GPT_HEADER_SIGNATURE);
 310                goto fail;
 311        }
 312
 313        /* Check the GUID Partition Table header size */
 314        if (le32_to_cpu((*gpt)->header_size) >
 315                        bdev_logical_block_size(state->bdev)) {
 316                pr_debug("GUID Partition Table Header size is wrong: %u > %u\n",
 317                        le32_to_cpu((*gpt)->header_size),
 318                        bdev_logical_block_size(state->bdev));
 319                goto fail;
 320        }
 321
 322        /* Check the GUID Partition Table CRC */
 323        origcrc = le32_to_cpu((*gpt)->header_crc32);
 324        (*gpt)->header_crc32 = 0;
 325        crc = efi_crc32((const unsigned char *) (*gpt), le32_to_cpu((*gpt)->header_size));
 326
 327        if (crc != origcrc) {
 328                pr_debug("GUID Partition Table Header CRC is wrong: %x != %x\n",
 329                         crc, origcrc);
 330                goto fail;
 331        }
 332        (*gpt)->header_crc32 = cpu_to_le32(origcrc);
 333
 334        /* Check that the my_lba entry points to the LBA that contains
 335         * the GUID Partition Table */
 336        if (le64_to_cpu((*gpt)->my_lba) != lba) {
 337                pr_debug("GPT my_lba incorrect: %lld != %lld\n",
 338                         (unsigned long long)le64_to_cpu((*gpt)->my_lba),
 339                         (unsigned long long)lba);
 340                goto fail;
 341        }
 342
 343        /* Check the first_usable_lba and last_usable_lba are
 344         * within the disk.
 345         */
 346        lastlba = last_lba(state->bdev);
 347        if (le64_to_cpu((*gpt)->first_usable_lba) > lastlba) {
 348                pr_debug("GPT: first_usable_lba incorrect: %lld > %lld\n",
 349                         (unsigned long long)le64_to_cpu((*gpt)->first_usable_lba),
 350                         (unsigned long long)lastlba);
 351                goto fail;
 352        }
 353        if (le64_to_cpu((*gpt)->last_usable_lba) > lastlba) {
 354                pr_debug("GPT: last_usable_lba incorrect: %lld > %lld\n",
 355                         (unsigned long long)le64_to_cpu((*gpt)->last_usable_lba),
 356                         (unsigned long long)lastlba);
 357                goto fail;
 358        }
 359
 360        /* Check that sizeof_partition_entry has the correct value */
 361        if (le32_to_cpu((*gpt)->sizeof_partition_entry) != sizeof(gpt_entry)) {
 362                pr_debug("GUID Partitition Entry Size check failed.\n");
 363                goto fail;
 364        }
 365
 366        if (!(*ptes = alloc_read_gpt_entries(state, *gpt)))
 367                goto fail;
 368
 369        /* Check the GUID Partition Entry Array CRC */
 370        crc = efi_crc32((const unsigned char *) (*ptes),
 371                        le32_to_cpu((*gpt)->num_partition_entries) *
 372                        le32_to_cpu((*gpt)->sizeof_partition_entry));
 373
 374        if (crc != le32_to_cpu((*gpt)->partition_entry_array_crc32)) {
 375                pr_debug("GUID Partitition Entry Array CRC check failed.\n");
 376                goto fail_ptes;
 377        }
 378
 379        /* We're done, all's well */
 380        return 1;
 381
 382 fail_ptes:
 383        kfree(*ptes);
 384        *ptes = NULL;
 385 fail:
 386        kfree(*gpt);
 387        *gpt = NULL;
 388        return 0;
 389}
 390
 391/**
 392 * is_pte_valid() - tests one PTE for validity
 393 * @pte is the pte to check
 394 * @lastlba is last lba of the disk
 395 *
 396 * Description: returns 1 if valid,  0 on error.
 397 */
 398static inline int
 399is_pte_valid(const gpt_entry *pte, const u64 lastlba)
 400{
 401        if ((!efi_guidcmp(pte->partition_type_guid, NULL_GUID)) ||
 402            le64_to_cpu(pte->starting_lba) > lastlba         ||
 403            le64_to_cpu(pte->ending_lba)   > lastlba)
 404                return 0;
 405        return 1;
 406}
 407
 408/**
 409 * compare_gpts() - Search disk for valid GPT headers and PTEs
 410 * @pgpt is the primary GPT header
 411 * @agpt is the alternate GPT header
 412 * @lastlba is the last LBA number
 413 * Description: Returns nothing.  Sanity checks pgpt and agpt fields
 414 * and prints warnings on discrepancies.
 415 * 
 416 */
 417static void
 418compare_gpts(gpt_header *pgpt, gpt_header *agpt, u64 lastlba)
 419{
 420        int error_found = 0;
 421        if (!pgpt || !agpt)
 422                return;
 423        if (le64_to_cpu(pgpt->my_lba) != le64_to_cpu(agpt->alternate_lba)) {
 424                printk(KERN_WARNING
 425                       "GPT:Primary header LBA != Alt. header alternate_lba\n");
 426                printk(KERN_WARNING "GPT:%lld != %lld\n",
 427                       (unsigned long long)le64_to_cpu(pgpt->my_lba),
 428                       (unsigned long long)le64_to_cpu(agpt->alternate_lba));
 429                error_found++;
 430        }
 431        if (le64_to_cpu(pgpt->alternate_lba) != le64_to_cpu(agpt->my_lba)) {
 432                printk(KERN_WARNING
 433                       "GPT:Primary header alternate_lba != Alt. header my_lba\n");
 434                printk(KERN_WARNING "GPT:%lld != %lld\n",
 435                       (unsigned long long)le64_to_cpu(pgpt->alternate_lba),
 436                       (unsigned long long)le64_to_cpu(agpt->my_lba));
 437                error_found++;
 438        }
 439        if (le64_to_cpu(pgpt->first_usable_lba) !=
 440            le64_to_cpu(agpt->first_usable_lba)) {
 441                printk(KERN_WARNING "GPT:first_usable_lbas don't match.\n");
 442                printk(KERN_WARNING "GPT:%lld != %lld\n",
 443                       (unsigned long long)le64_to_cpu(pgpt->first_usable_lba),
 444                       (unsigned long long)le64_to_cpu(agpt->first_usable_lba));
 445                error_found++;
 446        }
 447        if (le64_to_cpu(pgpt->last_usable_lba) !=
 448            le64_to_cpu(agpt->last_usable_lba)) {
 449                printk(KERN_WARNING "GPT:last_usable_lbas don't match.\n");
 450                printk(KERN_WARNING "GPT:%lld != %lld\n",
 451                       (unsigned long long)le64_to_cpu(pgpt->last_usable_lba),
 452                       (unsigned long long)le64_to_cpu(agpt->last_usable_lba));
 453                error_found++;
 454        }
 455        if (efi_guidcmp(pgpt->disk_guid, agpt->disk_guid)) {
 456                printk(KERN_WARNING "GPT:disk_guids don't match.\n");
 457                error_found++;
 458        }
 459        if (le32_to_cpu(pgpt->num_partition_entries) !=
 460            le32_to_cpu(agpt->num_partition_entries)) {
 461                printk(KERN_WARNING "GPT:num_partition_entries don't match: "
 462                       "0x%x != 0x%x\n",
 463                       le32_to_cpu(pgpt->num_partition_entries),
 464                       le32_to_cpu(agpt->num_partition_entries));
 465                error_found++;
 466        }
 467        if (le32_to_cpu(pgpt->sizeof_partition_entry) !=
 468            le32_to_cpu(agpt->sizeof_partition_entry)) {
 469                printk(KERN_WARNING
 470                       "GPT:sizeof_partition_entry values don't match: "
 471                       "0x%x != 0x%x\n",
 472                       le32_to_cpu(pgpt->sizeof_partition_entry),
 473                       le32_to_cpu(agpt->sizeof_partition_entry));
 474                error_found++;
 475        }
 476        if (le32_to_cpu(pgpt->partition_entry_array_crc32) !=
 477            le32_to_cpu(agpt->partition_entry_array_crc32)) {
 478                printk(KERN_WARNING
 479                       "GPT:partition_entry_array_crc32 values don't match: "
 480                       "0x%x != 0x%x\n",
 481                       le32_to_cpu(pgpt->partition_entry_array_crc32),
 482                       le32_to_cpu(agpt->partition_entry_array_crc32));
 483                error_found++;
 484        }
 485        if (le64_to_cpu(pgpt->alternate_lba) != lastlba) {
 486                printk(KERN_WARNING
 487                       "GPT:Primary header thinks Alt. header is not at the end of the disk.\n");
 488                printk(KERN_WARNING "GPT:%lld != %lld\n",
 489                        (unsigned long long)le64_to_cpu(pgpt->alternate_lba),
 490                        (unsigned long long)lastlba);
 491                error_found++;
 492        }
 493
 494        if (le64_to_cpu(agpt->my_lba) != lastlba) {
 495                printk(KERN_WARNING
 496                       "GPT:Alternate GPT header not at the end of the disk.\n");
 497                printk(KERN_WARNING "GPT:%lld != %lld\n",
 498                        (unsigned long long)le64_to_cpu(agpt->my_lba),
 499                        (unsigned long long)lastlba);
 500                error_found++;
 501        }
 502
 503        if (error_found)
 504                printk(KERN_WARNING
 505                       "GPT: Use GNU Parted to correct GPT errors.\n");
 506        return;
 507}
 508
 509/**
 510 * find_valid_gpt() - Search disk for valid GPT headers and PTEs
 511 * @state
 512 * @gpt is a GPT header ptr, filled on return.
 513 * @ptes is a PTEs ptr, filled on return.
 514 * Description: Returns 1 if valid, 0 on error.
 515 * If valid, returns pointers to newly allocated GPT header and PTEs.
 516 * Validity depends on PMBR being valid (or being overridden by the
 517 * 'gpt' kernel command line option) and finding either the Primary
 518 * GPT header and PTEs valid, or the Alternate GPT header and PTEs
 519 * valid.  If the Primary GPT header is not valid, the Alternate GPT header
 520 * is not checked unless the 'gpt' kernel command line option is passed.
 521 * This protects against devices which misreport their size, and forces
 522 * the user to decide to use the Alternate GPT.
 523 */
 524static int find_valid_gpt(struct parsed_partitions *state, gpt_header **gpt,
 525                          gpt_entry **ptes)
 526{
 527        int good_pgpt = 0, good_agpt = 0, good_pmbr = 0;
 528        gpt_header *pgpt = NULL, *agpt = NULL;
 529        gpt_entry *pptes = NULL, *aptes = NULL;
 530        legacy_mbr *legacymbr;
 531        u64 lastlba;
 532
 533        if (!ptes)
 534                return 0;
 535
 536        lastlba = last_lba(state->bdev);
 537        if (!force_gpt) {
 538                /* This will be added to the EFI Spec. per Intel after v1.02. */
 539                legacymbr = kzalloc(sizeof (*legacymbr), GFP_KERNEL);
 540                if (legacymbr) {
 541                        read_lba(state, 0, (u8 *) legacymbr,
 542                                 sizeof (*legacymbr));
 543                        good_pmbr = is_pmbr_valid(legacymbr);
 544                        kfree(legacymbr);
 545                }
 546                if (!good_pmbr)
 547                        goto fail;
 548        }
 549
 550        good_pgpt = is_gpt_valid(state, GPT_PRIMARY_PARTITION_TABLE_LBA,
 551                                 &pgpt, &pptes);
 552        if (good_pgpt)
 553                good_agpt = is_gpt_valid(state,
 554                                         le64_to_cpu(pgpt->alternate_lba),
 555                                         &agpt, &aptes);
 556        if (!good_agpt && force_gpt)
 557                good_agpt = is_gpt_valid(state, lastlba, &agpt, &aptes);
 558
 559        /* The obviously unsuccessful case */
 560        if (!good_pgpt && !good_agpt)
 561                goto fail;
 562
 563        compare_gpts(pgpt, agpt, lastlba);
 564
 565        /* The good cases */
 566        if (good_pgpt) {
 567                *gpt  = pgpt;
 568                *ptes = pptes;
 569                kfree(agpt);
 570                kfree(aptes);
 571                if (!good_agpt) {
 572                        printk(KERN_WARNING 
 573                               "Alternate GPT is invalid, "
 574                               "using primary GPT.\n");
 575                }
 576                return 1;
 577        }
 578        else if (good_agpt) {
 579                *gpt  = agpt;
 580                *ptes = aptes;
 581                kfree(pgpt);
 582                kfree(pptes);
 583                printk(KERN_WARNING 
 584                       "Primary GPT is invalid, using alternate GPT.\n");
 585                return 1;
 586        }
 587
 588 fail:
 589        kfree(pgpt);
 590        kfree(agpt);
 591        kfree(pptes);
 592        kfree(aptes);
 593        *gpt = NULL;
 594        *ptes = NULL;
 595        return 0;
 596}
 597
 598/**
 599 * efi_partition(struct parsed_partitions *state)
 600 * @state
 601 *
 602 * Description: called from check.c, if the disk contains GPT
 603 * partitions, sets up partition entries in the kernel.
 604 *
 605 * If the first block on the disk is a legacy MBR,
 606 * it will get handled by msdos_partition().
 607 * If it's a Protective MBR, we'll handle it here.
 608 *
 609 * We do not create a Linux partition for GPT, but
 610 * only for the actual data partitions.
 611 * Returns:
 612 * -1 if unable to read the partition table
 613 *  0 if this isn't our partition table
 614 *  1 if successful
 615 *
 616 */
 617int efi_partition(struct parsed_partitions *state)
 618{
 619        gpt_header *gpt = NULL;
 620        gpt_entry *ptes = NULL;
 621        u32 i;
 622        unsigned ssz = bdev_logical_block_size(state->bdev) / 512;
 623        u8 unparsed_guid[37];
 624
 625        if (!find_valid_gpt(state, &gpt, &ptes) || !gpt || !ptes) {
 626                kfree(gpt);
 627                kfree(ptes);
 628                return 0;
 629        }
 630
 631        pr_debug("GUID Partition Table is valid!  Yea!\n");
 632
 633        for (i = 0; i < le32_to_cpu(gpt->num_partition_entries) && i < state->limit-1; i++) {
 634                struct partition_meta_info *info;
 635                unsigned label_count = 0;
 636                unsigned label_max;
 637                u64 start = le64_to_cpu(ptes[i].starting_lba);
 638                u64 size = le64_to_cpu(ptes[i].ending_lba) -
 639                           le64_to_cpu(ptes[i].starting_lba) + 1ULL;
 640
 641                if (!is_pte_valid(&ptes[i], last_lba(state->bdev)))
 642                        continue;
 643
 644                put_partition(state, i+1, start * ssz, size * ssz);
 645
 646                /* If this is a RAID volume, tell md */
 647                if (!efi_guidcmp(ptes[i].partition_type_guid,
 648                                 PARTITION_LINUX_RAID_GUID))
 649                        state->parts[i + 1].flags = ADDPART_FLAG_RAID;
 650
 651                info = &state->parts[i + 1].info;
 652                /* Instead of doing a manual swap to big endian, reuse the
 653                 * common ASCII hex format as the interim.
 654                 */
 655                efi_guid_unparse(&ptes[i].unique_partition_guid, unparsed_guid);
 656                part_pack_uuid(unparsed_guid, info->uuid);
 657
 658                /* Naively convert UTF16-LE to 7 bits. */
 659                label_max = min(sizeof(info->volname) - 1,
 660                                sizeof(ptes[i].partition_name));
 661                info->volname[label_max] = 0;
 662                while (label_count < label_max) {
 663                        u8 c = ptes[i].partition_name[label_count] & 0xff;
 664                        if (c && !isprint(c))
 665                                c = '!';
 666                        info->volname[label_count] = c;
 667                        label_count++;
 668                }
 669                state->parts[i + 1].has_info = true;
 670        }
 671        kfree(ptes);
 672        kfree(gpt);
 673        strlcat(state->pp_buf, "\n", PAGE_SIZE);
 674        return 1;
 675}
 676
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.