Modify debug framework to be build-independent

During boot, Hostboot will push key pointers into memory.  This
allows the debug tools to find the pointers (using a known static
memory address) to base memory accesses on.  This replaces the
existing symbol lookup that we use now.  That means we don't
need to have the exact symbol file for the build we're debugging
against.

Change-Id: I4618e15a3dc90acc3a89520a502eb818c1b4258c
Reviewed-on: http://ralgit01.raleigh.ibm.com/gerrit1/56097
Tested-by: Jenkins Server <pfd-jenkins+hostboot@us.ibm.com>
Tested-by: Jenkins OP Build CI <op-jenkins+hostboot@us.ibm.com>
Tested-by: Jenkins OP HW <op-hw-jenkins+hostboot@us.ibm.com>
Tested-by: FSP CI Jenkins <fsp-CI-jenkins+hostboot@us.ibm.com>
Reviewed-by: Daniel M. Crowell <dcrowell@us.ibm.com>

7 files changed, 149 insertions, 7 deletions

diff --git a/src/kernel/block.C b/src/kernel/block.C
index ecb11ff0c..b80db2aac 100644
--- a/src/kernel/block.C
+++ b/src/kernel/block.C
@@ -5,7 +5,9 @@
 /*                                                                        */
 /* OpenPOWER HostBoot Project                                             */
 /*                                                                        */
-/* COPYRIGHT International Business Machines Corp. 2011,2014              */
+/* Contributors Listed Below - COPYRIGHT 2011,2018                        */
+/* [+] International Business Machines Corp.                              */
+/*                                                                        */
 /*                                                                        */
 /* Licensed under the Apache License, Version 2.0 (the "License");        */
 /* you may not use this file except in compliance with the License.       */
@@ -42,6 +44,7 @@
 #include <usr/vmmconst.h>
 
 #include <new>
+#include <usr/debugpointers.H>
 
 // Track eviction requests due to aging pages
 uint32_t Block::cv_ro_evict_req = 0;
@@ -708,3 +711,13 @@ void Block::releaseSPTE(ShadowPTE* i_pte)
 
     i_pte->setPageAddr(NULL);
 }
+
+void Block::addDebugPointers()
+{
+    DEBUG::add_debug_pointer(DEBUG::BLOCKREADONLYEVICT,
+                             &cv_ro_evict_req,
+                             sizeof(cv_ro_evict_req));
+    DEBUG::add_debug_pointer(DEBUG::BLOCKREADWRITEEVICT,
+                             &cv_rw_evict_req,
+                             sizeof(cv_rw_evict_req));
+}
diff --git a/src/kernel/heapmgr.C b/src/kernel/heapmgr.C
index b473eb05c..643774f52 100644
--- a/src/kernel/heapmgr.C
+++ b/src/kernel/heapmgr.C
@@ -5,7 +5,7 @@
 /*                                                                        */
 /* OpenPOWER HostBoot Project                                             */
 /*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2010,2017                        */
+/* Contributors Listed Below - COPYRIGHT 2010,2018                        */
 /* [+] International Business Machines Corp.                              */
 /*                                                                        */
 /*                                                                        */
@@ -30,6 +30,7 @@
 #include <kernel/pagemgr.H>
 #include <util/align.H>
 #include <arch/ppc.H>
+#include <usr/debugpointers.H>
 
 #ifdef HOSTBOOT_DEBUG
 #define SMALL_HEAP_PAGES_TRACKED 64
@@ -75,6 +76,11 @@ void HeapManager::init()
     Singleton<HeapManager>::instance();
 }
 
+void HeapManager::addDebugPointers()
+{
+    Singleton<HeapManager>::instance()._addDebugPointers();
+}
+
 void * HeapManager::allocate(size_t i_sz)
 {
     HeapManager& hmgr = Singleton<HeapManager>::instance();
@@ -622,3 +628,28 @@ bool HeapManager::_freeBig(void* i_ptr)
     return result;
 }
 
