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