part_efi.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435
  1. /*
  2. * Copyright (C) 2008 RuggedCom, Inc.
  3. * Richard Retanubun <RichardRetanubun@RuggedCom.com>
  4. *
  5. * See file CREDITS for list of people who contributed to this
  6. * project.
  7. *
  8. * This program is free software; you can redistribute it and/or
  9. * modify it under the terms of the GNU General Public License as
  10. * published by the Free Software Foundation; either version 2 of
  11. * the License, or (at your option) any later version.
  12. *
  13. * This program is distributed in the hope that it will be useful,
  14. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16. * GNU General Public License for more details.
  17. *
  18. * You should have received a copy of the GNU General Public License
  19. * along with this program; if not, write to the Free Software
  20. * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  21. * MA 02111-1307 USA
  22. */
  23. /*
  24. * Problems with CONFIG_SYS_64BIT_LBA:
  25. *
  26. * struct disk_partition.start in include/part.h is sized as ulong.
  27. * When CONFIG_SYS_64BIT_LBA is activated, lbaint_t changes from ulong to uint64_t.
  28. * For now, it is cast back to ulong at assignment.
  29. *
  30. * This limits the maximum size of addressable storage to < 2 Terra Bytes
  31. */
  32. #include <common.h>
  33. #include <command.h>
  34. #include <ide.h>
  35. #include <malloc.h>
  36. #include "part_efi.h"
  37. #include <linux/ctype.h>
  38. #if defined(CONFIG_CMD_IDE) || \
  39. defined(CONFIG_CMD_SATA) || \
  40. defined(CONFIG_CMD_SCSI) || \
  41. defined(CONFIG_CMD_USB) || \
  42. defined(CONFIG_MMC) || \
  43. defined(CONFIG_SYSTEMACE)
  44. /* Convert char[2] in little endian format to the host format integer
  45. */
  46. static inline unsigned short le16_to_int(unsigned char *le16)
  47. {
  48. return ((le16[1] << 8) + le16[0]);
  49. }
  50. /* Convert char[4] in little endian format to the host format integer
  51. */
  52. static inline unsigned long le32_to_int(unsigned char *le32)
  53. {
  54. return ((le32[3] << 24) + (le32[2] << 16) + (le32[1] << 8) + le32[0]);
  55. }
  56. /* Convert char[8] in little endian format to the host format integer
  57. */
  58. static inline unsigned long long le64_to_int(unsigned char *le64)
  59. {
  60. return (((unsigned long long)le64[7] << 56) +
  61. ((unsigned long long)le64[6] << 48) +
  62. ((unsigned long long)le64[5] << 40) +
  63. ((unsigned long long)le64[4] << 32) +
  64. ((unsigned long long)le64[3] << 24) +
  65. ((unsigned long long)le64[2] << 16) +
  66. ((unsigned long long)le64[1] << 8) +
  67. (unsigned long long)le64[0]);
  68. }
  69. /**
  70. * efi_crc32() - EFI version of crc32 function
  71. * @buf: buffer to calculate crc32 of
  72. * @len - length of buf
  73. *
  74. * Description: Returns EFI-style CRC32 value for @buf
  75. */
  76. static inline unsigned long efi_crc32(const void *buf, unsigned long len)
  77. {
  78. return crc32(0, buf, len);
  79. }
  80. /*
  81. * Private function prototypes
  82. */
  83. static int pmbr_part_valid(struct partition *part);
  84. static int is_pmbr_valid(legacy_mbr * mbr);
  85. static int is_gpt_valid(block_dev_desc_t * dev_desc, unsigned long long lba,
  86. gpt_header * pgpt_head, gpt_entry ** pgpt_pte);
  87. static gpt_entry *alloc_read_gpt_entries(block_dev_desc_t * dev_desc,
  88. gpt_header * pgpt_head);
  89. static int is_pte_valid(gpt_entry * pte);
  90. static char *print_efiname(gpt_entry *pte)
  91. {
  92. static char name[PARTNAME_SZ + 1];
  93. int i;
  94. for (i = 0; i < PARTNAME_SZ; i++) {
  95. u8 c;
  96. c = pte->partition_name[i] & 0xff;
  97. c = (c && !isprint(c)) ? '.' : c;
  98. name[i] = c;
  99. }
  100. name[PARTNAME_SZ] = 0;
  101. return name;
  102. }
  103. /*
  104. * Public Functions (include/part.h)
  105. */
  106. void print_part_efi(block_dev_desc_t * dev_desc)
  107. {
  108. ALLOC_CACHE_ALIGN_BUFFER(gpt_header, gpt_head, 1);
  109. gpt_entry *gpt_pte = NULL;
  110. int i = 0;
  111. if (!dev_desc) {
  112. printf("%s: Invalid Argument(s)\n", __func__);
  113. return;
  114. }
  115. /* This function validates AND fills in the GPT header and PTE */
  116. if (is_gpt_valid(dev_desc, GPT_PRIMARY_PARTITION_TABLE_LBA,
  117. gpt_head, &gpt_pte) != 1) {
  118. printf("%s: *** ERROR: Invalid GPT ***\n", __func__);
  119. return;
  120. }
  121. debug("%s: gpt-entry at %p\n", __func__, gpt_pte);
  122. printf("Part\tName\t\t\tStart LBA\tEnd LBA\n");
  123. for (i = 0; i < le32_to_int(gpt_head->num_partition_entries); i++) {
  124. if (is_pte_valid(&gpt_pte[i])) {
  125. printf("%3d\t%-18s\t0x%08llX\t0x%08llX\n", (i + 1),
  126. print_efiname(&gpt_pte[i]),
  127. le64_to_int(gpt_pte[i].starting_lba),
  128. le64_to_int(gpt_pte[i].ending_lba));
  129. } else {
  130. break; /* Stop at the first non valid PTE */
  131. }
  132. }
  133. /* Remember to free pte */
  134. free(gpt_pte);
  135. return;
  136. }
  137. int get_partition_info_efi(block_dev_desc_t * dev_desc, int part,
  138. disk_partition_t * info)
  139. {
  140. ALLOC_CACHE_ALIGN_BUFFER(gpt_header, gpt_head, 1);
  141. gpt_entry *gpt_pte = NULL;
  142. /* "part" argument must be at least 1 */
  143. if (!dev_desc || !info || part < 1) {
  144. printf("%s: Invalid Argument(s)\n", __func__);
  145. return -1;
  146. }
  147. /* This function validates AND fills in the GPT header and PTE */
  148. if (is_gpt_valid(dev_desc, GPT_PRIMARY_PARTITION_TABLE_LBA,
  149. gpt_head, &gpt_pte) != 1) {
  150. printf("%s: *** ERROR: Invalid GPT ***\n", __func__);
  151. return -1;
  152. }
  153. /* The ulong casting limits the maximum disk size to 2 TB */
  154. info->start = (ulong) le64_to_int(gpt_pte[part - 1].starting_lba);
  155. /* The ending LBA is inclusive, to calculate size, add 1 to it */
  156. info->size = ((ulong)le64_to_int(gpt_pte[part - 1].ending_lba) + 1)
  157. - info->start;
  158. info->blksz = GPT_BLOCK_SIZE;
  159. sprintf((char *)info->name, "%s",
  160. print_efiname(&gpt_pte[part - 1]));
  161. sprintf((char *)info->type, "U-Boot");
  162. debug("%s: start 0x%lX, size 0x%lX, name %s", __func__,
  163. info->start, info->size, info->name);
  164. /* Remember to free pte */
  165. free(gpt_pte);
  166. return 0;
  167. }
  168. int test_part_efi(block_dev_desc_t * dev_desc)
  169. {
  170. ALLOC_CACHE_ALIGN_BUFFER(legacy_mbr, legacymbr, 1);
  171. /* Read legacy MBR from block 0 and validate it */
  172. if ((dev_desc->block_read(dev_desc->dev, 0, 1, (ulong *)legacymbr) != 1)
  173. || (is_pmbr_valid(legacymbr) != 1)) {
  174. return -1;
  175. }
  176. return 0;
  177. }
  178. /*
  179. * Private functions
  180. */
  181. /*
  182. * pmbr_part_valid(): Check for EFI partition signature
  183. *
  184. * Returns: 1 if EFI GPT partition type is found.
  185. */
  186. static int pmbr_part_valid(struct partition *part)
  187. {
  188. if (part->sys_ind == EFI_PMBR_OSTYPE_EFI_GPT &&
  189. le32_to_int(part->start_sect) == 1UL) {
  190. return 1;
  191. }
  192. return 0;
  193. }
  194. /*
  195. * is_pmbr_valid(): test Protective MBR for validity
  196. *
  197. * Returns: 1 if PMBR is valid, 0 otherwise.
  198. * Validity depends on two things:
  199. * 1) MSDOS signature is in the last two bytes of the MBR
  200. * 2) One partition of type 0xEE is found, checked by pmbr_part_valid()
  201. */
  202. static int is_pmbr_valid(legacy_mbr * mbr)
  203. {
  204. int i = 0;
  205. if (!mbr || le16_to_int(mbr->signature) != MSDOS_MBR_SIGNATURE) {
  206. return 0;
  207. }
  208. for (i = 0; i < 4; i++) {
  209. if (pmbr_part_valid(&mbr->partition_record[i])) {
  210. return 1;
  211. }
  212. }
  213. return 0;
  214. }
  215. /**
  216. * is_gpt_valid() - tests one GPT header and PTEs for validity
  217. *
  218. * lba is the logical block address of the GPT header to test
  219. * gpt is a GPT header ptr, filled on return.
  220. * ptes is a PTEs ptr, filled on return.
  221. *
  222. * Description: returns 1 if valid, 0 on error.
  223. * If valid, returns pointers to PTEs.
  224. */
  225. static int is_gpt_valid(block_dev_desc_t * dev_desc, unsigned long long lba,
  226. gpt_header * pgpt_head, gpt_entry ** pgpt_pte)
  227. {
  228. unsigned char crc32_backup[4] = { 0 };
  229. unsigned long calc_crc32;
  230. unsigned long long lastlba;
  231. if (!dev_desc || !pgpt_head) {
  232. printf("%s: Invalid Argument(s)\n", __func__);
  233. return 0;
  234. }
  235. /* Read GPT Header from device */
  236. if (dev_desc->block_read(dev_desc->dev, lba, 1, pgpt_head) != 1) {
  237. printf("*** ERROR: Can't read GPT header ***\n");
  238. return 0;
  239. }
  240. /* Check the GPT header signature */
  241. if (le64_to_int(pgpt_head->signature) != GPT_HEADER_SIGNATURE) {
  242. printf("GUID Partition Table Header signature is wrong:"
  243. "0x%llX != 0x%llX\n",
  244. (unsigned long long)le64_to_int(pgpt_head->signature),
  245. (unsigned long long)GPT_HEADER_SIGNATURE);
  246. return 0;
  247. }
  248. /* Check the GUID Partition Table CRC */
  249. memcpy(crc32_backup, pgpt_head->header_crc32, sizeof(crc32_backup));
  250. memset(pgpt_head->header_crc32, 0, sizeof(pgpt_head->header_crc32));
  251. calc_crc32 = efi_crc32((const unsigned char *)pgpt_head,
  252. le32_to_int(pgpt_head->header_size));
  253. memcpy(pgpt_head->header_crc32, crc32_backup, sizeof(crc32_backup));
  254. if (calc_crc32 != le32_to_int(crc32_backup)) {
  255. printf("GUID Partition Table Header CRC is wrong:"
  256. "0x%08lX != 0x%08lX\n",
  257. le32_to_int(crc32_backup), calc_crc32);
  258. return 0;
  259. }
  260. /* Check that the my_lba entry points to the LBA that contains the GPT */
  261. if (le64_to_int(pgpt_head->my_lba) != lba) {
  262. printf("GPT: my_lba incorrect: %llX != %llX\n",
  263. (unsigned long long)le64_to_int(pgpt_head->my_lba),
  264. (unsigned long long)lba);
  265. return 0;
  266. }
  267. /* Check the first_usable_lba and last_usable_lba are within the disk. */
  268. lastlba = (unsigned long long)dev_desc->lba;
  269. if (le64_to_int(pgpt_head->first_usable_lba) > lastlba) {
  270. printf("GPT: first_usable_lba incorrect: %llX > %llX\n",
  271. le64_to_int(pgpt_head->first_usable_lba), lastlba);
  272. return 0;
  273. }
  274. if (le64_to_int(pgpt_head->last_usable_lba) > lastlba) {
  275. printf("GPT: last_usable_lba incorrect: %llX > %llX\n",
  276. le64_to_int(pgpt_head->last_usable_lba), lastlba);
  277. return 0;
  278. }
  279. debug("GPT: first_usable_lba: %llX last_usable_lba %llX last lba %llX\n",
  280. le64_to_int(pgpt_head->first_usable_lba),
  281. le64_to_int(pgpt_head->last_usable_lba), lastlba);
  282. /* Read and allocate Partition Table Entries */
  283. *pgpt_pte = alloc_read_gpt_entries(dev_desc, pgpt_head);
  284. if (*pgpt_pte == NULL) {
  285. printf("GPT: Failed to allocate memory for PTE\n");
  286. return 0;
  287. }
  288. /* Check the GUID Partition Table Entry Array CRC */
  289. calc_crc32 = efi_crc32((const unsigned char *)*pgpt_pte,
  290. le32_to_int(pgpt_head->num_partition_entries) *
  291. le32_to_int(pgpt_head->sizeof_partition_entry));
  292. if (calc_crc32 != le32_to_int(pgpt_head->partition_entry_array_crc32)) {
  293. printf("GUID Partition Table Entry Array CRC is wrong:"
  294. "0x%08lX != 0x%08lX\n",
  295. le32_to_int(pgpt_head->partition_entry_array_crc32),
  296. calc_crc32);
  297. free(*pgpt_pte);
  298. return 0;
  299. }
  300. /* We're done, all's well */
  301. return 1;
  302. }
  303. /**
  304. * alloc_read_gpt_entries(): reads partition entries from disk
  305. * @dev_desc
  306. * @gpt - GPT header
  307. *
  308. * Description: Returns ptes on success, NULL on error.
  309. * Allocates space for PTEs based on information found in @gpt.
  310. * Notes: remember to free pte when you're done!
  311. */
  312. static gpt_entry *alloc_read_gpt_entries(block_dev_desc_t * dev_desc,
  313. gpt_header * pgpt_head)
  314. {
  315. size_t count = 0;
  316. gpt_entry *pte = NULL;
  317. if (!dev_desc || !pgpt_head) {
  318. printf("%s: Invalid Argument(s)\n", __func__);
  319. return NULL;
  320. }
  321. count = le32_to_int(pgpt_head->num_partition_entries) *
  322. le32_to_int(pgpt_head->sizeof_partition_entry);
  323. debug("%s: count = %lu * %lu = %u\n", __func__,
  324. le32_to_int(pgpt_head->num_partition_entries),
  325. le32_to_int(pgpt_head->sizeof_partition_entry), count);
  326. /* Allocate memory for PTE, remember to FREE */
  327. if (count != 0) {
  328. pte = memalign(ARCH_DMA_MINALIGN, count);
  329. }
  330. if (count == 0 || pte == NULL) {
  331. printf("%s: ERROR: Can't allocate 0x%X bytes for GPT Entries\n",
  332. __func__, count);
  333. return NULL;
  334. }
  335. /* Read GPT Entries from device */
  336. if (dev_desc->block_read (dev_desc->dev,
  337. (unsigned long)le64_to_int(pgpt_head->partition_entry_lba),
  338. (lbaint_t) (count / GPT_BLOCK_SIZE), pte)
  339. != (count / GPT_BLOCK_SIZE)) {
  340. printf("*** ERROR: Can't read GPT Entries ***\n");
  341. free(pte);
  342. return NULL;
  343. }
  344. return pte;
  345. }
  346. /**
  347. * is_pte_valid(): validates a single Partition Table Entry
  348. * @gpt_entry - Pointer to a single Partition Table Entry
  349. *
  350. * Description: returns 1 if valid, 0 on error.
  351. */
  352. static int is_pte_valid(gpt_entry * pte)
  353. {
  354. efi_guid_t unused_guid;
  355. if (!pte) {
  356. printf("%s: Invalid Argument(s)\n", __func__);
  357. return 0;
  358. }
  359. /* Only one validation for now:
  360. * The GUID Partition Type != Unused Entry (ALL-ZERO)
  361. */
  362. memset(unused_guid.b, 0, sizeof(unused_guid.b));
  363. if (memcmp(pte->partition_type_guid.b, unused_guid.b,
  364. sizeof(unused_guid.b)) == 0) {
  365. debug("%s: Found an unused PTE GUID at 0x%08X\n", __func__,
  366. (unsigned int)pte);
  367. return 0;
  368. } else {
  369. return 1;
  370. }
  371. }
  372. #endif