Mirrors/u-boot
2
0
Fork 0
mirror of https://github.com/AsahiLinux/u-boot synced 2024-11-14 00:47:26 +00:00
Code Issues Projects Releases Packages Wiki Activity

disk: Drop debug messages in part_efi

Browse source 
This is monstrously verbose when something goes wrong. It should work by
recording the problem and reporting it (once) at the command level. At
present it sometimes outputs hundreds of lines of CRC mismatches.

For now, just silence it all.

  GUID Partition Table Entry Array CRC is wrong: 0xaebfebf2 != 0xc916f712
  find_valid_gpt: *** ERROR: Invalid GPT ***
  find_valid_gpt: ***        Using Backup GPT ***
  GUID Partition Table Entry Array CRC is wrong: 0xaebfebf2 != 0xc916f712
  find_valid_gpt: *** ERROR: Invalid GPT ***
  find_valid_gpt: ***        Using Backup GPT ***
  ...

While we are error, remove the '*** ERROR: ' text as it is already clear
that this is unexpected

Signed-off-by: Simon Glass <sjg@chromium.org>
Suggested-by: Heinrich Schuchardt <xypron.glpk@gmx.de>
This commit is contained in:
Simon Glass 2022-10-20 18:22:40 -06:00 committed by Tom Rini
parent 984639039f
commit 3e62adc497
1 changed files with 72 additions and 78 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

122
disk/part_efi.c
View file

