From 519b09db143e87b3d43f39790486f6c5dc1be96b Mon Sep 17 00:00:00 2001 From: Marty Gloff Date: Tue, 13 Feb 2018 10:46:34 -0600 Subject: Support multiple nodes in HBRT - Concurrent Code Update Enable HBRT to prepare for a concurrent code update on a multiple node system. Modify preparation function called by Host to loop through all nodes on the system. Make additional updates to go from supporting only a single node to supporting multiple nodes. Change-Id: I2d72b26abf40812641815051b968d6b540d27b00 RTC: 186584 Reviewed-on: http://ralgit01.raleigh.ibm.com/gerrit1/53952 Tested-by: Jenkins Server Tested-by: Jenkins OP Build CI Tested-by: Jenkins OP HW Tested-by: FSP CI Jenkins Reviewed-by: Christian R. Geddes Reviewed-by: Prachi Gupta Reviewed-by: Daniel M. Crowell --- src/include/usr/runtime/rt_targeting.H | 8 +- src/include/usr/targeting/attrrp.H | 51 ++- src/include/usr/targeting/common/target.H | 90 ++++- src/include/usr/targeting/common/targetservice.H | 25 +- src/usr/errl/errlentry.C | 4 +- src/usr/targeting/attrrp_common.C | 7 + src/usr/targeting/common/target.C | 28 ++ src/usr/targeting/common/targetservice.C | 120 ++++-- src/usr/targeting/runtime/attrrp_rt.C | 50 +-- src/usr/targeting/runtime/rt_targeting.C | 120 +++--- src/usr/targeting/runtime/test/testtargeting.H | 479 ++++++++++++++--------- 11 files changed, 624 insertions(+), 358 deletions(-) diff --git a/src/include/usr/runtime/rt_targeting.H b/src/include/usr/runtime/rt_targeting.H index 9f3d96818..9070dbc88 100644 --- a/src/include/usr/runtime/rt_targeting.H +++ b/src/include/usr/runtime/rt_targeting.H @@ -67,12 +67,12 @@ namespace RT_TARG * into new LID Structure data * @param[in] Pointer to current Reserved Memory targeting binary data * @param[in/out] Pointer to new LID Structure targeting binary data - * @param[out] Error log userdata2 value associated with non-zero rtn code + * @param[in] Instance, ie, Node ID * @return nullptr on success, else error log */ errlHndl_t saveRestoreAttrs(void *i_rsvdMemPtr, void *io_lidStructPtr, - uint64_t& o_userdata2); + uint8_t i_instance); /** * @brief Validate LID Structure against Reserved Memory. Check that the @@ -82,13 +82,11 @@ namespace RT_TARG * @param[in] Pointer to new LID Structure targeting binary data * @param[in] Pointer to current Reserved Memory targeting binary data * @param[out] Total size of all sections in the new lid - * @param[out] Error log userdata2 value associated with non-zero rtn code * @return nullptr on success, else error log */ errlHndl_t validateData(void *i_lidStructPtr, void *i_rsvdMemPtr, - size_t& o_lidTotalSize, - uint64_t& o_userdata2); + size_t& o_lidTotalSize); /** * @brief Apply ATTR_TMP overrides to be available for run time diff --git a/src/include/usr/targeting/attrrp.H b/src/include/usr/targeting/attrrp.H index 6eb367e17..897e6dec4 100644 --- a/src/include/usr/targeting/attrrp.H +++ b/src/include/usr/targeting/attrrp.H @@ -114,7 +114,7 @@ class AttrRP #else friend errlHndl_t RT_TARG::saveRestoreAttrs(void *, void *, - uint64_t&); + uint8_t); #endif public: @@ -306,14 +306,16 @@ class AttrRP #else /** - * @brief Fill in new attribute resource provider for HBRT. + * @brief Get node instance status of attribute resource provider + * which indicates if the attribute resource provider is handling + * a single node or multiple nodes * - * @param[in] i_header - * TargetingHeader to use with filling in the new RT AttrRP. - * - * @return void + * @return Node instance status */ - void fillInAttrRP(TargetingHeader* i_header); + NodeInstanceStatus getInstanceStatus() + { + return iv_instanceStatus; + } /** * @brief Get count of nodes handled by attribute resource provider. @@ -352,12 +354,39 @@ class AttrRP * @par Detailed Description: * Ensures member variables are initialized to sane values. */ - AttrRP(TargetingHeader* i_header) - : iv_isTempInstance(true), iv_instanceStatus(SINGLE_NODE), + AttrRP(TargetingHeader* i_header, + NODE_ID i_nodeId, + size_t i_nodeCount, + NodeInstanceStatus i_instanceStatus) + : iv_isTempInstance(true), iv_instanceStatus(i_instanceStatus), iv_isMpipl(false) { - // Fill in member variables - fillInAttrRP(i_header); + // Work with nodes before passed in node + for(NODE_ID l_nodeId = NODE0; l_nodeId < i_nodeCount; ++l_nodeId) + { + // Create local copy of container for node info struct + NodeInfo l_nodeCont; + + if(l_nodeId == i_nodeId) + { + // Initialize local copy of container for node info struct + errlHndl_t l_errl = nodeInfoInit(l_nodeCont, + i_header, + i_nodeId); + if (l_errl) + { + l_errl->setSev(ERRORLOG::ERRL_SEV_UNRECOVERABLE); + + /* Commit the error */ + errlCommit(l_errl, TARG_COMP_ID); + + break; + } + } + + // Push back node info struct into the node container + iv_nodeContainer.push_back(l_nodeCont); + } }; #endif diff --git a/src/include/usr/targeting/common/target.H b/src/include/usr/targeting/common/target.H index 7bdd16f54..21f3d7fba 100644 --- a/src/include/usr/targeting/common/target.H +++ b/src/include/usr/targeting/common/target.H @@ -64,7 +64,7 @@ namespace RT_TARG void adjustTargeting4Runtime(); ERRORLOG::ErrlEntry* saveRestoreAttrs(void *i_rsvdMemPtr, void *io_lidStructPtr, - uint64_t& o_userdata2); + uint8_t i_instance); } #endif @@ -179,6 +179,34 @@ class Target template typename AttributeTraits::Type getAttr() const; + /** + * @brief Get the target's specified attribute value + * + * Returns the target's specified attribute value. If the specified + * attribute does not exist for the associated target, the routine + * asserts. Thus callers must be sure the attribute exists for the + * given target. + * + * @param[in] i_attrRP Pointer to attribute resource provider + * @param[in] i_pAttrId Pointer to array of attribute IDs for target + * @param[in] i_ppAttrAddr Pointer to array of attribute addresses + * + * @pre Target service must be initialized + * + * @post Target's specified attribute value returned, or assert + * called if specified attribute doesn't exist for the + * associated target + * + * @return Data type associated with the attribute being returned + * + * @retval Varies The attribute data + */ + template + typename AttributeTraits::Type getAttr(AttrRP* i_attrRP, + ATTRIBUTE_ID* i_pAttrId, + AbstractPointer* + i_ppAttrAddr) const; + /** * @brief DEBUG ONLY! Returns the requested attribute as a string * @@ -479,6 +507,39 @@ class Target uint32_t i_size, void* io_attrData) const; + /** + * @brief Tries to get the target's specified attribute value without + * checking for valid values. Do not call this function + * directly. This function is private. + * + * Tries to get the target's specified attribute value + * + * @param[in] i_attr Attribute to retrieve + * @param[in] i_size Size of the attribute + * @param[in] i_attrRP Pointer to attribute resource provider + * @param[in] i_pAttrId Pointer to array of attribute IDs for target + * @param[in] i_ppAttrAddr Pointer to array of attribute addresses + * @param[in/out] io_attrData On input, location to store the attribute + * On output, location updated with attribute data + * + * @pre Target service must be initialized + * + * @post Caller notified if attribute retrieval succeeded or not. If + * so, the attribute data is stored at io_addrData + * + * @return bool indicating if attribute retrieval succeeded or not + * + * @retval true Attribute retrieval succeeded + * @retval false Attribute retrieval failed + */ + bool _tryGetAttrUnsafe( + ATTRIBUTE_ID i_attr, + uint32_t i_size, + AttrRP* i_attrRP, + ATTRIBUTE_ID* i_pAttrId, + AbstractPointer* i_ppAttrAddr, + void* io_attrData) const; + /** * @brief Tries to set the target's specified attribute value * @@ -704,7 +765,7 @@ class Target friend void RT_TARG::adjustTargeting4Runtime(); friend ERRORLOG::ErrlEntry* RT_TARG::saveRestoreAttrs(void *, void *, - uint64_t&); + uint8_t); #endif @@ -763,6 +824,31 @@ typename AttributeTraits::Type Target::getAttr() const return l_attrValue; } +template +typename AttributeTraits::Type Target::getAttr(AttrRP* i_attrRP, + ATTRIBUTE_ID* i_pAttrId, + AbstractPointer* + i_ppAttrAddr) const +{ + typename AttributeTraits::Type l_attrValue; + if(AttributeTraits::readable) { } + if(AttributeTraits::notHbMutex) { } + if(AttributeTraits::notFspMutex) { } + + bool l_read = _tryGetAttrUnsafe(A, + sizeof(l_attrValue), + i_attrRP, + i_pAttrId, + i_ppAttrAddr, + reinterpret_cast(&l_attrValue)); + + if (unlikely(!l_read)) + { + targAssert(GET_ATTR, A); + } + return l_attrValue; +} + template void Target::setAttr(typename AttributeTraits::Type const& i_attrValue) { diff --git a/src/include/usr/targeting/common/targetservice.H b/src/include/usr/targeting/common/targetservice.H index c02826b77..82001c0ae 100644 --- a/src/include/usr/targeting/common/targetservice.H +++ b/src/include/usr/targeting/common/targetservice.H @@ -726,31 +726,30 @@ class TargetService void getMasterNodeTarget(Target*& o_masterNodeTarget) const; /** - * @brief Returns Target Range Filter information. + * @brief Returns Array of Targets from Targeting Image. * * @par Detailed Description: - * Returns the Target Range Filter information for the specified - * attribute data and resource provider. + * Returns a pointer to the Array of Targets found in the Targeting + * Image as provided by the Attribute Data. * * @param[in] i_attrData pointer to attribute data * - * @param[in] i_attrRP pointer to attribute resource provider + * @param[in] i_nodeId, node ID for the targeting image * - * @param[out] o_maxTargets maximum targets in the range + * @param[in] i_attrRP pointer to attribute resource provider * - * @param[in] i_nodeId, node ID for the target. + * @param[out] o_maxTargets maximum targets in image * * @pre TargetService must be initialized. * - * @post Returns the Target Range Filter information for the specified - * attribute data and resource provider. + * @post Returns pointer to Array of Targets from Targeting Image. * - * @return TargetRangeFilter + * @return Target* */ - TargetRangeFilter getTargetRangeFilter(void *i_attrData, - AttrRP *i_attrRP, - uint32_t &o_maxTargets, - NODE_ID i_nodeId); + Target* getTargetArray(void *i_attrData, + NODE_ID i_nodeId, + AttrRP *i_attrRP, + uint32_t &o_maxTargets); /** * @brief Returns Target Attribute information. diff --git a/src/usr/errl/errlentry.C b/src/usr/errl/errlentry.C index 2605509ae..972c8b272 100644 --- a/src/usr/errl/errlentry.C +++ b/src/usr/errl/errlentry.C @@ -91,9 +91,9 @@ ErrlEntry::ErrlEntry(const errlSeverity_t i_sev, iv_eselCallhomeInfoEvent(false) { #ifdef CONFIG_ERRL_ENTRY_TRACE - TRACFCOMP( g_trac_errl, ERR_MRK"Error created : PLID=%.8X, RC=%.4X, Mod=%.2X, Userdata=%.16X %.16X", plid(), i_reasonCode, i_modId, i_user1, i_user2 ); + TRACFCOMP( g_trac_errl, ERR_MRK"Error created : PLID=%.8X, RC=%.4X, Mod=%.2X, Userdata=%.16llX %.16llX", plid(), i_reasonCode, i_modId, i_user1, i_user2 ); #else - TRACDCOMP( g_trac_errl, ERR_MRK"Error created : PLID=%.8X, RC=%.4X, Mod=%.2X, Userdata=%.16X %.16X", plid(), i_reasonCode, i_modId, i_user1, i_user2 ); + TRACDCOMP( g_trac_errl, ERR_MRK"Error created : PLID=%.8X, RC=%.4X, Mod=%.2X, Userdata=%.16llX %.16llX", plid(), i_reasonCode, i_modId, i_user1, i_user2 ); #endif // Collect the Backtrace and add it to the error log iv_pBackTrace = new ErrlUserDetailsBackTrace(); diff --git a/src/usr/targeting/attrrp_common.C b/src/usr/targeting/attrrp_common.C index 26213dcf5..173c249ec 100755 --- a/src/usr/targeting/attrrp_common.C +++ b/src/usr/targeting/attrrp_common.C @@ -61,6 +61,7 @@ namespace TARGETING if (iv_sections) // @TODO RTC:186585 move if... to #ifndef clause { delete[] iv_sections; + iv_sections = nullptr; } // @TODO RTC:186585 move if... to #ifndef clause #ifndef __HOSTBOOT_RUNTIME @@ -71,7 +72,13 @@ namespace TARGETING { if (iv_nodeContainer[i].pSections) { + if((i == NODE0) && (iv_sections == nullptr)) + { + iv_nodeContainer[i].pSections = nullptr; + continue; + } // @TODO RTC:186585 move if... delete[] iv_nodeContainer[i].pSections; + iv_nodeContainer[i].pSections = nullptr; } } diff --git a/src/usr/targeting/common/target.C b/src/usr/targeting/common/target.C index 1ee281576..90bfd6850 100644 --- a/src/usr/targeting/common/target.C +++ b/src/usr/targeting/common/target.C @@ -137,6 +137,34 @@ bool Target::_tryGetAttrUnsafe( #undef TARG_FN } +//****************************************************************************** +// Target::_tryGetAttrUnsafe +//****************************************************************************** +bool Target::_tryGetAttrUnsafe( + const ATTRIBUTE_ID i_attr, + const uint32_t i_size, + AttrRP* i_attrRP, + ATTRIBUTE_ID* i_pAttrId, + AbstractPointer* i_ppAttrAddr, + void* const io_pAttrData) const +{ + #define TARG_FN "_tryGetAttrUnsafe()" + + bool l_found = false; + + void* l_pAttrData = NULL; + _getAttrPtr(i_attr, i_attrRP, i_pAttrId, i_ppAttrAddr, l_pAttrData); + if (l_pAttrData) + { + memcpy(io_pAttrData, l_pAttrData, i_size); + l_found = true; + } + + return l_found; + + #undef TARG_FN +} + //****************************************************************************** // Target::_trySetAttr //****************************************************************************** diff --git a/src/usr/targeting/common/targetservice.C b/src/usr/targeting/common/targetservice.C index 652d8869c..3db2f75c7 100644 --- a/src/usr/targeting/common/targetservice.C +++ b/src/usr/targeting/common/targetservice.C @@ -507,23 +507,25 @@ Target* TargetService::getNextTarget(const Target* i_pTarget) const #define TARG_FN "getNextTarget(...)" Target* l_pTarget = const_cast(i_pTarget); bool l_targetFound = false; + if(l_pTarget != NULL) { for(uint8_t i_node=0; i_node 0) && - ((l_pTarget >= &(*(iv_nodeData[i_node]).targets)[0]) && - (l_pTarget <= &(*(iv_nodeData[i_node]).targets)[ + ((l_pTarget >= &(*(iv_nodeData[i_node].targets))[0]) && + (l_pTarget <= &(*(iv_nodeData[i_node].targets))[ iv_nodeData[i_node].maxTargets - 1]))) { - if( l_pTarget == &(*(iv_nodeData[i_node]).targets)[iv_nodeData[ + if( l_pTarget == &(*(iv_nodeData[i_node].targets))[iv_nodeData[ i_node].maxTargets - 1] ) { // Go for next node uint8_t l_nextNode = getNextInitializedNode( static_cast(i_node)); - if(l_nextNode != MAX_NODE_ID) + TARG_INF("getNextTarget: Using next node %d", l_nextNode); + if(l_nextNode < MAX_NODE_ID) { l_pTarget = &(*(iv_nodeData[l_nextNode].targets))[0]; l_targetFound = true; @@ -542,10 +544,34 @@ Target* TargetService::getNextTarget(const Target* i_pTarget) const break; } } + else if( !(iv_nodeData[i_node].initialized) || + (iv_nodeData[i_node].maxTargets == 0)) + { + TARG_ERR("getNextTarget: For node %d, initialized %d, " + "maximum targets %d", + i_node, + iv_nodeData[i_node].initialized, + iv_nodeData[i_node].maxTargets); + } + } + + if(l_targetFound == false) + { + for(uint8_t i_node=0; i_nodeeyeCatcher) - // Create node info - TargetService::NodeSpecificInfo l_nodeSpecificInfo; - l_nodeSpecificInfo.nodeId = i_nodeId; + // Save away the address of the targeting data in l_pPnor variable + // l_pPnor--> points to uint32_t* --> points to --> uint32_t, targets[] + // (uint32_t*)+1 --> points to ------------> targets[] + const void *l_pPnor = + reinterpret_cast(reinterpret_cast(l_header) + + l_header->headerSize); + + // Target count found by following the l_pPnor pointer + const AbstractPointer* pNumTargetsPtr = + static_cast*>(l_pPnor); + uint32_t* pNumTargets = TARG_TO_PLAT_PTR(*pNumTargetsPtr); + + // Only translate addresses on platforms where addresses are 4 bytes wide + // (FSP). The compiler should perform dead code elimination of this path on + // platforms with 8 byte wide addresses (Hostboot), since the "if" check + // can be statically computed at compile time. + if(TARG_ADDR_TRANSLATION_REQUIRED) + { + pNumTargets = + static_cast(i_attrRP->translateAddr(pNumTargets, + i_nodeId)); + } - // Save away the address of the targeting data in pPnor field - l_nodeSpecificInfo.pPnor = - reinterpret_cast(reinterpret_cast(l_header) + - l_header->headerSize); + TARG_ASSERT(pNumTargets, TARG_ERR_LOC + "FATAL: Could not determine location of targets after " + "address translation"); - TargetService::_configureTargetPool(l_nodeSpecificInfo, - i_attrRP); + // Set maximum number of targets output + o_maxTargets = *pNumTargets; - l_nodeSpecificInfo.initialized = true; + TARG_INF("Max targets = %d", o_maxTargets); - // Create pointer to first target in new attribute data - // First target is after header and number of targets count - Target* l_pFirstTarget = &(*(l_nodeSpecificInfo.targets))[0]; - TARG_INF("getTargetRangeFilter: First target pointer %p, huid 0x%.8x", - l_pFirstTarget, - get_huid(l_pFirstTarget)); + // Targets array found by following the l_pPnor pointer + Target (*l_targets)[] = reinterpret_cast< Target(*)[] > ( + (TARG_TO_PLAT_PTR_AND_INC(*pNumTargetsPtr,1))); - // Create TargetRangeFilter for attribute data - TargetRangeFilter l_rangeFilter(TargetIterator(l_pFirstTarget), - TargetIterator(NULL), - NULL); + TARG_ASSERT(l_targets, TARG_ERR_LOC + "FATAL: Could not determine location of targets"); + TARG_INF("l_targets = %p", l_targets); - // Set maximum target value to be returned - o_maxTargets = l_nodeSpecificInfo.maxTargets; + // Only translate addresses on platforms where addresses are 4 bytes wide + // (FSP). The compiler should perform dead code elimination of this path on + // platforms with 8 byte wide addresses (Hostboot), since the "if" check + // can be statically computed at compile time. + if(TARG_ADDR_TRANSLATION_REQUIRED) + { + l_targets = + static_cast(i_attrRP->translateAddr(l_targets, + i_nodeId)); + TARG_ASSERT(l_targets, TARG_ERR_LOC + "FATAL: Could not determine location of targets after " + "address translation"); + TARG_INF("l_targets after translation = %p", + l_targets); + } TARG_EXIT(); #undef TARG_FN - return l_rangeFilter; + // Return pointer to first target in array + return &(*(l_targets))[0]; } //****************************************************************************** diff --git a/src/usr/targeting/runtime/attrrp_rt.C b/src/usr/targeting/runtime/attrrp_rt.C index e13ecd3dc..8d260cf75 100644 --- a/src/usr/targeting/runtime/attrrp_rt.C +++ b/src/usr/targeting/runtime/attrrp_rt.C @@ -38,54 +38,6 @@ using namespace ERRORLOG; namespace TARGETING { - void AttrRP::fillInAttrRP(TargetingHeader* i_header) - { - TRACFCOMP(g_trac_targeting, ENTER_MRK"AttrRP::fillInAttrRP"); - - do - { - // Allocate section structures based on section count in header. - iv_sectionCount = i_header->numSections; - iv_sections = new AttrRP_Section[iv_sectionCount](); - - // Find start to the first section: - // (header address + size of header + offset in header) - TargetingSection* l_section = - reinterpret_cast( - reinterpret_cast(i_header) + - sizeof(TargetingHeader) + i_header->offsetToSections - ); - - uint64_t l_offset = 0; - - for (size_t i = 0; i < iv_sectionCount; ++i, ++l_section) - { - iv_sections[i].type = l_section->sectionType; - iv_sections[i].size = l_section->sectionSize; - - iv_sections[i].vmmAddress = - static_cast( - TARG_TO_PLAT_PTR(i_header->vmmBaseAddress)) + - i_header->vmmSectionOffset*i; - iv_sections[i].pnorAddress = - reinterpret_cast(i_header) + l_offset; - - l_offset += ALIGN_PAGE(iv_sections[i].size); - - TRACFCOMP(g_trac_targeting, - "Decoded Attribute Section: %d, 0x%lx, 0x%lx, 0x%lx", - iv_sections[i].type, - iv_sections[i].vmmAddress, - iv_sections[i].pnorAddress, - iv_sections[i].size); - } - } while(false); - - TRACFCOMP(g_trac_targeting, EXIT_MRK"AttrRP::fillInAttrRP"); - - return; - } - void AttrRP::startup(errlHndl_t& io_taskRetErrl, bool isMpipl) { TRACFCOMP(g_trac_targeting, "AttrRP::startup"); @@ -282,7 +234,7 @@ namespace TARGETING TargetingHeader* i_header, const NODE_ID i_nodeId) { - TRACFCOMP(g_trac_targeting, "AttrRP::nodeInfoInit"); + TRACFCOMP(g_trac_targeting, "AttrRP::nodeInfoInit %d", i_nodeId); errlHndl_t l_errl = nullptr; do diff --git a/src/usr/targeting/runtime/rt_targeting.C b/src/usr/targeting/runtime/rt_targeting.C index 8da93830d..8f1a9b5a1 100644 --- a/src/usr/targeting/runtime/rt_targeting.C +++ b/src/usr/targeting/runtime/rt_targeting.C @@ -202,13 +202,11 @@ errlHndl_t getHbTarget( * @param[in] Pointer to new LID Structure targeting binary data * @param[in] Pointer to current Reserved Memory targeting binary data * @param[out] Total size of all sections in the new lid - * @param[out] Error log userdata2 value associated with non-zero rtn code * @return 0 on success, else return code */ errlHndl_t validateData(void *i_lidStructPtr, void *i_rsvdMemPtr, - size_t& o_lidTotalSize, - uint64_t& o_userdata2) + size_t& o_lidTotalSize) { TRACFCOMP(g_trac_targeting, ENTER_MRK"validateData: %p %p", i_lidStructPtr, i_rsvdMemPtr); @@ -376,7 +374,7 @@ errlHndl_t validateData(void *i_lidStructPtr, o_lidTotalSize += l_sectionLid->sectionSize; } - // *** Could check if rc was set in for loop and break from do loop + // *** Could check if rc was set in for loop and break from do loop } while(false); TRACFCOMP(g_trac_targeting, @@ -391,24 +389,23 @@ errlHndl_t validateData(void *i_lidStructPtr, * into new LID Structure data * @param[in] Pointer to current Reserved Memory targeting binary data * @param[in/out] Pointer to new LID Structure targeting binary data - * @param[out] Error log userdata2 value associated with non-zero rtn code + * @param[in] Instance, ie, Node ID * @return 0 on success, else return code */ errlHndl_t saveRestoreAttrs(void *i_rsvdMemPtr, void *io_lidStructPtr, - uint64_t& o_userdata2) + uint8_t i_instance) { TRACFCOMP( g_trac_targeting, - ENTER_MRK"saveRestoreAttrs: %p %p", - i_rsvdMemPtr, io_lidStructPtr ); + ENTER_MRK"saveRestoreAttrs: %p %p %d", + i_rsvdMemPtr, io_lidStructPtr, i_instance ); errlHndl_t l_errhdl = nullptr; AttrRP *l_attrRPLid = nullptr; do { - // Node ID - NODE_ID l_nodeId = NODE0; + NODE_ID l_nodeId = static_cast(i_instance); // Locate current Reserved Memory data via TargetService TARGETING::TargetService& l_targSrv = TARGETING::targetService(); @@ -418,41 +415,47 @@ errlHndl_t saveRestoreAttrs(void *i_rsvdMemPtr, // Create temporary AttrRP instance for new LID Structure targeting data l_attrRPLid = - new AttrRP(reinterpret_cast(io_lidStructPtr)); + new AttrRP(reinterpret_cast(io_lidStructPtr), + l_nodeId, + l_attrRPRsvd->getNodeCount(), + l_attrRPRsvd->getInstanceStatus()); - // Create TargetRangeFilter for LID Structure targeting data + // Get pointer to array of targets in the targeting image uint32_t l_maxTargetsLid = 0; - TargetRangeFilter l_allTargetsLid = - l_targSrv.getTargetRangeFilter(io_lidStructPtr, - l_attrRPLid, - l_maxTargetsLid, - l_nodeId); + Target (*l_targetsLid)[] = reinterpret_cast< Target(*)[] >( + l_targSrv.getTargetArray(io_lidStructPtr, + l_nodeId, + l_attrRPLid, + l_maxTargetsLid)); TRACFCOMP( g_trac_targeting, - "Found %d targets in the lid", - l_maxTargetsLid ); + "Found %d targets in the lid for node %d", + l_maxTargetsLid, + l_nodeId ); // Set up variables for getting attribute information for a target uint32_t l_attrCountRsvd = 0; ATTRIBUTE_ID* l_pAttrIdRsvd = nullptr; AbstractPointer* l_ppAttrAddrRsvd = nullptr; + uint32_t l_attrCountLid = 0; ATTRIBUTE_ID* l_pAttrIdLid = nullptr; AbstractPointer* l_ppAttrAddrLid = nullptr; - uint32_t l_huidLid = 0; - EntityPath l_physPathLid; // Walk through new LID Structure Targets for(uint32_t l_targetNum = 1; (l_targetNum <= l_maxTargetsLid); - ++l_allTargetsLid, ++l_targetNum) + ++l_targetNum) { + // Get target for this pass through loop + Target *l_targetLid = &(*(l_targetsLid))[l_targetNum - 1]; + // Counts of how many new attribute values were kept uint32_t l_kept_for_added_attr = 0; uint32_t l_kept_for_unknown_size = 0; // Get attribute information for a target in LID Structure (new) - l_attrCountLid = l_targSrv.getTargetAttributes(*l_allTargetsLid, + l_attrCountLid = l_targSrv.getTargetAttributes(l_targetLid, l_attrRPLid, l_pAttrIdLid, l_ppAttrAddrLid); @@ -466,16 +469,35 @@ errlHndl_t saveRestoreAttrs(void *i_rsvdMemPtr, continue; } - l_huidLid = l_allTargetsLid->getAttr(); - l_physPathLid = l_allTargetsLid->getAttr(); + // Get key attributes and trace the information + ATTR_CLASS_type l_classLid = + l_targetLid->getAttr(l_attrRPLid, + l_pAttrIdLid, + l_ppAttrAddrLid); + ATTR_TYPE_type l_typeLid = + l_targetLid->getAttr(l_attrRPLid, + l_pAttrIdLid, + l_ppAttrAddrLid); + ATTR_ORDINAL_ID_type l_ordinalIdLid = + l_targetLid->getAttr(l_attrRPLid, + l_pAttrIdLid, + l_ppAttrAddrLid); + ATTR_HUID_type l_huidLid = + l_targetLid->getAttr(l_attrRPLid, + l_pAttrIdLid, + l_ppAttrAddrLid); + ATTR_PHYS_PATH_type l_physPathLid = + l_targetLid->getAttr(l_attrRPLid, + l_pAttrIdLid, + l_ppAttrAddrLid); TRACFCOMP( g_trac_targeting, "Target %3d has %3d attrs, class %0.8x, type %0.8x, " "ord ID %0.8x, HUID 0x%0.8x, %s", l_targetNum, l_attrCountLid, - l_allTargetsLid->getAttr(), - l_allTargetsLid->getAttr(), - l_allTargetsLid->getAttr(), + l_classLid, + l_typeLid, + l_ordinalIdLid, l_huidLid, l_physPathLid.toString()); @@ -492,11 +514,9 @@ errlHndl_t saveRestoreAttrs(void *i_rsvdMemPtr, l_allTargetsRsvd; ++l_allTargetsRsvd) { - if((l_allTargetsLid->getAttr() == - l_allTargetsRsvd->getAttr()) && - (l_allTargetsLid->getAttr() == - l_allTargetsRsvd->getAttr()) && - (l_allTargetsLid->getAttr() == + if((l_classLid == l_allTargetsRsvd->getAttr()) && + (l_typeLid == l_allTargetsRsvd->getAttr()) && + (l_ordinalIdLid == l_allTargetsRsvd->getAttr()) && (l_physPathLid == l_allTargetsRsvd->getAttr())) @@ -575,11 +595,11 @@ errlHndl_t saveRestoreAttrs(void *i_rsvdMemPtr, { // Get the LID Structure attribute value pointer void* l_pAttrLid = nullptr; - l_allTargetsLid->_getAttrPtr(*l_pAttrId, - l_attrRPLid, - l_pAttrIdLid, - l_ppAttrAddrLid, - l_pAttrLid); + l_targetLid->_getAttrPtr(*l_pAttrId, + l_attrRPLid, + l_pAttrIdLid, + l_ppAttrAddrLid, + l_pAttrLid); // Check if attribute is in LID Structure data if(l_pAttrLid == nullptr) @@ -700,23 +720,31 @@ errlHndl_t saveRestoreAttrs(void *i_rsvdMemPtr, int hbrt_update_prep(void) { errlHndl_t pError = nullptr; - uint64_t l_userdata2 = 0; UtilLidMgr l_lidMgr(Util::TARGETING_BINARY_LIDID); void *l_lidStructPtr = nullptr; void* l_newMem = nullptr; - do + for(NODE_ID l_nodeId = NODE0; + l_nodeId < Singleton::instance().getNodeCount(); + l_nodeId++) { // Get size and location of attributes in reserved memory uint64_t l_attr_size = 0; uint64_t l_rsvdMem = hb_get_rt_rsvd_mem(Util::HBRT_MEM_LABEL_ATTR, - 0, l_attr_size); + l_nodeId, l_attr_size); TRACFCOMP( g_trac_targeting, "l_rsvdMem @ %.16llX for 0x%llX", l_rsvdMem, l_attr_size ); // Set pointer to reserved memory targeting data void *l_rsvdMemPtr = reinterpret_cast(l_rsvdMem); + // Set LID for this node + pError = l_lidMgr.setLidId(Util::TARGETING_BINARY_LIDID + l_nodeId); + if(pError) + { + break; + } + // Create lidMgr and get size of Targeting Binary LID size_t l_lidSize = 0; pError = l_lidMgr.getLidSize(l_lidSize); @@ -734,9 +762,6 @@ int hbrt_update_prep(void) l_lidSize, l_attr_size); - l_userdata2 = TWO_UINT32_TO_UINT64(l_lidSize, - l_attr_size); - break; } @@ -755,8 +780,7 @@ int hbrt_update_prep(void) // Validate LID Structure against Reserved Memory pError = validateData(l_lidStructPtr, l_rsvdMemPtr, - l_lidDataSize, - l_userdata2); + l_lidDataSize); if(pError) { break; @@ -801,7 +825,7 @@ int hbrt_update_prep(void) // new LID Structure data pError = saveRestoreAttrs(l_rsvdMemPtr, l_newMem, - l_userdata2); + l_nodeId); if(pError) { break; @@ -831,7 +855,7 @@ int hbrt_update_prep(void) 0, l_setSize); } - } while(false); + } // Delete the scratch space for the new attributes if( l_newMem ) diff --git a/src/usr/targeting/runtime/test/testtargeting.H b/src/usr/targeting/runtime/test/testtargeting.H index c03f2fd27..fce91f46d 100644 --- a/src/usr/targeting/runtime/test/testtargeting.H +++ b/src/usr/targeting/runtime/test/testtargeting.H @@ -33,6 +33,7 @@ #include #include #include +#include #define MEMCMPPTR(addr, offset) \ reinterpret_cast(reinterpret_cast(addr) + offset) @@ -286,21 +287,280 @@ class TargetingTestSuite : public CxxTest::TestSuite allow_attr_overrides); } - // Test the two internal functions used during HBRT concurrent update. - // The first function validates the LID Structure against the Reserved - // Memory data. The second function saves and restores attribute - // values from current Reserved Memory data into new LID Structure - // data. This testcase uses Reserved Memory data to make its LID - // Structure, so it tests basic logic in the functions, but does not - // test more complex handling of special data conditions. - void _testSaveRestoreAttrs() + // Test internal function used during HBRT concurrent update to validate + // the LID Structure against the Reserved Memory data. This testcase + // uses Reserved Memory data to make its LID Structure, so it tests + // basic logic in the functions, but does not test more complex handling + // of special data conditions. + void testValidateData() + { + using namespace TARGETING; + TRACFCOMP(g_trac_targeting,ENTER_MRK"testValidateData"); + + errlHndl_t l_err = nullptr; + void *l_lidStruct = nullptr; + NODE_ID l_node = NODE0; // Runs on Standalone, so only Node 0 + + do + { + uint64_t l_attr_size = 0; + uint64_t l_rsvdMem = + hb_get_rt_rsvd_mem(Util::HBRT_MEM_LABEL_ATTR, + l_node, + l_attr_size); + void *l_rsvdMemPtr = reinterpret_cast(l_rsvdMem); + + // Access TargetingHeader in current data + TargetingHeader* l_headerRsvd = + reinterpret_cast(l_rsvdMemPtr); + + // Find start to the first section in current data: + // (header address + size of header + offset in header) + TargetingSection* l_sectionRsvd = + reinterpret_cast( + reinterpret_cast(l_headerRsvd) + + sizeof(TargetingHeader) + + l_headerRsvd->offsetToSections); + + // Allocate memory for new LID structure + l_lidStruct = malloc(l_attr_size); + + // Make LID structure from current Reserved Memory data + memcpy(l_lidStruct, + l_rsvdMemPtr, + l_attr_size); + + // Intentionally invalidate the eyecatcher for LID structure + // Then run validateData() to make sure this error is detected + TargetingHeader* l_headerLid = + reinterpret_cast(l_lidStruct); + uint32_t *l_pEyeCatcher = + reinterpret_cast(reinterpret_cast( + &l_headerLid->eyeCatcher)); + *l_pEyeCatcher += 0x20202020; + size_t l_lidDataSize = 0; + l_err = RT_TARG::validateData(l_lidStruct, + l_rsvdMemPtr, + l_lidDataSize); + if(ERRL_GETRC_SAFE(l_err) != TARG_RT_BAD_EYECATCHER_LID) + { + TS_FAIL("testValidateData> unexpected reason code from " + "validateData, expected 0x%.4x, received 0x%.4x", + TARG_RT_BAD_EYECATCHER_LID, + ERRL_GETRC_SAFE(l_err)); + break; + } + else if(l_err && + (l_err->moduleId() != TARG_RT_VALIDATEDATA)) + { + TS_FAIL("testValidateData> unexpected module ID from " + "validateData, expected 0x86, received 0x%.2x", + TARG_RT_VALIDATEDATA, + l_err->moduleId()); + break; + } + else if(l_err && + (l_err->getUserData1() != l_headerLid->eyeCatcher)) + { + TS_FAIL("testValidateData> unexpected user data from " + "validateData, expected 0x%.16llx, rcvd 0x%.16llx", + l_headerLid->eyeCatcher, + l_err->getUserData1()); + break; + } + else + { + *l_pEyeCatcher -= 0x20202020; + } + + // Intentionally invalidate the eyecatcher for Reserved Memory + // Then run validateData() to make sure this error is detected + l_pEyeCatcher = + reinterpret_cast(reinterpret_cast( + &l_headerRsvd->eyeCatcher)); + *l_pEyeCatcher += 0x00202020; + l_err = RT_TARG::validateData(l_lidStruct, + l_rsvdMemPtr, + l_lidDataSize); + if(ERRL_GETRC_SAFE(l_err) != TARG_RT_BAD_EYECATCHER_MEM) + { + TS_FAIL("testValidateData> unexpected reason code from " + "validateData, expected 0x%.4x, received 0x%.4x", + TARG_RT_BAD_EYECATCHER_MEM, + ERRL_GETRC_SAFE(l_err)); + break; + } + else if(l_err && + (l_err->moduleId() != TARG_RT_VALIDATEDATA)) + { + TS_FAIL("testValidateData> unexpected module ID from " + "validateData, expected 0x86, received 0x%.2x", + TARG_RT_VALIDATEDATA, + l_err->moduleId()); + break; + } + else if(l_err && + (l_err->getUserData1() != l_headerRsvd->eyeCatcher)) + { + TS_FAIL("testValidateData> unexpected user data from " + "validateData, expected 0x%.16llx, rcvd 0x%.16llx", + l_headerRsvd->eyeCatcher, + l_err->getUserData1()); + break; + } + else + { + *l_pEyeCatcher -= 0x00202020; + } + + // Intentionally cause mismatch with number of sections + // Then run validateData() to make sure this error is detected + uint32_t *l_pNumSections = + reinterpret_cast(reinterpret_cast( + &l_headerRsvd->numSections)); + *l_pNumSections += 2; + l_err = RT_TARG::validateData(l_lidStruct, + l_rsvdMemPtr, + l_lidDataSize); + if(ERRL_GETRC_SAFE(l_err) != TARG_RT_SECTION_NUM_MISMATCH) + { + TS_FAIL("testValidateData> unexpected reason code from " + "validateData, expected 0x%.4x, received 0x%.4x", + TARG_RT_SECTION_NUM_MISMATCH, + ERRL_GETRC_SAFE(l_err)); + break; + } + else if(l_err && + (l_err->moduleId() != TARG_RT_VALIDATEDATA)) + { + TS_FAIL("testValidateData> unexpected module ID from " + "validateData, expected 0x86, received 0x%.2x", + TARG_RT_VALIDATEDATA, + l_err->moduleId()); + break; + } + else if(l_err && + ((l_err->getUserData1() != l_headerLid->numSections) || + (l_err->getUserData2() != l_headerRsvd->numSections))) + { + TS_FAIL("testValidateData> unexpected user data from " + "validateData, expected 0x%.16llx, rcvd 0x%.16llx, " + "expected 0x%.16llx, rcvd 0x%.16llx", + l_headerLid->numSections, + l_err->getUserData1(), + l_headerRsvd->numSections, + l_err->getUserData2()); + break; + } + else + { + *l_pNumSections -= 2; + } + + // Intentionally cause mismatch with TargetingSection type + // Then run validateData() to make sure this error is detected + TargetingSection* l_sectionLid = + reinterpret_cast( + reinterpret_cast(l_headerLid) + + sizeof(TargetingHeader) + + l_headerLid->offsetToSections); + uint8_t l_sectionType = l_sectionLid[0].sectionType; + uint8_t *l_pSectionType = + reinterpret_cast(reinterpret_cast( + &l_sectionLid[0])); // sectionType is first field + *l_pSectionType = l_sectionType + 0xF0; + uint64_t l_expected = + TWO_UINT32_TO_UINT64(l_sectionLid[0].sectionType, + l_sectionRsvd[0].sectionType); + l_err = RT_TARG::validateData(l_lidStruct, + l_rsvdMemPtr, + l_lidDataSize); + if(ERRL_GETRC_SAFE(l_err) != TARG_RT_SECTION_MISMATCH) + { + TS_FAIL("testValidateData> unexpected reason code from " + "validateData, expected 0x%.4x, received 0x%.4x", + TARG_RT_SECTION_MISMATCH, + ERRL_GETRC_SAFE(l_err)); + break; + } + else if(l_err && + (l_err->moduleId() != TARG_RT_VALIDATEDATA)) + { + TS_FAIL("testValidateData> unexpected module ID from " + "validateData, expected 0x86, received 0x%.2x", + TARG_RT_VALIDATEDATA, + l_err->moduleId()); + break; + } + else if(l_err && + ((l_err->getUserData1() != 0) || + (l_err->getUserData2() != l_expected))) + { + TS_FAIL("testValidateData> unexpected user data from " + "validateData, expected 0, rcvd 0x%.16llx, " + "expected 0x%.16llx, rcvd 0x%.16llx", + l_err->getUserData1(), + l_expected, + l_err->getUserData2()); + break; + } + else + { + *l_pSectionType = l_sectionType; + } + + // Detect TargetingSection size mismatch + uint32_t l_sectionSize = l_sectionRsvd[0].sectionSize; + uint32_t *l_pSectionSize = + reinterpret_cast(reinterpret_cast( + &l_sectionRsvd[0].sectionSize)); + *l_pSectionSize = l_sectionSize + 0x100; + l_err = RT_TARG::validateData(l_lidStruct, + l_rsvdMemPtr, + l_lidDataSize); + if(l_err) + { + TS_FAIL("testValidateData> unexpected error log from " + "validateData, should only trace mismatch"); + break; + } + else + { + *l_pSectionSize = l_sectionSize; + } + + // Validate LID Structure against Reserved Memory + l_err = RT_TARG::validateData(l_lidStruct, + l_rsvdMemPtr, + l_lidDataSize); + if(l_err) + { + TS_FAIL("testValidateData> unexpected error log from " + "validateData"); + break; + } + + TRACFCOMP(g_trac_targeting,"testValidateData SUCCESS"); + } while(false); + + free(l_lidStruct); + l_lidStruct = nullptr; + + TRACFCOMP(g_trac_targeting,EXIT_MRK"testValidateData"); + } + + // Test the internal function used during HBRT concurrent update to save + // and restoresattribute values from current Reserved Memory data into + // new LID Structure data. This testcase uses Reserved Memory data to + // make its LID Structure, so it tests basic logic in the functions, but + // does not test more complex handling of special data conditions. + void testSaveRestoreAttrs() { -#if 0 //@todo-RTC:188625-Turn this back on using namespace TARGETING; TRACFCOMP(g_trac_targeting,ENTER_MRK"testSaveRestoreAttrs"); - int rc = 0; - uint64_t l_userdata2 = 0; + errlHndl_t l_err = nullptr; + NODE_ID l_node = NODE0; // Runs on Standalone, so only Node 0 void *l_lidStruct = nullptr; do @@ -308,7 +568,7 @@ class TargetingTestSuite : public CxxTest::TestSuite uint64_t l_attr_size = 0; uint64_t l_rsvdMem = hb_get_rt_rsvd_mem(Util::HBRT_MEM_LABEL_ATTR, - 0, + l_node, l_attr_size); void *l_rsvdMemPtr = reinterpret_cast(l_rsvdMem); @@ -325,22 +585,13 @@ class TargetingTestSuite : public CxxTest::TestSuite number of sections match, and that the types of each TargetingSection match. */ size_t l_lidDataSize = 0; - rc = RT_TARG::validateData(l_lidStruct, - l_rsvdMemPtr, - l_lidDataSize, - l_userdata2); - if(rc) - { - TS_FAIL("testSaveRestoreAttrs> unexpected return code from " - "validateData, received 0x%.2x", - rc); - break; - } - else if(l_userdata2 != 0) + l_err = RT_TARG::validateData(l_lidStruct, + l_rsvdMemPtr, + l_lidDataSize); + if(l_err) { - TS_FAIL("testSaveRestoreAttrs> unexpected user data from " - "validateData, received 0x%.16llx", - l_userdata2); + TS_FAIL("testSaveRestoreAttrs> unexpected error log from " + "validateData"); break; } @@ -358,21 +609,13 @@ class TargetingTestSuite : public CxxTest::TestSuite into new LID Structure data. Leave attribute values in new LID Structure data as is, if there is no value from current Reserved Memory data. */ - rc = RT_TARG::saveRestoreAttrs(l_rsvdMemPtr, - l_lidStruct, - l_userdata2); - if(rc) - { - TS_FAIL("testSaveRestoreAttrs> unexpected return code from " - "saveRestoreAttrs, received 0x%.2x", - rc); - break; - } - else if(l_userdata2 != 0) + l_err = RT_TARG::saveRestoreAttrs(l_rsvdMemPtr, + l_lidStruct, + l_node); + if(l_err) { - TS_FAIL("testSaveRestoreAttrs> unexpected user data from " - "saveRestoreAttrs, received 0x%.8x", - l_userdata2); + TS_FAIL("testSaveRestoreAttrs> unexpected error log from " + "validateData"); break; } @@ -523,159 +766,6 @@ class TargetingTestSuite : public CxxTest::TestSuite break; } - // Detect invalid LID Structure TargetingHeader eyecatcher - TargetingHeader* l_headerLid = - reinterpret_cast(l_lidStruct); - uint32_t *l_pEyeCatcher = - reinterpret_cast(reinterpret_cast( - &l_headerLid->eyeCatcher)); - *l_pEyeCatcher += 0x20202020; - rc = RT_TARG::validateData(l_lidStruct, - l_rsvdMemPtr, - l_lidDataSize, - l_userdata2); - if(rc != 0x11) - { - TS_FAIL("testSaveRestoreAttrs> unexpected return code from " - "validateData, expected 0x11, received 0x%.2x", - rc); - break; - } - else if(l_userdata2 != l_headerLid->eyeCatcher) - { - TS_FAIL("testSaveRestoreAttrs> unexpected user data from " - "validateData, expected 0x%.16llx, rcvd 0x%.16llx", - l_headerLid->eyeCatcher, - l_userdata2); - break; - } - else - { - *l_pEyeCatcher -= 0x20202020; - l_userdata2 = 0; - } - - // Detect invalid Reserved Memory TargetingHeader eyecatcher - l_pEyeCatcher = - reinterpret_cast(reinterpret_cast( - &l_headerRsvd->eyeCatcher)); - *l_pEyeCatcher += 0x00202020; - rc = RT_TARG::validateData(l_lidStruct, - l_rsvdMemPtr, - l_lidDataSize, - l_userdata2); - if(rc != 0x12) - { - TS_FAIL("testSaveRestoreAttrs> unexpected return code from " - "validateData, expected 0x12, received 0x%.2x", - rc); - break; - } - else if(l_userdata2 != l_headerRsvd->eyeCatcher) - { - TS_FAIL("testSaveRestoreAttrs> unexpected user data from " - "validateData, expected 0x%.16llx, rcvd 0x%.16llx", - l_headerRsvd->eyeCatcher, - l_userdata2); - break; - } - else - { - *l_pEyeCatcher -= 0x00202020; - l_userdata2 = 0; - } - - // Detect TargetingHeader number of sections mismatch - uint32_t *l_pNumSections = - reinterpret_cast(reinterpret_cast( - &l_headerRsvd->numSections)); - *l_pNumSections += 2; - uint64_t l_expected = - TWO_UINT32_TO_UINT64(l_headerLid->numSections, - l_headerRsvd->numSections); - rc = RT_TARG::validateData(l_lidStruct, - l_rsvdMemPtr, - l_lidDataSize, - l_userdata2); - if(rc != 0x13) - { - TS_FAIL("testSaveRestoreAttrs> unexpected return code from " - "validateData, expected 0x13, received 0x%.2x", - rc); - break; - } - else if(l_userdata2 != l_expected) - { - TS_FAIL("testSaveRestoreAttrs> unexpected user data from " - "validateData, expected 0x%.16llx, rcvd 0x%.16llx", - l_expected, - l_userdata2); - break; - } - else - { - *l_pNumSections -= 2; - l_userdata2 = 0; - } - - // Detect TargetingSection type mismatch - TargetingSection* l_sectionLid = - reinterpret_cast( - reinterpret_cast(l_headerLid) + - sizeof(TargetingHeader) + - l_headerLid->offsetToSections); - uint8_t l_sectionType = l_sectionLid[0].sectionType; - uint8_t *l_pSectionType = - reinterpret_cast(reinterpret_cast( - &l_sectionLid[0])); // sectionType is first field - *l_pSectionType = l_sectionType + 0xF0; - l_expected = - TWO_UINT32_TO_UINT64(l_sectionLid[0].sectionType, - l_sectionRsvd[0].sectionType); - rc = RT_TARG::validateData(l_lidStruct, - l_rsvdMemPtr, - l_lidDataSize, - l_userdata2); - if(rc != 0x14) - { - TS_FAIL("testSaveRestoreAttrs> unexpected return code from " - "validateData, expected 0x14, received 0x%.2x", - rc); - break; - } - else if(l_userdata2 != l_expected) - { - TS_FAIL("testSaveRestoreAttrs> unexpected user data from " - "validateData, expected 0x%.16llx, rcvd 0x%.16llx", - l_expected, - l_userdata2); - break; - } - else - { - *l_pSectionType = l_sectionType; - l_userdata2 = 0; - } - - // Validate LID Structure against Reserved Memory - rc = RT_TARG::validateData(l_lidStruct, - l_rsvdMemPtr, - l_lidDataSize, - l_userdata2); - if(rc) - { - TS_FAIL("testSaveRestoreAttrs> unexpected return code from " - "validateData, received 0x%.2x", - rc); - break; - } - else if(l_userdata2 != 0) - { - TS_FAIL("testSaveRestoreAttrs> unexpected user data from " - "validateData, received 0x%.16llx", - l_userdata2); - break; - } TRACFCOMP(g_trac_targeting,"testSaveRestoreAttrs SUCCESS"); } while(false); @@ -684,7 +774,6 @@ class TargetingTestSuite : public CxxTest::TestSuite l_lidStruct = nullptr; TRACFCOMP(g_trac_targeting,EXIT_MRK"testSaveRestoreAttrs"); -#endif } }; -- cgit v1.2.1