part_efi.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428
  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. #if defined(CONFIG_CMD_IDE) || \
  38. defined(CONFIG_CMD_MG_DISK) || \
  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. /*
  91. * Public Functions (include/part.h)
  92. */
  93. void print_part_efi(block_dev_desc_t * dev_desc)
  94. {
  95. gpt_header gpt_head;
  96. gpt_entry **pgpt_pte = NULL;
  97. int i = 0;
  98. if (!dev_desc) {
  99. printf("%s: Invalid Argument(s)\n", __FUNCTION__);
  100. return;
  101. }
  102. /* This function validates AND fills in the GPT header and PTE */
  103. if (is_gpt_valid(dev_desc, GPT_PRIMARY_PARTITION_TABLE_LBA,
  104. &(gpt_head), pgpt_pte) != 1) {
  105. printf("%s: *** ERROR: Invalid GPT ***\n", __FUNCTION__);
  106. return;
  107. }
  108. debug("%s: gpt-entry at 0x%08X\n", __FUNCTION__, (unsigned int)*pgpt_pte);
  109. printf("Part Start LBA End LBA\n");
  110. for (i = 0; i < le32_to_int(gpt_head.num_partition_entries); i++) {
  111. if (is_pte_valid(&(*pgpt_pte)[i])) {
  112. printf("%s%d 0x%llX 0x%llX\n", GPT_ENTRY_NAME,
  113. (i + 1),
  114. le64_to_int((*pgpt_pte)[i].starting_lba),
  115. le64_to_int((*pgpt_pte)[i].ending_lba));
  116. } else {
  117. break; /* Stop at the first non valid PTE */
  118. }
  119. }
  120. /* Remember to free pte */
  121. if (*pgpt_pte != NULL) {
  122. debug("%s: Freeing pgpt_pte\n", __FUNCTION__);
  123. free(*pgpt_pte);
  124. }
  125. return;
  126. }
  127. int get_partition_info_efi(block_dev_desc_t * dev_desc, int part,
  128. disk_partition_t * info)
  129. {
  130. gpt_header gpt_head;
  131. gpt_entry **pgpt_pte = NULL;
  132. /* "part" argument must be at least 1 */
  133. if (!dev_desc || !info || part < 1) {
  134. printf("%s: Invalid Argument(s)\n", __FUNCTION__);
  135. return -1;
  136. }
  137. /* This function validates AND fills in the GPT header and PTE */
  138. if (is_gpt_valid(dev_desc, GPT_PRIMARY_PARTITION_TABLE_LBA,
  139. &(gpt_head), pgpt_pte) != 1) {
  140. printf("%s: *** ERROR: Invalid GPT ***\n", __FUNCTION__);
  141. return -1;
  142. }
  143. /* The ulong casting limits the maximum disk size to 2 TB */
  144. info->start = (ulong) le64_to_int((*pgpt_pte)[part - 1].starting_lba);
  145. /* The ending LBA is inclusive, to calculate size, add 1 to it */
  146. info->size = ((ulong)le64_to_int((*pgpt_pte)[part - 1].ending_lba) + 1)
  147. - info->start;
  148. info->blksz = GPT_BLOCK_SIZE;
  149. sprintf((char *)info->name, "%s%d", GPT_ENTRY_NAME, part);
  150. sprintf((char *)info->type, "U-Boot");
  151. debug("%s: start 0x%lX, size 0x%lX, name %s", __FUNCTION__,
  152. info->start, info->size, info->name);
  153. /* Remember to free pte */
  154. if (*pgpt_pte != NULL) {
  155. debug("%s: Freeing pgpt_pte\n", __FUNCTION__);
  156. free(*pgpt_pte);
  157. }
  158. return 0;
  159. }
  160. int test_part_efi(block_dev_desc_t * dev_desc)
  161. {
  162. legacy_mbr legacymbr;
  163. /* Read legacy MBR from block 0 and validate it */
  164. if ((dev_desc->block_read(dev_desc->dev, 0, 1, (ulong *) & legacymbr) != 1)
  165. || (is_pmbr_valid(&legacymbr) != 1)) {
  166. return -1;
  167. }
  168. return 0;
  169. }
  170. /*
  171. * Private functions
  172. */
  173. /*
  174. * pmbr_part_valid(): Check for EFI partition signature
  175. *
  176. * Returns: 1 if EFI GPT partition type is found.
  177. */
  178. static int pmbr_part_valid(struct partition *part)
  179. {
  180. if (part->sys_ind == EFI_PMBR_OSTYPE_EFI_GPT &&
  181. le32_to_int(part->start_sect) == 1UL) {
  182. return 1;
  183. }
  184. return 0;
  185. }
  186. /*
  187. * is_pmbr_valid(): test Protective MBR for validity
  188. *
  189. * Returns: 1 if PMBR is valid, 0 otherwise.
  190. * Validity depends on two things:
  191. * 1) MSDOS signature is in the last two bytes of the MBR
  192. * 2) One partition of type 0xEE is found, checked by pmbr_part_valid()
  193. */
  194. static int is_pmbr_valid(legacy_mbr * mbr)
  195. {
  196. int i = 0;
  197. if (!mbr || le16_to_int(mbr->signature) != MSDOS_MBR_SIGNATURE) {
  198. return 0;
  199. }
  200. for (i = 0; i < 4; i++) {
  201. if (pmbr_part_valid(&mbr->partition_record[i])) {
  202. return 1;
  203. }
  204. }
  205. return 0;
  206. }
  207. /**
  208. * is_gpt_valid() - tests one GPT header and PTEs for validity
  209. *
  210. * lba is the logical block address of the GPT header to test
  211. * gpt is a GPT header ptr, filled on return.
  212. * ptes is a PTEs ptr, filled on return.
  213. *
  214. * Description: returns 1 if valid, 0 on error.
  215. * If valid, returns pointers to PTEs.
  216. */
  217. static int is_gpt_valid(block_dev_desc_t * dev_desc, unsigned long long lba,
  218. gpt_header * pgpt_head, gpt_entry ** pgpt_pte)
  219. {
  220. unsigned char crc32_backup[4] = { 0 };
  221. unsigned long calc_crc32;
  222. unsigned long long lastlba;
  223. if (!dev_desc || !pgpt_head) {
  224. printf("%s: Invalid Argument(s)\n", __FUNCTION__);
  225. return 0;
  226. }
  227. /* Read GPT Header from device */
  228. if (dev_desc->block_read(dev_desc->dev, lba, 1, pgpt_head) != 1) {
  229. printf("*** ERROR: Can't read GPT header ***\n");
  230. return 0;
  231. }
  232. /* Check the GPT header signature */
  233. if (le64_to_int(pgpt_head->signature) != GPT_HEADER_SIGNATURE) {
  234. printf("GUID Partition Table Header signature is wrong:"
  235. "0x%llX != 0x%llX\n",
  236. (unsigned long long)le64_to_int(pgpt_head->signature),
  237. (unsigned long long)GPT_HEADER_SIGNATURE);
  238. return 0;
  239. }
  240. /* Check the GUID Partition Table CRC */
  241. memcpy(crc32_backup, pgpt_head->header_crc32, sizeof(crc32_backup));
  242. memset(pgpt_head->header_crc32, 0, sizeof(pgpt_head->header_crc32));
  243. calc_crc32 = efi_crc32((const unsigned char *)pgpt_head,
  244. le32_to_int(pgpt_head->header_size));
  245. memcpy(pgpt_head->header_crc32, crc32_backup, sizeof(crc32_backup));
  246. if (calc_crc32 != le32_to_int(crc32_backup)) {
  247. printf("GUID Partition Table Header CRC is wrong:"
  248. "0x%08lX != 0x%08lX\n",
  249. le32_to_int(crc32_backup), calc_crc32);
  250. return 0;
  251. }
  252. /* Check that the my_lba entry points to the LBA that contains the GPT */
  253. if (le64_to_int(pgpt_head->my_lba) != lba) {
  254. printf("GPT: my_lba incorrect: %llX != %llX\n",
  255. (unsigned long long)le64_to_int(pgpt_head->my_lba),
  256. (unsigned long long)lba);
  257. return 0;
  258. }
  259. /* Check the first_usable_lba and last_usable_lba are within the disk. */
  260. lastlba = (unsigned long long)dev_desc->lba;
  261. if (le64_to_int(pgpt_head->first_usable_lba) > lastlba) {
  262. printf("GPT: first_usable_lba incorrect: %llX > %llX\n",
  263. le64_to_int(pgpt_head->first_usable_lba), lastlba);
  264. return 0;
  265. }
  266. if (le64_to_int(pgpt_head->last_usable_lba) > lastlba) {
  267. printf("GPT: last_usable_lba incorrect: %llX > %llX\n",
  268. le64_to_int(pgpt_head->last_usable_lba), lastlba);
  269. return 0;
  270. }
  271. debug("GPT: first_usable_lba: %llX last_usable_lba %llX last lba %llX\n",
  272. le64_to_int(pgpt_head->first_usable_lba),
  273. le64_to_int(pgpt_head->last_usable_lba), lastlba);
  274. /* Read and allocate Partition Table Entries */
  275. *pgpt_pte = alloc_read_gpt_entries(dev_desc, pgpt_head);
  276. if (*pgpt_pte == NULL) {
  277. printf("GPT: Failed to allocate memory for PTE\n");
  278. return 0;
  279. }
  280. /* Check the GUID Partition Table Entry Array CRC */
  281. calc_crc32 = efi_crc32((const unsigned char *)*pgpt_pte,
  282. le32_to_int(pgpt_head->num_partition_entries) *
  283. le32_to_int(pgpt_head->sizeof_partition_entry));
  284. if (calc_crc32 != le32_to_int(pgpt_head->partition_entry_array_crc32)) {
  285. printf("GUID Partition Table Entry Array CRC is wrong:"
  286. "0x%08lX != 0x%08lX\n",
  287. le32_to_int(pgpt_head->partition_entry_array_crc32),
  288. calc_crc32);
  289. if (*pgpt_pte != NULL) {
  290. free(*pgpt_pte);
  291. }
  292. return 0;
  293. }
  294. /* We're done, all's well */
  295. return 1;
  296. }
  297. /**
  298. * alloc_read_gpt_entries(): reads partition entries from disk
  299. * @dev_desc
  300. * @gpt - GPT header
  301. *
  302. * Description: Returns ptes on success, NULL on error.
  303. * Allocates space for PTEs based on information found in @gpt.
  304. * Notes: remember to free pte when you're done!
  305. */
  306. static gpt_entry *alloc_read_gpt_entries(block_dev_desc_t * dev_desc,
  307. gpt_header * pgpt_head)
  308. {
  309. size_t count = 0;
  310. gpt_entry *pte = NULL;
  311. if (!dev_desc || !pgpt_head) {
  312. printf("%s: Invalid Argument(s)\n", __FUNCTION__);
  313. return NULL;
  314. }
  315. count = le32_to_int(pgpt_head->num_partition_entries) *
  316. le32_to_int(pgpt_head->sizeof_partition_entry);
  317. debug("%s: count = %lu * %lu = %u\n", __FUNCTION__,
  318. le32_to_int(pgpt_head->num_partition_entries),
  319. le32_to_int(pgpt_head->sizeof_partition_entry), count);
  320. /* Allocate memory for PTE, remember to FREE */
  321. if (count != 0) {
  322. pte = malloc(count);
  323. }
  324. if (count == 0 || pte == NULL) {
  325. printf("%s: ERROR: Can't allocate 0x%X bytes for GPT Entries\n",
  326. __FUNCTION__, count);
  327. return NULL;
  328. }
  329. /* Read GPT Entries from device */
  330. if (dev_desc->block_read (dev_desc->dev,
  331. (unsigned long)le64_to_int(pgpt_head->partition_entry_lba),
  332. (lbaint_t) (count / GPT_BLOCK_SIZE), pte)
  333. != (count / GPT_BLOCK_SIZE)) {
  334. printf("*** ERROR: Can't read GPT Entries ***\n");
  335. free(pte);
  336. return NULL;
  337. }
  338. return pte;
  339. }
  340. /**
  341. * is_pte_valid(): validates a single Partition Table Entry
  342. * @gpt_entry - Pointer to a single Partition Table Entry
  343. *
  344. * Description: returns 1 if valid, 0 on error.
  345. */
  346. static int is_pte_valid(gpt_entry * pte)
  347. {
  348. efi_guid_t unused_guid;
  349. if (!pte) {
  350. printf("%s: Invalid Argument(s)\n", __FUNCTION__);
  351. return 0;
  352. }
  353. /* Only one validation for now:
  354. * The GUID Partition Type != Unused Entry (ALL-ZERO)
  355. */
  356. memset(unused_guid.b, 0, sizeof(unused_guid.b));
  357. if (memcmp(pte->partition_type_guid.b, unused_guid.b,
  358. sizeof(unused_guid.b)) == 0) {
  359. debug("%s: Found an unused PTE GUID at 0x%08X\n", __FUNCTION__,
  360. (unsigned int)pte);
  361. return 0;
  362. } else {
  363. return 1;
  364. }
  365. }
  366. #endif