summaryrefslogtreecommitdiffstats
path: root/src/usr
diff options
context:
space:
mode:
Diffstat (limited to 'src/usr')
-rw-r--r--src/usr/targeting/common/targetservice.C64
-rw-r--r--src/usr/targeting/runtime/attrrp_rt.C87
-rw-r--r--src/usr/targeting/runtime/rt_targeting.C35
-rw-r--r--src/usr/targeting/runtime/start_rt.C70
4 files changed, 203 insertions, 53 deletions
diff --git a/src/usr/targeting/common/targetservice.C b/src/usr/targeting/common/targetservice.C
index fb5e7cfa5..4489809cf 100644
--- a/src/usr/targeting/common/targetservice.C
+++ b/src/usr/targeting/common/targetservice.C
@@ -184,6 +184,13 @@ void TargetService::init(const size_t i_maxNodes)
l_nodeInfo.initialized = true;
}
+
+ Target* l_pFirstTarget = &(*(l_nodeInfo.targets))[0];
+ TARG_INF("TargetService::init: Pushing info for node %d with first "
+ "target huid 0x%.8x and %d total targets",
+ l_nodeInfo.nodeId,
+ get_huid(l_pFirstTarget),
+ l_nodeInfo.maxTargets);
iv_nodeInfo.push_back(l_nodeInfo);
}
@@ -256,6 +263,43 @@ void TargetService::_getFirstTargetForIterators(Target*& o_firstTargetPtr) const
#undef TARG_FN
}
+#ifdef __HOSTBOOT_RUNTIME
+//******************************************************************************
+// TargetService:: _getFirstTargetForIterators
+//******************************************************************************
+
+void TargetService::_getFirstTargetForIterators(Target*& o_firstTargetPtr,
+ NODE_ID i_nodeId) const
+{
+ #define TARG_FN "_getFirstTargetForIterators()"
+ TARG_ASSERT(iv_initialized, TARG_ERR_LOC
+ "USAGE: TargetService not initialized");
+
+ /* This will come inside for initialized node only.. Just for safety we
+ * are checking for maxTargets & whether it is initialized or not */
+ if( (i_nodeId < MAX_NODE_ID) &&
+ (iv_nodeInfo[i_nodeId].initialized == true) &&
+ (iv_nodeInfo[i_nodeId].maxTargets > 0))
+ {
+ /* Assumption -
+ * Here we are assuming that the first target of any binary is not
+ * the system target, to make sure this ithe binary compiler needs
+ * to compile the binary in this specific order.
+ */
+ o_firstTargetPtr = &(*(iv_nodeInfo[i_nodeId].targets))[0];
+
+ TARG_ASSERT(o_firstTargetPtr != NULL, TARG_ERR_LOC
+ "FATAL: Could not find any targets");
+ }
+ else
+ {
+ o_firstTargetPtr = nullptr;
+ }
+
+ #undef TARG_FN
+}
+#endif
+
//******************************************************************************
// TargetService::begin (non-const version)
//******************************************************************************
@@ -274,6 +318,26 @@ TargetService::iterator TargetService::begin()
#undef TARG_FN
}
+#ifdef __HOSTBOOT_RUNTIME
+//******************************************************************************
+// TargetService::begin (non-const version)
+//******************************************************************************
+
+TargetService::iterator TargetService::begin(NODE_ID i_nodeId)
+{
+ #define TARG_FN "begin()"
+ Target* l_pFirstTarget = nullptr;
+
+ TARG_ASSERT(iv_initialized, TARG_ERR_LOC
+ "USAGE: TargetService not initialized");
+
+ _getFirstTargetForIterators(l_pFirstTarget, i_nodeId);
+ return iterator(l_pFirstTarget);
+
+ #undef TARG_FN
+}
+#endif
+
//******************************************************************************
// TargetService::raw_begin (non-const version)
//******************************************************************************
diff --git a/src/usr/targeting/runtime/attrrp_rt.C b/src/usr/targeting/runtime/attrrp_rt.C
index 21aa4b8c6..f8d6ed9e2 100644
--- a/src/usr/targeting/runtime/attrrp_rt.C
+++ b/src/usr/targeting/runtime/attrrp_rt.C
@@ -488,20 +488,86 @@ namespace TARGETING
#undef TARG_FN
}
+ void AttrRP::getNodeId(const Target* i_pTarget,
+ NODE_ID& o_nodeId) const
+ {
+ #define TARG_FN "getNodeId"
+
+ bool l_found = false;
+
+ // Initialize with invalid
+ o_nodeId = INVALID_NODE_ID;
+
+ //find the node to which this target belongs
+ for(uint8_t i=0; i<INVALID_NODE_ID; ++i)
+ {
+ for(uint32_t j=0; j<iv_nodeContainer[i].sectionCount; ++j)
+ {
+ if( iv_nodeContainer[i].pSections[j].type ==
+ SECTION_TYPE_PNOR_RO)
+ {
+ // This expects the pTarget to be always in range and !NULL.
+ // If any invalid target is passed (which is still within the
+ // RO Section scope) then behaviour is undefined.
+ if( (i_pTarget >= iv_nodeContainer[i].pTargetMap) &&
+ (i_pTarget < reinterpret_cast<Target*>((
+ reinterpret_cast<uint8_t*>(
+ iv_nodeContainer[i].pTargetMap) +
+ iv_nodeContainer[i].pSections[j].size))) )
+ {
+ l_found = true;
+ o_nodeId = i;
+ break;
+ }
+ }
+ }
+ if(l_found)
+ {
+ break;
+ }
+ }
+ #undef TARG_FN
+ }
+
void* AttrRP::translateAddr(void* i_pAddress,
- const Target* i_pUnused)
+ const Target* i_pTarget)
{
- void* l_address = i_pAddress;
+ #define TARG_FN "translateAddr(..., Target*)"
+// TARG_ENTER(); // Disabled due to number of traces created
+
+ NODE_ID l_nodeId = NODE0;
- for (size_t i = 0; i < iv_sectionCount; ++i)
+ if(i_pTarget != NULL)
{
- if ((iv_sections[i].vmmAddress + iv_sections[i].size) >=
+ getNodeId(i_pTarget, l_nodeId);
+ }
+
+ void* l_address = translateAddr(i_pAddress, l_nodeId);
+
+// TARG_EXIT(); // Disabled due to number of traces created
+ #undef TARG_FN
+
+ return l_address;
+ }
+
+ void* AttrRP::translateAddr(void* i_pAddress,
+ const TARGETING::NODE_ID i_nodeId)
+ {
+ #define TARG_FN "translateAddr(..., NODE_ID)"
+// TARG_ENTER(); // Disabled due to number of traces created
+
+ void* l_address = NULL;
+
+ for (size_t i = 0; i < iv_nodeContainer[i_nodeId].sectionCount; ++i)
+ {
+ if ((iv_nodeContainer[i_nodeId].pSections[i].vmmAddress +
+ iv_nodeContainer[i_nodeId].pSections[i].size) >=
reinterpret_cast<uint64_t>(i_pAddress))
{
l_address = reinterpret_cast<void*>(
- iv_sections[i].pnorAddress +
+ iv_nodeContainer[i_nodeId].pSections[i].pnorAddress +
reinterpret_cast<uint64_t>(i_pAddress) -
- iv_sections[i].vmmAddress);
+ iv_nodeContainer[i_nodeId].pSections[i].vmmAddress);
break;
}
}
@@ -509,12 +575,9 @@ namespace TARGETING
TRACDCOMP(g_trac_targeting, "Translated 0x%p to 0x%p",
i_pAddress, l_address);
- return l_address;
- }
+// TARG_EXIT(); // Disabled due to number of traces created
+ #undef TARG_FN
- void* AttrRP::translateAddr(void* i_pAddress,
- const TARGETING::NODE_ID i_unused)
- {
- return translateAddr(i_pAddress, static_cast<Target*>(NULL));
+ return l_address;
}
}
diff --git a/src/usr/targeting/runtime/rt_targeting.C b/src/usr/targeting/runtime/rt_targeting.C
index 8eea48a57..8da93830d 100644
--- a/src/usr/targeting/runtime/rt_targeting.C
+++ b/src/usr/targeting/runtime/rt_targeting.C
@@ -45,6 +45,8 @@
#include <util/memoize.H>
#include <util/runtime/util_rt.H>
#include <util/utillidmgr.H>
+#include <sys/internode.h>
+
using namespace TARGETING;
@@ -123,17 +125,32 @@ errlHndl_t _getHbTarget(
TARGETING::TargetHandle_t pTarget = NULL;
if(i_rtTargetId != RUNTIME::HBRT_HYP_ID_UNKNOWN)
{
- for (TARGETING::TargetIterator pIt =
- TARGETING::targetService().begin();
- pIt != TARGETING::targetService().end();
- ++pIt)
+ uint8_t l_maxNodeId =
+ TARGETING::targetService().getNumInitializedNodes();
+ for(uint8_t l_nodeId=NODE0; l_nodeId<l_maxNodeId; ++l_nodeId)
{
- auto rtTargetId = RUNTIME::HBRT_HYP_ID_UNKNOWN;
- if( ((*pIt)->tryGetAttr<
- TARGETING::ATTR_HBRT_HYP_ID>(rtTargetId))
- && (rtTargetId == i_rtTargetId))
+ TRACFCOMP( g_trac_targeting, "Node %d beginning target %p",
+ l_nodeId,
+ *(TARGETING::targetService().begin(l_nodeId)));
+
+ for (TARGETING::TargetIterator pIt =
+ TARGETING::targetService().begin(l_nodeId);
+ pIt != TARGETING::targetService().end();
+ ++pIt)
+ {
+ auto rtTargetId = RUNTIME::HBRT_HYP_ID_UNKNOWN;
+ if( (*pIt != nullptr)
+ && ((*pIt)->tryGetAttr<
+ TARGETING::ATTR_HBRT_HYP_ID>(rtTargetId))
+ && (rtTargetId == i_rtTargetId))
+ {
+ pTarget = (*pIt);
+ break;
+ }
+ }
+
+ if(pTarget)
{
- pTarget = (*pIt);
break;
}
}
diff --git a/src/usr/targeting/runtime/start_rt.C b/src/usr/targeting/runtime/start_rt.C
index b49d4524b..dac7dc137 100644
--- a/src/usr/targeting/runtime/start_rt.C
+++ b/src/usr/targeting/runtime/start_rt.C
@@ -48,7 +48,7 @@ namespace RT_TARG
}
TargetService& l_targetService = targetService();
- (void)l_targetService.init();
+ l_targetService.init(Singleton<AttrRP>::instance().getNodeCount());
adjustTargeting4Runtime();
@@ -78,45 +78,51 @@ namespace RT_TARG
// error check that ATTR_PEER_TARGET is only readable, not writable.
// adjustTargeting4Runtime has been included as a friend to allow
// access to the private target class methods.
- const Target* l_pUnused = NULL;
size_t l_xlateCnt = 0;
- for (TargetIterator target = targetService().begin();
- target != targetService().end();
- ++target)
+ uint8_t l_maxNodeId =
+ TARGETING::targetService().getNumInitializedNodes();
+ for(uint8_t l_nodeId = NODE0; l_nodeId < l_maxNodeId; ++l_nodeId)
{
- const TARGETING::Target * l_target = *target;
- TARGETING::Target * l_peer = static_cast<Target*>(NULL);
- bool l_hasPeer = l_target->tryGetAttr<ATTR_PEER_TARGET>(l_peer);
- if (l_hasPeer && (l_peer != nullptr))
+ for (TargetIterator target = targetService().begin(l_nodeId);
+ target != targetService().end();
+ ++target)
{
- TRACDCOMP(g_trac_targeting,
- "translate peer target for=%p %x",
- l_target, get_huid(l_target));
-
- ATTR_PEER_TARGET_type l_xlated = (TARGETING::Target *)
- Singleton<AttrRP>::instance().
- AttrRP::translateAddr(l_peer,l_pUnused);
- bool l_fixed = false;
- l_fixed = l_target->_trySetAttr(ATTR_PEER_TARGET,
- sizeof(l_xlated),
- &l_xlated);
- if (l_fixed)
- {
- TRACDCOMP(g_trac_targeting, " to=%p", l_xlated);
- l_xlateCnt++;
- }
- // Not good if could not be fixed. But might not be referenced.
- // A segment fault will occur if used.
- else
+ const TARGETING::Target * l_target = *target;
+ TARGETING::Target * l_peer = static_cast<Target*>(NULL);
+ bool l_hasPeer = l_target->tryGetAttr<ATTR_PEER_TARGET>(l_peer);
+ if (l_hasPeer && (l_peer != nullptr))
{
TRACFCOMP(g_trac_targeting,
- "failed to translate peer target HUID=0x%x",
- get_huid(l_target));
+ "translate peer target for=%p %x",
+ l_target, get_huid(l_target));
+
+ ATTR_PEER_TARGET_type l_xlated = (TARGETING::Target *)
+ Singleton<AttrRP>::instance().
+ AttrRP::translateAddr(l_peer,l_target);
+ bool l_fixed = false;
+ l_fixed = l_target->_trySetAttr(ATTR_PEER_TARGET,
+ sizeof(l_xlated),
+ &l_xlated);
+ if (l_fixed)
+ {
+ TRACDCOMP(g_trac_targeting, " to=%p", l_xlated);
+ l_xlateCnt++;
+ }
+ // Not good if could not be fixed. But might not be
+ // referenced. A segment fault will occur if used.
+ else
+ {
+ TRACFCOMP(g_trac_targeting,
+ "failed to translate peer target HUID=0x%x",
+ get_huid(l_target));
+ }
}
}
}
TRACFCOMP(g_trac_targeting,
- "adjustTargeting4Runtime: %d peer target addresses translated",
- l_xlateCnt);
+ "adjustTargeting4Runtime: %d peer target addresses "
+ "translated on %d nodes",
+ l_xlateCnt,
+ l_maxNodeId);
}
}
OpenPOWER on IntegriCloud