fsp: improve debugging

Author: rizlik

include/x86/common.h

@@ -66,4 +66,5 @@ void cpuid(uint32_t eax_param,
            uint32_t *eax, uint32_t *ebx, uint32_t *ecx, uint32_t *edx);
 int cpuid_is_1gb_page_supported();
 void switch_to_long_mode(uint64_t *entry, uint32_t page_table);
+void x86_log_memory_load(uint32_t start, uint32_t end, const char *name);
 #endif /* COMMON_H */

src/boot_x86_fsp.c

@@ -200,30 +200,34 @@ static int check_memory_ranges()
 static void load_wolfboot(void)
 {
     size_t wolfboot_size, bss_size;
+    uint32_t wolfboot_start;
 
     if (check_memory_ranges() != 0) {
         wolfBoot_printf("wolfboot overlaps with loader data...stop" ENDLINE);
         panic();
     }
 
-    wolfBoot_printf("loading wolfboot at %x..." ENDLINE,
-                    (uint32_t)WOLFBOOT_LOAD_BASE - IMAGE_HEADER_SIZE);
+    wolfboot_start = (uint32_t)WOLFBOOT_LOAD_BASE - IMAGE_HEADER_SIZE;
     wolfboot_size = _wolfboot_flash_end - _wolfboot_flash_start;
-    memcpy((uint8_t*)WOLFBOOT_LOAD_BASE - IMAGE_HEADER_SIZE,
-            _wolfboot_flash_start, wolfboot_size);
+    x86_log_memory_load(wolfboot_start, wolfboot_start + wolfboot_size,
+                        "wolfboot");
+    memcpy((uint8_t*)wolfboot_start,_wolfboot_flash_start, wolfboot_size);
     bss_size = wb_end_bss - wb_start_bss;
+    x86_log_memory_load((uint32_t)(uintptr_t)wb_start_bss,
+                        (uint32_t)(uintptr_t)(wb_start_bss + bss_size),
+                        "wolfboot .bss");
     memset(wb_start_bss, 0, bss_size);
     wolfBoot_printf("load wolfboot end" ENDLINE);
 }
 
 static void load_fsp_s_to_ram(void)
 {
     size_t fsp_s_size;
-    wolfBoot_printf("loading FSP_S at %x..." ENDLINE,
-                    (uint32_t)(FSP_S_LOAD_BASE - IMAGE_HEADER_SIZE));
+    uint32_t fsp_start;
+    fsp_start = FSP_S_LOAD_BASE - IMAGE_HEADER_SIZE;
     fsp_s_size = _end_fsp_s - _fsp_s_hdr;
-    memcpy((uint8_t*)FSP_S_LOAD_BASE - IMAGE_HEADER_SIZE,
-            _fsp_s_hdr, fsp_s_size);
+    x86_log_memory_load(fsp_start, fsp_start + fsp_s_size, "FSPS");
+    memcpy((uint8_t*)fsp_start, _fsp_s_hdr, fsp_s_size);
 }
 
 /*!
@@ -252,8 +256,8 @@ static void jump_into_wolfboot(void)
     uint32_t cr3;
     int ret;
 
-    wolfBoot_printf("building identity map at %x...\r\n",
-                    (uint32_t)params->page_table);
+    x86_log_memory_load((uint32_t)(uintptr_t)params->page_table,params->page_table + x86_paging_get_page_table_size(),
+                        "IdentityPageTablePage");
     ret = x86_paging_build_identity_mapping(MEMORY_4GB,
                                             (uint8_t*)(uintptr_t)params->page_table);
     if (ret != 0) {
@@ -334,11 +338,15 @@ static inline void memory_init_data_bss(void)
 {
     uint32_t *datamem_p;
     uint32_t *dataflash_p;
+    x86_log_memory_load((uint32_t)(uintptr_t)_start_data,
+                         (uint32_t)(uintptr_t)_end_data, "stage1 .data");
     datamem_p = (uint32_t *)_start_data;
     dataflash_p = (uint32_t *)_stored_data;
     while(datamem_p < (uint32_t *)_end_data) {
         *(datamem_p++) = *(dataflash_p++);
     }
+    x86_log_memory_load((uint32_t)(uintptr_t)_start_bss,
+                          (uint32_t)(uintptr_t)_end_bss, "stage1 .bss");
     memset(_start_bss, 0, (_end_bss - _start_bss));
 }
 
@@ -696,6 +704,7 @@ void start(uint32_t stack_base, uint32_t stack_top, uint64_t timestamp,
                     stage2_params->tpm_policy_size);
 #endif
 
+    wolfBoot_printf("TOLUM: 0x%x\r\n", stage2_params->tolum);
     /* change_stack_and_invoke() never returns.
      *
      * Execution here is eventually transferred to memory_ready_entry

src/elf.c

@@ -36,8 +36,6 @@
 #if defined(DEBUG) || defined(ELF_PARSER)
 #if DEBUG_ELF == 0
 #undef DEBUG_ELF
-#else
-#define DEBUG_ELF
 #endif
 #endif
 

src/pci.c

@@ -424,7 +424,7 @@ static int pci_program_bar(uint8_t bus, uint8_t dev, uint8_t fun,
     orig_bar = pci_config_read32(bus, dev, fun, bar_off);
     pci_config_write32(bus, dev, fun, bar_off, 0xffffffff);
     bar_value = pci_config_read32(bus, dev,fun, bar_off);
-    PCI_DEBUG_PRINTF("bar value: 0x%x\r\n", bar_value);
+    PCI_DEBUG_PRINTF("bar value after writing 0xff..ff: 0x%x\r\n", bar_value);
 
     if (bar_value == 0) {
         PCI_DEBUG_PRINTF("PCI enum: %x:%x.%x bar: %d val: %x - skipping\r\n",
@@ -437,13 +437,12 @@ static int pci_program_bar(uint8_t bus, uint8_t dev, uint8_t fun,
         bar_align = bar_value & PCI_ENUM_MM_BAR_MASK;
         is_prefetch = pci_enum_is_prefetch(bar_value);
         if (pci_enum_is_64bit(bar_value)) {
-            PCI_DEBUG_PRINTF("bar is 64bit\r\n");
             orig_bar2 = pci_config_read32(bus, dev, fun, bar_off + 4);
             pci_config_write32(bus, dev, fun, bar_off + 4, 0xffffffff);
             reg = pci_config_read32(bus, dev, fun, bar_off + 4);
             PCI_DEBUG_PRINTF("bar high 32bit: %d\r\n", reg);
             if (reg != 0xffffffff) {
-                PCI_DEBUG_PRINTF("Too big BAR, skipping\r\n");
+                PCI_DEBUG_PRINTF("Device wants too much memory, skipping\r\n");
                 pci_config_write32(bus, dev, fun, bar_off + 4, orig_bar2);
                 goto restore_bar;
             }
@@ -477,8 +476,10 @@ static int pci_program_bar(uint8_t bus, uint8_t dev, uint8_t fun,
 
     /* check max length */
     ret = pci_enum_next_aligned32(*base, &bar_value, align, limit);