@ -94,7 +94,7 @@ static int validate_gpt_header(gpt_header *gpt_h, lbaint_t lba,
/* Check the GPT header signature */ /* Check the GPT header signature */
if (le64_to_cpu(gpt_h->signature) != GPT_HEADER_SIGNATURE_UBOOT) { if (le64_to_cpu(gpt_h->signature) != GPT_HEADER_SIGNATURE_UBOOT) {
printf("%s signature is wrong: 0x%llX != 0x%llX\n", log_debug("%s signature is wrong: %#llX != %#llX\n",
"GUID Partition Table Header", "GUID Partition Table Header",
le64_to_cpu(gpt_h->signature), le64_to_cpu(gpt_h->signature),
GPT_HEADER_SIGNATURE_UBOOT); GPT_HEADER_SIGNATURE_UBOOT);
@ -111,7 +111,7 @@ static int validate_gpt_header(gpt_header *gpt_h, lbaint_t lba,
memcpy(&gpt_h->header_crc32, &crc32_backup, sizeof(crc32_backup)); memcpy(&gpt_h->header_crc32, &crc32_backup, sizeof(crc32_backup));
if (calc_crc32 != le32_to_cpu(crc32_backup)) { if (calc_crc32 != le32_to_cpu(crc32_backup)) {
printf("%s CRC is wrong: 0x%x != 0x%x\n", log_debug("%s: CRC is wrong: %#x != %#x\n",
"GUID Partition Table Header", "GUID Partition Table Header",
le32_to_cpu(crc32_backup), calc_crc32); le32_to_cpu(crc32_backup), calc_crc32);
return -1; return -1;
@ -121,9 +121,8 @@ static int validate_gpt_header(gpt_header *gpt_h, lbaint_t lba,
* Check that the my_lba entry points to the LBA that contains the GPT * Check that the my_lba entry points to the LBA that contains the GPT
*/ */
if (le64_to_cpu(gpt_h->my_lba) != lba) { if (le64_to_cpu(gpt_h->my_lba) != lba) {
printf("GPT: my_lba incorrect: %llX != " LBAF "\n", log_debug("GPT: my_lba incorrect: %llX != " LBAF "\n",
le64_to_cpu(gpt_h->my_lba), le64_to_cpu(gpt_h->my_lba), lba);
lba);
return -1; return -1;
} }
@ -132,12 +131,12 @@ static int validate_gpt_header(gpt_header *gpt_h, lbaint_t lba,
* within the disk. * within the disk.
*/ */
if (le64_to_cpu(gpt_h->first_usable_lba) > lastlba) { if (le64_to_cpu(gpt_h->first_usable_lba) > lastlba) {
printf("GPT: first_usable_lba incorrect: %llX > " LBAF "\n", log_debug("GPT: first_usable_lba incorrect: %llX > " LBAF "\n",
le64_to_cpu(gpt_h->first_usable_lba), lastlba); le64_to_cpu(gpt_h->first_usable_lba), lastlba);
return -1; return -1;
} }
if (le64_to_cpu(gpt_h->last_usable_lba) > lastlba) { if (le64_to_cpu(gpt_h->last_usable_lba) > lastlba) {
printf("GPT: last_usable_lba incorrect: %llX > " LBAF "\n", log_debug("GPT: last_usable_lba incorrect: %llX > " LBAF "\n",
le64_to_cpu(gpt_h->last_usable_lba), lastlba); le64_to_cpu(gpt_h->last_usable_lba), lastlba);
return -1; return -1;
} }
@ -159,7 +158,7 @@ static int validate_gpt_entries(gpt_header *gpt_h, gpt_entry *gpt_e)
le32_to_cpu(gpt_h->sizeof_partition_entry)); le32_to_cpu(gpt_h->sizeof_partition_entry));
if (calc_crc32 != le32_to_cpu(gpt_h->partition_entry_array_crc32)) { if (calc_crc32 != le32_to_cpu(gpt_h->partition_entry_array_crc32)) {
printf("%s: 0x%x != 0x%x\n", log_debug("%s: %#x != %#x\n",
"GUID Partition Table Entry Array CRC is wrong", "GUID Partition Table Entry Array CRC is wrong",
le32_to_cpu(gpt_h->partition_entry_array_crc32), le32_to_cpu(gpt_h->partition_entry_array_crc32),
calc_crc32); calc_crc32);
@ -274,7 +273,7 @@ int part_get_info_efi(struct blk_desc *dev_desc, int part,
if (part > le32_to_cpu(gpt_head->num_partition_entries) || if (part > le32_to_cpu(gpt_head->num_partition_entries) ||
!is_pte_valid(&gpt_pte[part - 1])) { !is_pte_valid(&gpt_pte[part - 1])) {
log_debug("*** ERROR: Invalid partition number %d ***\n", part); log_debug("Invalid partition number %d\n", part);
free(gpt_pte); free(gpt_pte);
return -EPERM; return -EPERM;
} }
@ -330,14 +329,15 @@ static int set_protective_mbr(struct blk_desc *dev_desc)
/* Setup the Protective MBR */ /* Setup the Protective MBR */
ALLOC_CACHE_ALIGN_BUFFER_PAD(legacy_mbr, p_mbr, 1, dev_desc->blksz); ALLOC_CACHE_ALIGN_BUFFER_PAD(legacy_mbr, p_mbr, 1, dev_desc->blksz);
if (p_mbr == NULL) { if (p_mbr == NULL) {
printf("%s: calloc failed!\n", __func__); log_debug("calloc failed!\n");
return -1; return -ENOMEM;
} }
/* Read MBR to backup boot code if it exists */ /* Read MBR to backup boot code if it exists */
if (blk_dread(dev_desc, 0, 1, p_mbr) != 1) { if (blk_dread(dev_desc, 0, 1, p_mbr) != 1) {
pr_err("** Can't read from device %d **\n", dev_desc->devnum); log_debug("** Can't read from device %d **\n",
return -1; dev_desc->devnum);
return -EIO;
} }
/* Clear all data in MBR except of backed up boot code */ /* Clear all data in MBR except of backed up boot code */
@ -352,9 +352,8 @@ static int set_protective_mbr(struct blk_desc *dev_desc)
/* Write MBR sector to the MMC device */ /* Write MBR sector to the MMC device */
if (blk_dwrite(dev_desc, 0, 1, p_mbr) != 1) { if (blk_dwrite(dev_desc, 0, 1, p_mbr) != 1) {
printf("** Can't write to device %d **\n", log_debug("** Can't write to device %d **\n", dev_desc->devnum);
dev_desc->devnum); return -EIO;
return -1;
} }
return 0; return 0;
@ -404,8 +403,8 @@ int write_gpt_table(struct blk_desc *dev_desc,
return 0; return 0;
err: err:
printf("** Can't write to device %d **\n", dev_desc->devnum); log_debug("** Can't write to device %d **\n", dev_desc->devnum);
return -1; return -EIO;
} }
int gpt_fill_pte(struct blk_desc *dev_desc, int gpt_fill_pte(struct blk_desc *dev_desc,
@ -451,15 +450,15 @@ int gpt_fill_pte(struct blk_desc *dev_desc,
*/ */
if (((start < hdr_end && hdr_start < (start + size)) || if (((start < hdr_end && hdr_start < (start + size)) ||
(start < pte_end && pte_start < (start + size)))) { (start < pte_end && pte_start < (start + size)))) {
printf("Partition overlap\n"); log_debug("Partition overlap\n");
return -1; return -ENOSPC;
} }
gpt_e[i].starting_lba = cpu_to_le64(start); gpt_e[i].starting_lba = cpu_to_le64(start);
if (offset > (last_usable_lba + 1)) { if (offset > (last_usable_lba + 1)) {
printf("Partitions layout exceds disk size\n"); log_debug("Partitions layout exceeds disk size\n");
return -1; return -E2BIG;
} }
/* partition ending lba */ /* partition ending lba */
if ((i == parts - 1) && (size == 0)) if ((i == parts - 1) && (size == 0))
@ -474,9 +473,9 @@ int gpt_fill_pte(struct blk_desc *dev_desc,
if (strlen(str_type_guid)) { if (strlen(str_type_guid)) {
if (uuid_str_to_bin(str_type_guid, bin_type_guid, if (uuid_str_to_bin(str_type_guid, bin_type_guid,
UUID_STR_FORMAT_GUID)) { UUID_STR_FORMAT_GUID)) {
printf("Partition no. %d: invalid type guid: %s\n", log_debug("Partition no. %d: invalid type guid: %s\n",
i, str_type_guid); i, str_type_guid);
return -1; return -EINVAL;
} }
} else { } else {
/* default partition type GUID */ /* default partition type GUID */
@ -494,9 +493,9 @@ int gpt_fill_pte(struct blk_desc *dev_desc,
bin_uuid = gpt_e[i].unique_partition_guid.b; bin_uuid = gpt_e[i].unique_partition_guid.b;
if (uuid_str_to_bin(str_uuid, bin_uuid, UUID_STR_FORMAT_GUID)) { if (uuid_str_to_bin(str_uuid, bin_uuid, UUID_STR_FORMAT_GUID)) {
printf("Partition no. %d: invalid guid: %s\n", log_debug("Partition no. %d: invalid guid: %s\n",
i, str_uuid); i, str_uuid);
return -1; return -EINVAL;
} }
#endif #endif
@ -608,8 +607,8 @@ int gpt_restore(struct blk_desc *dev_desc, char *str_disk_guid,
size = PAD_TO_BLOCKSIZE(sizeof(gpt_header), dev_desc); size = PAD_TO_BLOCKSIZE(sizeof(gpt_header), dev_desc);
gpt_h = malloc_cache_aligned(size); gpt_h = malloc_cache_aligned(size);
if (gpt_h == NULL) { if (gpt_h == NULL) {
printf("%s: calloc failed!\n", __func__); log_debug("calloc failed!\n");
return -1; return -ENOMEM;
} }
memset(gpt_h, 0, size); memset(gpt_h, 0, size);
@ -617,9 +616,9 @@ int gpt_restore(struct blk_desc *dev_desc, char *str_disk_guid,
dev_desc); dev_desc);
gpt_e = malloc_cache_aligned(size); gpt_e = malloc_cache_aligned(size);
if (gpt_e == NULL) { if (gpt_e == NULL) {
printf("%s: calloc failed!\n", __func__); log_debug("calloc failed!\n");
free(gpt_h); free(gpt_h);
return -1; return -ENOMEM;
} }
memset(gpt_e, 0, size); memset(gpt_e, 0, size);
@ -675,8 +674,7 @@ int gpt_verify_headers(struct blk_desc *dev_desc, gpt_header *gpt_head,
if (is_gpt_valid(dev_desc, if (is_gpt_valid(dev_desc,
GPT_PRIMARY_PARTITION_TABLE_LBA, GPT_PRIMARY_PARTITION_TABLE_LBA,
gpt_head, gpt_pte) != 1) { gpt_head, gpt_pte) != 1) {
printf("%s: *** ERROR: Invalid GPT ***\n", log_debug("Invalid GPT\n");
__func__);
return -1; return -1;
} }
@ -687,15 +685,13 @@ int gpt_verify_headers(struct blk_desc *dev_desc, gpt_header *gpt_head,
* Check that the alternate_lba entry points to the last LBA * Check that the alternate_lba entry points to the last LBA
*/ */
if (le64_to_cpu(gpt_head->alternate_lba) != (dev_desc->lba - 1)) { if (le64_to_cpu(gpt_head->alternate_lba) != (dev_desc->lba - 1)) {
printf("%s: *** ERROR: Misplaced Backup GPT ***\n", log_debug("Misplaced Backup GPT\n");
__func__);
return -1; return -1;
} }
if (is_gpt_valid(dev_desc, (dev_desc->lba - 1), if (is_gpt_valid(dev_desc, (dev_desc->lba - 1),
gpt_head, gpt_pte) != 1) { gpt_head, gpt_pte) != 1) {
printf("%s: *** ERROR: Invalid Backup GPT ***\n", log_debug("Invalid Backup GPT\n");
__func__);
return -1; return -1;
} }
@ -913,8 +909,8 @@ int write_mbr_and_gpt_partitions(struct blk_desc *dev_desc, void *buf)
lba = 0; /* MBR is always at 0 */ lba = 0; /* MBR is always at 0 */
cnt = 1; /* MBR (1 block) */ cnt = 1; /* MBR (1 block) */
if (blk_dwrite(dev_desc, lba, cnt, buf) != cnt) { if (blk_dwrite(dev_desc, lba, cnt, buf) != cnt) {
printf("%s: failed writing '%s' (%d blks at 0x" LBAF ")\n", log_debug("failed writing '%s' (%d blks at 0x" LBAF ")\n",
__func__, "MBR", cnt, lba); "MBR", cnt, lba);
return 1; return 1;
} }
@ -922,16 +918,16 @@ int write_mbr_and_gpt_partitions(struct blk_desc *dev_desc, void *buf)
lba = GPT_PRIMARY_PARTITION_TABLE_LBA; lba = GPT_PRIMARY_PARTITION_TABLE_LBA;
cnt = 1; /* GPT Header (1 block) */ cnt = 1; /* GPT Header (1 block) */
if (blk_dwrite(dev_desc, lba, cnt, gpt_h) != cnt) { if (blk_dwrite(dev_desc, lba, cnt, gpt_h) != cnt) {
printf("%s: failed writing '%s' (%d blks at 0x" LBAF ")\n", log_debug("failed writing '%s' (%d blks at 0x" LBAF ")\n",
__func__, "Primary GPT Header", cnt, lba); "Primary GPT Header", cnt, lba);
return 1; return 1;
} }
lba = le64_to_cpu(gpt_h->partition_entry_lba); lba = le64_to_cpu(gpt_h->partition_entry_lba);
cnt = gpt_e_blk_cnt; cnt = gpt_e_blk_cnt;
if (blk_dwrite(dev_desc, lba, cnt, gpt_e) != cnt) { if (blk_dwrite(dev_desc, lba, cnt, gpt_e) != cnt) {
printf("%s: failed writing '%s' (%d blks at 0x" LBAF ")\n", log_debug("failed writing '%s' (%d blks at 0x" LBAF ")\n",
__func__, "Primary GPT Entries", cnt, lba); "Primary GPT Entries", cnt, lba);
return 1; return 1;
} }
@ -941,16 +937,16 @@ int write_mbr_and_gpt_partitions(struct blk_desc *dev_desc, void *buf)
lba = le64_to_cpu(gpt_h->partition_entry_lba); lba = le64_to_cpu(gpt_h->partition_entry_lba);
cnt = gpt_e_blk_cnt; cnt = gpt_e_blk_cnt;
if (blk_dwrite(dev_desc, lba, cnt, gpt_e) != cnt) { if (blk_dwrite(dev_desc, lba, cnt, gpt_e) != cnt) {
printf("%s: failed writing '%s' (%d blks at 0x" LBAF ")\n", log_debug("failed writing '%s' (%d blks at 0x" LBAF ")\n",
__func__, "Backup GPT Entries", cnt, lba); "Backup GPT Entries", cnt, lba);
return 1; return 1;
} }
lba = le64_to_cpu(gpt_h->my_lba); lba = le64_to_cpu(gpt_h->my_lba);
cnt = 1; /* GPT Header (1 block) */ cnt = 1; /* GPT Header (1 block) */
if (blk_dwrite(dev_desc, lba, cnt, gpt_h) != cnt) { if (blk_dwrite(dev_desc, lba, cnt, gpt_h) != cnt) {
printf("%s: failed writing '%s' (%d blks at 0x" LBAF ")\n", log_debug("failed writing '%s' (%d blks at 0x" LBAF ")\n",
__func__, "Backup GPT Header", cnt, lba); "Backup GPT Header", cnt, lba);
return 1; return 1;
} }
@ -1017,7 +1013,7 @@ static int is_gpt_valid(struct blk_desc *dev_desc, u64 lba,
{ {
/* Confirm valid arguments prior to allocation. */ /* Confirm valid arguments prior to allocation. */
if (!dev_desc || !pgpt_head) { if (!dev_desc || !pgpt_head) {
printf("%s: Invalid Argument(s)\n", __func__); log_debug("Invalid Argument(s)\n");
return 0; return 0;
} }
@ -1025,19 +1021,19 @@ static int is_gpt_valid(struct blk_desc *dev_desc, u64 lba,
/* Read MBR Header from device */ /* Read MBR Header from device */
if (blk_dread(dev_desc, 0, 1, (ulong *)mbr) != 1) { if (blk_dread(dev_desc, 0, 1, (ulong *)mbr) != 1) {
printf("*** ERROR: Can't read MBR header ***\n"); log_debug("Can't read MBR header\n");
return 0; return 0;
} }
/* Read GPT Header from device */ /* Read GPT Header from device */
if (blk_dread(dev_desc, (lbaint_t)lba, 1, pgpt_head) != 1) { if (blk_dread(dev_desc, (lbaint_t)lba, 1, pgpt_head) != 1) {
printf("*** ERROR: Can't read GPT header ***\n"); log_debug("Can't read GPT header\n");
return 0; return 0;
} }
/* Invalid but nothing to yell about. */ /* Invalid but nothing to yell about. */
if (le64_to_cpu(pgpt_head->signature) == GPT_HEADER_CHROMEOS_IGNORE) { if (le64_to_cpu(pgpt_head->signature) == GPT_HEADER_CHROMEOS_IGNORE) {
debug("ChromeOS 'IGNOREME' GPT header found and ignored\n"); log_debug("ChromeOS 'IGNOREME' GPT header found and ignored\n");
return 2; return 2;
} }
@ -1089,17 +1085,15 @@ static int find_valid_gpt(struct blk_desc *dev_desc, gpt_header *gpt_head,
if (r != 1) { if (r != 1) {
if (r != 2) if (r != 2)
printf("%s: *** ERROR: Invalid GPT ***\n", __func__); log_debug("Invalid GPT\n");
if (is_gpt_valid(dev_desc, (dev_desc->lba - 1), gpt_head, if (is_gpt_valid(dev_desc, (dev_desc->lba - 1), gpt_head,
pgpt_pte) != 1) { pgpt_pte) != 1) {
printf("%s: *** ERROR: Invalid Backup GPT ***\n", log_debug("Invalid Backup GPT\n");
__func__);
return 0; return 0;
} }
if (r != 2) if (r != 2)
printf("%s: *** Using Backup GPT ***\n", log_debug(" Using Backup GPT\n");
__func__);
} }
return 1; return 1;
} }
@ -1121,16 +1115,16 @@ static gpt_entry *alloc_read_gpt_entries(struct blk_desc *dev_desc,
gpt_entry *pte = NULL; gpt_entry *pte = NULL;
if (!dev_desc || !pgpt_head) { if (!dev_desc || !pgpt_head) {
printf("%s: Invalid Argument(s)\n", __func__); log_debug("Invalid Argument(s)\n");
return NULL; return NULL;
} }
count = le32_to_cpu(pgpt_head->num_partition_entries) * count = le32_to_cpu(pgpt_head->num_partition_entries) *
le32_to_cpu(pgpt_head->sizeof_partition_entry); le32_to_cpu(pgpt_head->sizeof_partition_entry);
debug("%s: count = %u * %u = %lu\n", __func__, log_debug("count = %u * %u = %lu\n",
(u32) le32_to_cpu(pgpt_head->num_partition_entries), (u32)le32_to_cpu(pgpt_head->num_partition_entries),
(u32) le32_to_cpu(pgpt_head->sizeof_partition_entry), (u32)le32_to_cpu(pgpt_head->sizeof_partition_entry),
(ulong)count); (ulong)count);
/* Allocate memory for PTE, remember to FREE */ /* Allocate memory for PTE, remember to FREE */
@ -1140,8 +1134,8 @@ static gpt_entry *alloc_read_gpt_entries(struct blk_desc *dev_desc,
} }
if (count == 0 || pte == NULL) { if (count == 0 || pte == NULL) {
printf("%s: ERROR: Can't allocate %#lX bytes for GPT Entries\n", log_debug("ERROR: Can't allocate %#lX bytes for GPT Entries\n",
__func__, (ulong)count); (ulong)count);
return NULL; return NULL;
} }
@ -1149,7 +1143,7 @@ static gpt_entry *alloc_read_gpt_entries(struct blk_desc *dev_desc,
blk = le64_to_cpu(pgpt_head->partition_entry_lba); blk = le64_to_cpu(pgpt_head->partition_entry_lba);
blk_cnt = BLOCK_CNT(count, dev_desc); blk_cnt = BLOCK_CNT(count, dev_desc);
if (blk_dread(dev_desc, blk, (lbaint_t)blk_cnt, pte) != blk_cnt) { if (blk_dread(dev_desc, blk, (lbaint_t)blk_cnt, pte) != blk_cnt) {
printf("*** ERROR: Can't read GPT Entries ***\n"); log_debug("Can't read GPT Entries\n");
free(pte); free(pte);
return NULL; return NULL;
} }
@ -1167,7 +1161,7 @@ static int is_pte_valid(gpt_entry * pte)
efi_guid_t unused_guid; efi_guid_t unused_guid;
if (!pte) { if (!pte) {
printf("%s: Invalid Argument(s)\n", __func__); log_debug("Invalid Argument(s)\n");
return 0; return 0;
} }
@ -1179,7 +1173,7 @@ static int is_pte_valid(gpt_entry * pte)
if (memcmp(pte->partition_type_guid.b, unused_guid.b, if (memcmp(pte->partition_type_guid.b, unused_guid.b,
sizeof(unused_guid.b)) == 0) { sizeof(unused_guid.b)) == 0) {
debug("%s: Found an unused PTE GUID at 0x%08X\n", __func__, log_debug("Found an unused PTE GUID at 0x%08X\n",
(unsigned int)(uintptr_t)pte); (unsigned int)(uintptr_t)pte);
return 0; return 0;