+void HeapManager::_addDebugPointers()
+{
+    DEBUG::add_debug_pointer(DEBUG::HEAPMANAGER,
+                             this,
+                             sizeof(HeapManager));
+    DEBUG::add_debug_pointer(DEBUG::HEAPMANAGERLARGEPAGECOUNT,
+                             &cv_largeheap_page_count,
+                             sizeof(HeapManager::cv_largeheap_page_count));
+    DEBUG::add_debug_pointer(DEBUG::HEAPMANAGERLARGEPAGEMAX,
+                             &cv_largeheap_page_max,
+                             sizeof(HeapManager::cv_largeheap_page_max));
+    DEBUG::add_debug_pointer(DEBUG::HEAPMANAGERSMALLPAGECOUNT,
+                             &cv_smallheap_page_count,
+                             sizeof(HeapManager::cv_smallheap_page_count));
+    DEBUG::add_debug_pointer(DEBUG::HEAPMANAGERCOALESCECOUNT,
+                             &cv_coalesce_count,
+                             sizeof(HeapManager::cv_coalesce_count));
+    DEBUG::add_debug_pointer(DEBUG::HEAPMANAGERFREEBYTES,
+                             &cv_free_bytes,
+                             sizeof(HeapManager::cv_free_bytes));
+    DEBUG::add_debug_pointer(DEBUG::HEAPMANAGERFREECHUNKS,
+                             &cv_free_chunks,
+                             sizeof(HeapManager::cv_free_chunks));
+}
+
diff --git a/src/kernel/kernel.C b/src/kernel/kernel.C
index e78dca726..da9470546 100644
--- a/src/kernel/kernel.C
+++ b/src/kernel/kernel.C
@@ -41,13 +41,16 @@
 #include <securerom/sha512.H>
 #include <kernel/bltohbdatamgr.H>
 #include <kernel/cpuid.H>
+#include <usr/debugpointers.H>
+#include <kernel/segmentmgr.H>
+#include <kernel/block.H>
 
 #include <stdlib.h>
 
 extern "C" void kernel_dispatch_task();
 extern void* init_main(void* unused);
 extern uint64_t kernel_other_thread_spinlock;
-
+extern char hbi_ImageId[];
 
 class Kernel
 {
@@ -101,7 +104,8 @@ const Bootloader::BlToHbData* getBlToHbData()
 extern "C"
 int main()
 {
-    printk("Booting %s kernel...\n\n", "Hostboot");
+    printk("Booting %s kernel...\n", "Hostboot");
+    printk("%s\n\n", hbi_ImageId);
     printk("CPU=%s  PIR=%ld\n",
            ProcessorCoreTypeStrings[CpuID::getCpuType()],
            static_cast<uint64_t>(getPIR()));
@@ -135,6 +139,18 @@ int main()
     // Let FSP/BMC know that Hostboot is now running
     KernelMisc::setHbScratchStatus(KernelMisc::HB_RUNNING);
 
+    // Initialize the debug pointer area
+    debug_pointers = new DEBUG::DebugPointers_t();
+    DEBUG::add_debug_pointer(DEBUG::PRINTK,
+                             kernel_printk_buffer,
+                             sizeof(kernel_printk_buffer));
+    printk("Debug @ %p\n", debug_pointers);
+    HeapManager::addDebugPointers();
+    PageManager::addDebugPointers();
+    TaskManager::addDebugPointers();
+    SegmentManager::addDebugPointers();
+    Block::addDebugPointers();
+
     kernel.inittaskBootstrap();
 
     // Ready to let the other CPUs go.
@@ -193,3 +209,34 @@ void Kernel::inittaskBootstrap()
     TaskManager::setCurrentTask(t);
 }
 
+
+namespace DEBUG
+{
+void add_debug_pointer( uint64_t i_label,
+                        void* i_ptr,
+                        size_t i_size )
+{
+    if( debug_pointers != nullptr )
+    {
+        for( auto i = 0; i < MAX_ENTRIES; i++ )
+        {
+            if( 0 == ((DebugPointers_t*)debug_pointers)->pairs[i].label_num )
+            {
+                ((DebugPointers_t*)debug_pointers)->pairs[i].label_num
+                  = i_label;
+                ((DebugPointers_t*)debug_pointers)->pairs[i].pointer =
+                  (uint32_t)((uint64_t)i_ptr); //using forced cast on purpose
+                ((DebugPointers_t*)debug_pointers)->pairs[i].size =
+                  static_cast<uint32_t>(i_size);
+                break;
+            }
+        }
+    }
+    else
+    {
+        printk("No debug pointer set for %.16lX\n",i_label);
+        MAGIC_INSTRUCTION(MAGIC_BREAK);
+    }
+    //NOTE: This is called by kernel code so do not add any traces
+}
+};
diff --git a/src/kernel/pagemgr.C b/src/kernel/pagemgr.C
index 42545470a..bfc1bbf7a 100644
--- a/src/kernel/pagemgr.C
+++ b/src/kernel/pagemgr.C
@@ -38,6 +38,7 @@
 #include <kernel/memstate.H>
 #include <kernel/bltohbdatamgr.H>
 #include <kernel/misc.H>
+#include <usr/debugpointers.H>
 
 
 size_t PageManager::cv_coalesce_count = 0;
@@ -205,6 +206,11 @@ uint64_t PageManager::availPages()
     return Singleton<PageManager>::instance()._availPages();
 }
 
+void PageManager::addDebugPointers()
+{
+    return Singleton<PageManager>::instance()._addDebugPointers();
+}
+
 PageManager::PageManager()
     : iv_pagesAvail(0), iv_pagesTotal(0), iv_lock()
 {
@@ -478,3 +484,16 @@ void PageManager::_addMemory(size_t i_addr, size_t i_pageCount)
 
     return;
 }