-    if (ret != 0)
+    if (ret != 0) {
+        wolfBoot_printf("Not memory space for mapping the PCI device... skipping\r\n");
         goto restore_bar;
+    }
 
     pci_config_write32(bus, dev, fun, bar_off, bar_value);
     if (*is_64bit)

src/update_disk.c

@@ -132,7 +132,7 @@ void RAMFUNCTION wolfBoot_start(void)
     stage2_params = stage2_get_parameters();
     /* load the image just after wolfboot */
     load_address = (uint32_t *)(_end_wb);
-    wolfBoot_printf("Load address %x\r\n", load_address);
+    wolfBoot_printf("Load address 0x%x\r\n", load_address);
     do {
         failures++;
         if (selected)
@@ -161,6 +161,9 @@ void RAMFUNCTION wolfBoot_start(void)
         }
 
         /* Read the image into RAM */
+        x86_log_memory_load((uint32_t)(uintptr_t)load_address,
+                            (uint32_t)(uintptr_t)load_address + img_size,
+                            "ELF");
         wolfBoot_printf("Loading image from disk...");
         load_off = 0;
         do {

src/x86/common.c

@@ -31,6 +31,7 @@
 #ifndef COMMON_H_
 #define COMMON_H_
 
+#include <printf.h>
 #include <stdint.h>
 
 #include <x86/common.h>
@@ -362,4 +363,9 @@ void switch_to_long_mode(uint64_t *entry, uint32_t page_table)
     _entry();
 }
 #endif /* BUILD_LOADER_STAGE1 */
+
+void x86_log_memory_load(uint32_t start, uint32_t end, const char *name)
+{
+    wolfBoot_printf("mem: [ 0x%x, 0x%x ] - %s (0x%x) \n\r", start, end, name, end - start);
+}
 #endif /* COMMON_H_ */

src/x86/mptable.c

@@ -496,6 +496,9 @@ void mptable_setup(void)
     struct mptable *_mp;
 
     _mp = (struct mptable *)MPTABLE_LOAD_BASE;
+    x86_log_memory_load((uint32_t)MPTABLE_LOAD_BASE,
+                        (uint32_t)MPTABLE_LOAD_BASE + sizeof(struct mptable), 
+                        "MPTABLE");
     memcpy(_mp, (void*)&_mptable, sizeof(struct mptable));
     apic_id = mmio_read32(LOCAL_APIC_ID);
     apic_ver = mmio_read32(LOCAL_APIC_VER);