+
+void PageManager::_addDebugPointers()
+{
+    DEBUG::add_debug_pointer(DEBUG::PAGEMANAGER,
+                             this,
+                             sizeof(PageManager));
+    DEBUG::add_debug_pointer(DEBUG::PAGEMANAGERLOWPAGECOUNT,
+                             &PageManager::cv_low_page_count,
+                             sizeof(PageManager::cv_low_page_count));
+    DEBUG::add_debug_pointer(DEBUG::PAGEMANAGERCOALESCECOUNT,
+                             &PageManager::cv_coalesce_count,
+                             sizeof(PageManager::cv_coalesce_count));
+}
diff --git a/src/kernel/segmentmgr.C b/src/kernel/segmentmgr.C
index 73caaf76f..9cf88de90 100644
--- a/src/kernel/segmentmgr.C
+++ b/src/kernel/segmentmgr.C
@@ -5,7 +5,7 @@
 /*                                                                        */
 /* OpenPOWER HostBoot Project                                             */
 /*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2011,2015                        */
+/* Contributors Listed Below - COPYRIGHT 2011,2018                        */
 /* [+] International Business Machines Corp.                              */
 /*                                                                        */
 /*                                                                        */
@@ -31,6 +31,7 @@
 #include <kernel/segmentmgr.H>
 #include <kernel/segment.H>
 #include <kernel/devicesegment.H>
+#include <usr/debugpointers.H>
 
 bool SegmentManager::handlePageFault(task_t* i_task, uint64_t i_addr,
                                      bool i_store)
@@ -77,6 +78,11 @@ int SegmentManager::devUnmap(void* ea)
     return Singleton<SegmentManager>::instance()._devUnmap(ea);
 }
 
+void SegmentManager::addDebugPointers()
+{
+    Singleton<SegmentManager>::instance()._addDebugPointers();
+}
+
 bool SegmentManager::_handlePageFault(task_t* i_task, uint64_t i_addr,
                                       bool i_store)
 {
@@ -200,4 +206,9 @@ int SegmentManager::_devUnmap(void* ea)
     return reinterpret_cast<DeviceSegment*>(iv_segments[segId])->devUnmap(ea);
 }
 
-
+void SegmentManager::_addDebugPointers()
+{
+    DEBUG::add_debug_pointer(DEBUG::SEGMENTMANAGER,
+                             this,
+                             sizeof(SegmentManager));
+}
diff --git a/src/kernel/start.S b/src/kernel/start.S
index 979235276..1e2b53cd6 100644
--- a/src/kernel/start.S
+++ b/src/kernel/start.S
@@ -276,6 +276,14 @@ kernel_descriptor:
     .byte 'H', 'O', 'S', 'T', 'B', 'O', 'O', 'T'
     .quad kernel_hbDescriptor
 
+;// Hostboot debug pointers.
+;//
+;// This points to a table of pointers to be used by the debug tools
+;// See debugpointers.H for details
+.global debug_pointers
+debug_pointers:
+    .space 8
+
 
 ;// _main:
 ;//     Set up stack and TOC and call kernel's main.
diff --git a/src/kernel/taskmgr.C b/src/kernel/taskmgr.C
index 03b3d0073..274ad42cc 100644
--- a/src/kernel/taskmgr.C
+++ b/src/kernel/taskmgr.C
@@ -5,7 +5,7 @@
 /*                                                                        */
 /* OpenPOWER HostBoot Project                                             */
 /*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2010,2015                        */
+/* Contributors Listed Below - COPYRIGHT 2010,2018                        */
 /* [+] International Business Machines Corp.                              */
 /*                                                                        */
 /*                                                                        */
@@ -36,6 +36,7 @@
 #include <string.h>
 #include <limits.h>
 #include <assert.h>
+#include <usr/debugpointers.H>
 
 extern "C" void userspace_task_entry();
 extern "C" void task_end_stub();
@@ -80,6 +81,11 @@ void TaskManager::waitTask(task_t* t, int64_t tid, int* status, void** retval)
     Singleton<TaskManager>::instance()._waitTask(t,tid,status,retval);
 }
 
+void TaskManager::addDebugPointers()
+{
+    Singleton<TaskManager>::instance()._addDebugPointers();
+}
+
 task_t* TaskManager::_createIdleTask()
 {
     return this->_createTask(&TaskManager::idleTaskLoop, NULL, false, true);
@@ -373,3 +379,10 @@ void TaskManager::removeTracker(task_tracking_t* t)
     // Delete tracker object.
     delete t;
 }
+
+void TaskManager::_addDebugPointers()
+{
+    DEBUG::add_debug_pointer(DEBUG::TASKMANAGER,
+                             this,
+                             sizeof(TaskManager));
+}