diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/include/usr/runtime/rt_targeting.H | 26 | ||||
| -rw-r--r-- | src/include/usr/targeting/attrrp.H | 47 | ||||
| -rw-r--r-- | src/include/usr/targeting/attrsync.H | 45 | ||||
| -rw-r--r-- | src/include/usr/targeting/common/target.H | 30 | ||||
| -rw-r--r-- | src/include/usr/targeting/common/targetservice.H | 69 | ||||
| -rw-r--r-- | src/include/usr/targeting/common/targreasoncodes.H | 1 | ||||
| -rw-r--r-- | src/include/usr/util/utillidmgr.H | 1 | ||||
| -rwxr-xr-x | src/usr/targeting/attrrp_common.C | 10 | ||||
| -rw-r--r-- | src/usr/targeting/attrsync.C | 19 | ||||
| -rw-r--r-- | src/usr/targeting/common/target.C | 44 | ||||
| -rw-r--r-- | src/usr/targeting/common/targetservice.C | 125 | ||||
| -rwxr-xr-x | src/usr/targeting/common/xmltohb/xmltohb.pl | 53 | ||||
| -rw-r--r-- | src/usr/targeting/runtime/attrrp_rt.C | 94 | ||||
| -rw-r--r-- | src/usr/targeting/runtime/makefile | 1 | ||||
| -rw-r--r-- | src/usr/targeting/runtime/rt_targeting.C | 532 | ||||
| -rw-r--r-- | src/usr/util/runtime/utillidmgr_rt.C | 8 |
16 files changed, 1075 insertions, 30 deletions
diff --git a/src/include/usr/runtime/rt_targeting.H b/src/include/usr/runtime/rt_targeting.H index 5895c9fad..a8e01c20b 100644 --- a/src/include/usr/runtime/rt_targeting.H +++ b/src/include/usr/runtime/rt_targeting.H @@ -5,7 +5,7 @@ /* */ /* OpenPOWER HostBoot Project */ /* */ -/* Contributors Listed Below - COPYRIGHT 2014,2016 */ +/* Contributors Listed Below - COPYRIGHT 2014,2017 */ /* [+] International Business Machines Corp. */ /* */ /* */ @@ -54,7 +54,7 @@ namespace RT_TARG rtChipId_t &o_targetId); /** - * @brier Convert a runtime chip_id (target) into a TARGETING::Target + * @brief Convert a runtime chip_id (target) into a TARGETING::Target * @param[in] The rt chipId * @param[out] The TARGETING::Target pointer * @return error log handle on error else NULL @@ -63,6 +63,28 @@ namespace RT_TARG TARGETING::Target *& o_target); /** + * @brief Save/Restore attribute values from current Reserved Memory data + * 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 + * @return 0 on success, else return code + */ + int saveRestoreAttrs(void *i_rsvdMemPtr, + void *io_lidStructPtr); + + /** + * @brief Validate LID Structure against Reserved Memory. Check that the + * TargetingHeader eyecatchers are valid, that the TargetingHeader number of + * sections match, and that the types and sizes of each TargetingSection + * match. + * @param[in] Pointer to new LID Structure targeting binary data + * @param[in] Pointer to current Reserved Memory targeting binary data + * @return 0 on success, else return code + */ + int validateData(void *i_lidStructPtr, + void *i_rsvdMemPtr); + + /** * @brief Apply ATTR_TMP overrides to be available for run time */ void applyTempOverrides( ); diff --git a/src/include/usr/targeting/attrrp.H b/src/include/usr/targeting/attrrp.H index 02772cb6d..1d5698d74 100644 --- a/src/include/usr/targeting/attrrp.H +++ b/src/include/usr/targeting/attrrp.H @@ -40,7 +40,6 @@ #include <sys/msg.h> #include <targeting/adapters/types.H> #include <targeting/common/targetservice.H> -#include <targeting/attrsync.H> #include <targeting/common/attributeTank.H> namespace TARGETING @@ -73,6 +72,11 @@ class AttrRP const SECTION_TYPE i_sectionId, const TARGETING::NODE_ID i_nodeId); +#ifdef __HOSTBOOT_RUNTIME + friend int RT_TARG::saveRestoreAttrs(void *, + void *); +#endif + public: /** @@ -216,6 +220,16 @@ class AttrRP static errlHndl_t saveOverrides( uint8_t* i_dest, size_t& io_size ); +#else + /** + * @brief Fill in new attribute resource provider for HBRT. + * + * @param[in] i_header + * TargetingHeader to use with filling in the new RT AttrRP. + * + * @return void + */ + void fillInAttrRP(TargetingHeader* i_header); #endif protected: @@ -228,22 +242,40 @@ class AttrRP */ AttrRP() #ifndef __HOSTBOOT_RUNTIME - : iv_msgQ(NULL), iv_sections(NULL), iv_sectionCount(0), iv_isMpipl(false) + : iv_msgQ(NULL), iv_sections(NULL), iv_sectionCount(0), + iv_isMpipl(false) #else - : iv_sections(NULL), iv_sectionCount(0), iv_isMpipl(false) + : iv_isTempInstance(false), iv_sections(NULL), iv_sectionCount(0), + iv_isMpipl(false) #endif { }; +#ifdef __HOSTBOOT_RUNTIME + /** + * @brief Initialize temporary attribute resource provider + * + * @par Detailed Description" + * Ensures member variables are initialized to sane values. + */ + AttrRP(TargetingHeader* i_header) + : iv_isTempInstance(true), iv_isMpipl(false) + { + // Fill in member variables + fillInAttrRP(i_header); + }; +#endif + /** * @brief Destroy the attribute resource provider * * @par Detailed Description: * Frees any memory allocated by the resource provider. * - * @note This should never actually be used because the daemon - * thread and the vmm blocks are unable to be reclaimed. - * Function will assert if called due to leaky behavior. + * @note This should never actually be used for the singleton + * instance because the daemon thread and the vmm blocks + * are unable to be reclaimed. Function will assert if + * called due to leaky behavior. */ ~AttrRP(); @@ -388,6 +420,9 @@ class AttrRP // Message Queue for VMM requests msg_q_t iv_msgQ; +#else + // Indicator that AttrRP instance is a temporary one, not the singleton + bool iv_isTempInstance; #endif // Parsed structures of the attribute sections. AttrRP_Section* iv_sections; diff --git a/src/include/usr/targeting/attrsync.H b/src/include/usr/targeting/attrsync.H index b8c52fe7e..598292546 100644 --- a/src/include/usr/targeting/attrsync.H +++ b/src/include/usr/targeting/attrsync.H @@ -5,7 +5,7 @@ /* */ /* OpenPOWER HostBoot Project */ /* */ -/* Contributors Listed Below - COPYRIGHT 2012,2016 */ +/* Contributors Listed Below - COPYRIGHT 2012,2017 */ /* [+] International Business Machines Corp. */ /* */ /* */ @@ -43,6 +43,7 @@ #include <stddef.h> #include <targeting/common/targetservice.H> #include <targeting/common/attrsyncdefs.H> +#include <targeting/attrrp.H> namespace TARGETING @@ -79,6 +80,7 @@ namespace TARGETING */ ~AttributeSync(); +#ifndef __HOSTBOOT_RUNTIME /** * @brief Setup the internal variables to point to the correct * attribute section. @@ -86,8 +88,8 @@ namespace TARGETING * @par Detailed Description: * This function will call into the AttRP:: to have the * correct attribute section paged into accessible memory. - * this function may be called multiple times with different - * section names. + * this function may be called multiple times with + * different section names. * * @pre None: * @@ -107,6 +109,36 @@ namespace TARGETING errlHndl_t syncSectionToFsp( TARGETING::SECTION_TYPE i_section_to_sync ); +#else + /** + * @brief Setup the internal variables to point to the correct + * attribute section. + * + * @par Detailed Description: + * This function will call into the AttRP:: to have the + * correct attribute section paged into accessible memory. + * This function may be called multiple times with + * different section names. + * + * @pre None: + * + * @post The entire section from the HB attribute section + * passed in has been synchronized to new AttrRP. + * + * @param[in] i_section_to_sync + * TARGETING::SECTION_TYPE is passed in to + * identify the section to be synced to the + * new AttrRP. + * + * @return std::vector <TARGETING::sectionRefData> with + * attribute section pages. + * + */ + std::vector <TARGETING::sectionRefData> syncSectionFromAttrRP( + TARGETING::SECTION_TYPE i_section_to_sync); +#endif + +#ifndef __HOSTBOOT_RUNTIME /** * @brief Sends a request to the FSP to sync its data to Hostboot * for a specific attribute section. Write the data @@ -138,9 +170,11 @@ namespace TARGETING errlHndl_t syncSectionFromFsp( TARGETING::SECTION_TYPE i_section_to_sync, msg_q_t i_pMsgQ ); +#endif private: +#ifndef __HOSTBOOT_RUNTIME /** * @enum TARGETING::MBOX_MSG_TYPE * @@ -153,6 +187,7 @@ namespace TARGETING ASYNCHRONOUS, SYNCHRONOUS }; +#endif /** * @brief Setup the internal variables to point to the correct @@ -165,6 +200,7 @@ namespace TARGETING */ void getSectionData(); +#ifndef __HOSTBOOT_RUNTIME /** * @brief Write the attribute data received from the FSP to * the attribute section. @@ -226,6 +262,7 @@ namespace TARGETING * return errl != NULL -> failure */ errlHndl_t sendSyncToHBRequestMessage(); +#endif private: @@ -247,6 +284,7 @@ namespace TARGETING }; +#ifndef __HOSTBOOT_RUNTIME /** * @brief Handles synchronization of all RW targeting attributes from * hostboot to the fsp; the following sections are @@ -278,6 +316,7 @@ namespace TARGETING * return errl != NULL -> failure */ errlHndl_t syncAllAttributesFromFsp(); +#endif diff --git a/src/include/usr/targeting/common/target.H b/src/include/usr/targeting/common/target.H index 9e1c23b85..6d7a0dafd 100644 --- a/src/include/usr/targeting/common/target.H +++ b/src/include/usr/targeting/common/target.H @@ -58,6 +58,8 @@ namespace RT_TARG { void adjustTargeting4Runtime(); + int saveRestoreAttrs(void *i_rsvdMemPtr, + void *io_lidStructPtr); } #endif @@ -98,6 +100,7 @@ namespace TARGETING // Type Aliases //****************************************************************************** class AttributeTank; +class AttrRP; class Target; typedef const Target* ConstTargetHandle_t; typedef Target* TargetHandle_t; @@ -480,6 +483,31 @@ class Target void*& o_pAttr) const; /** + * @brief Gets a pointer to the target's associated attribute + * + * Gets a pointer to the target's associated attribute + * + * @param[in] i_attr Attribute to retrieve + * @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[out] o_pAttr Pointer to data location to hold the attribute + * data + * + * @pre Target service must be initialized + * + * @post If attribute exists for the associated target, caller's + * pointer updated with associated attribute pointer. Otherwise, + * caller's pointer updated to NULL. + */ + void _getAttrPtr( + ATTRIBUTE_ID i_attr, + AttrRP* i_attrRP, + ATTRIBUTE_ID* i_pAttrId, + AbstractPointer<void>* i_ppAttrAddr, + void*& o_pAttr) const; + + /** * @brief Returns pointer to a mutex attribute associated with the * target * @@ -632,6 +660,8 @@ class Target #ifdef __HOSTBOOT_RUNTIME friend void RT_TARG::adjustTargeting4Runtime(); + friend int RT_TARG::saveRestoreAttrs(void *, + void *); #endif diff --git a/src/include/usr/targeting/common/targetservice.H b/src/include/usr/targeting/common/targetservice.H index 5eae01fc7..f1126bf21 100644 --- a/src/include/usr/targeting/common/targetservice.H +++ b/src/include/usr/targeting/common/targetservice.H @@ -63,6 +63,9 @@ namespace TARGETING { + // Forward declaration of attribute resource provider class. + class AttrRP; + class TargetService; /* @@ -710,6 +713,60 @@ class TargetService */ void getMasterNodeTarget(Target*& o_masterNodeTarget) const; + /** + * @brief Returns Target Range Filter information. + * + * @par Detailed Description: + * Returns the Target Range Filter information for the specified + * attribute data and resource provider. + * + * @param[in] i_attrData pointer to attribute data + * + * @param[in] i_attrRP pointer to attribute resource provider + * + * @param[out] o_maxTargets maximum targets in the range + * + * @param[in] i_nodeId, node ID for the target. Defaults to 0. + * + * @pre TargetService must be initialized. + * + * @post Returns the Target Range Filter information for the specified + * attribute data and resource provider. + * + * @return TargetRangeFilter + */ + TargetRangeFilter getTargetRangeFilter(void *i_attrData, + AttrRP *i_attrRP, + uint32_t &o_maxTargets, + NODE_ID i_nodeId = 0); + + /** + * @brief Returns Target Attribute information. + * + * @par Detailed Description: + * Returns the Target Attribute information for the specified + * target and resource provider. + * + * @param[in] i_target pointer to target + * + * @param[in] i_attrRP pointer to attribute resource provider + * + * @param[out] o_pAttrId pointer to array of attribute IDs + * + * @param[out] o_ppAttrAddr pointer to array of attribute addresses + * + * @pre TargetService must be initialized. + * + * @post Returns the Target Attribute information for the specified + * target and resource provider. + * + * @return Number of attributes in the arrays + */ + uint32_t getTargetAttributes(Target*i_target, + AttrRP *i_attrRP, + ATTRIBUTE_ID* &o_pAttrId, + AbstractPointer<void>* &o_ppAttrAddr); + private: @@ -768,11 +825,15 @@ class TargetService * specific information of the type NodeSpecificInfo. May refer to * structure definition * + * @param[in] i_attrRP, attribute resource provider to use if address + * translation is required. Defaults to NULL, ie, AttrRP Singleton. + * * @pre Target service must not be initialized * * @post Target service target pool configured for access */ - void _configureTargetPool(NodeSpecificInfo& i_nodeInfoContainer); + void _configureTargetPool(NodeSpecificInfo& i_nodeInfoContainer, + AttrRP *i_attrRP = NULL); /** * @brief Computes the maximum number of targets, caches the value @@ -785,13 +846,17 @@ class TargetService * specific information of the type NodeSpecificInfo. May refer to * structure definition * + * @param[in] i_attrRP, attribute resource provider to use if address + * translation is required. Defaults to NULL, ie, AttrRP Singleton. + * * @pre Target service must not already be initialized * * @post Target service updated with maximum target count in * nodeContainer. * */ - void _maxTargets(NodeSpecificInfo & io_nodeInfoContainer); + void _maxTargets(NodeSpecificInfo & io_nodeInfoContainer, + AttrRP *i_attrRP = NULL); //@NEBA diff --git a/src/include/usr/targeting/common/targreasoncodes.H b/src/include/usr/targeting/common/targreasoncodes.H index 92d9611c4..1c0fb4c8c 100644 --- a/src/include/usr/targeting/common/targreasoncodes.H +++ b/src/include/usr/targeting/common/targreasoncodes.H @@ -50,6 +50,7 @@ enum TargetingModuleId TARG_APPLY_ATTR_OVER = 0x0A, TARG_HANDLE_ENUM_CHECK_FAILURE = 0x0B, TARG_HANDLE_RANGE_CHECK_FAILURE = 0x0C, + TARG_RT_SAVE_RESTORE_ATTRS = 0x0D, }; enum TargetingReasonCode diff --git a/src/include/usr/util/utillidmgr.H b/src/include/usr/util/utillidmgr.H index a80f67876..9b2b349f3 100644 --- a/src/include/usr/util/utillidmgr.H +++ b/src/include/usr/util/utillidmgr.H @@ -59,6 +59,7 @@ enum LidId CUMULUS_HCODE_LIDID = 0x81e00603, HCODE_CONTAINER_LIDID = 0x80d0000c, HWREFIMG_RINGOVD_LIDID = 0x81e00620, + TARGETING_BINARY_LIDID = 0x81e00630, INVALID_LIDID = 0xFFFFFFFF }; diff --git a/src/usr/targeting/attrrp_common.C b/src/usr/targeting/attrrp_common.C index 4406182a3..693d421a3 100755 --- a/src/usr/targeting/attrrp_common.C +++ b/src/usr/targeting/attrrp_common.C @@ -5,7 +5,7 @@ /* */ /* OpenPOWER HostBoot Project */ /* */ -/* Contributors Listed Below - COPYRIGHT 2013,2016 */ +/* Contributors Listed Below - COPYRIGHT 2013,2017 */ /* [+] International Business Machines Corp. */ /* */ /* */ @@ -56,9 +56,15 @@ namespace TARGETING } #ifndef __HOSTBOOT_RUNTIME msg_q_destroy(iv_msgQ); + TARG_ASSERT(false, "Assert to exit ~AttrRP"); +#else + // Only assert if this in not a temporary AttrRP instance + if (!iv_isTempInstance) + { + TARG_ASSERT(false, "Assert to exit ~AttrRP"); + } #endif - TARG_ASSERT(false, "Assert to exit ~AttrRP"); } void AttrRP::init(errlHndl_t &io_taskRetErrl, bool i_isMpipl) diff --git a/src/usr/targeting/attrsync.C b/src/usr/targeting/attrsync.C index 4201776be..b184e9abe 100644 --- a/src/usr/targeting/attrsync.C +++ b/src/usr/targeting/attrsync.C @@ -61,6 +61,7 @@ namespace TARGETING } +#ifndef __HOSTBOOT_RUNTIME ATTR_SYNC_RC AttributeSync::updateSectionData() const { TARG_INF( ENTER_MRK "AttributeSync::updateSectionData - " @@ -90,6 +91,23 @@ namespace TARGETING return l_rc; } +#else + std::vector<TARGETING::sectionRefData> AttributeSync::syncSectionFromAttrRP( + TARGETING::SECTION_TYPE i_section_to_sync) + { + iv_section_to_sync = i_section_to_sync; + + do + { + // set up the pointers to the data area + getSectionData(); + } while(0); + + return iv_pages; + } +#endif + +#ifndef __HOSTBOOT_RUNTIME errlHndl_t AttributeSync::syncSectionToFsp( TARGETING::SECTION_TYPE i_section_to_sync ) { @@ -625,6 +643,7 @@ namespace TARGETING TARG_INF( EXIT_MRK "syncAllAttributesFromFsp" ); return l_errl; } +#endif }; // end namespace diff --git a/src/usr/targeting/common/target.C b/src/usr/targeting/common/target.C index 49e94e820..b48827187 100644 --- a/src/usr/targeting/common/target.C +++ b/src/usr/targeting/common/target.C @@ -276,6 +276,50 @@ void Target::_getAttrPtr( } //****************************************************************************** +// Target::_getAttrPtr +//****************************************************************************** + +void Target::_getAttrPtr( + ATTRIBUTE_ID i_attr, + AttrRP* i_attrRP, + ATTRIBUTE_ID* i_pAttrId, + AbstractPointer<void>* i_ppAttrAddr, + void*& o_pAttr) const +{ + + #define TARG_FN "_getAttrPtr()" + + void* l_pAttr = NULL; + + // Search for the attribute ID. + ATTRIBUTE_ID* ptr = std::lower_bound(i_pAttrId, + i_pAttrId + iv_attrs, + i_attr); + if ((ptr != i_pAttrId + iv_attrs) && (*ptr == i_attr)) + { + // Locate the corresponding attribute address + l_pAttr = + TARG_TO_PLAT_PTR(*(i_ppAttrAddr + std::distance(i_pAttrId, ptr))); + + // Only translate addresses on platforms where addresses are + // 4 byte wide (FSP). The compiler should perform dead code + // elimination 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_pAttr = + i_attrRP->translateAddr(l_pAttr, + static_cast<const Target*>(this)); + } + } + + o_pAttr = l_pAttr; + + #undef TARG_FN +} + +//****************************************************************************** // Target::_getHbMutexAttr //****************************************************************************** diff --git a/src/usr/targeting/common/targetservice.C b/src/usr/targeting/common/targetservice.C index b47b4a6b7..917bd5258 100644 --- a/src/usr/targeting/common/targetservice.C +++ b/src/usr/targeting/common/targetservice.C @@ -5,7 +5,7 @@ /* */ /* OpenPOWER HostBoot Project */ /* */ -/* Contributors Listed Below - COPYRIGHT 2012,2016 */ +/* Contributors Listed Below - COPYRIGHT 2012,2017 */ /* [+] International Business Machines Corp. */ /* */ /* */ @@ -1085,12 +1085,16 @@ void TargetService::readSectionData( //****************************************************************************** void TargetService::_configureTargetPool( - NodeSpecificInfo& i_nodeInfoContainer) + NodeSpecificInfo& i_nodeInfoContainer, + AttrRP *i_attrRP) { #define TARG_FN "_configureTargetPool(...)" TARG_ENTER(); + AttrRP *l_attrRP = (i_attrRP == NULL) + ? &TARG_GET_SINGLETON(TARGETING::theAttrRP) : i_attrRP; + _maxTargets(i_nodeInfoContainer); // iv_pPnor--> points to uint32_t* --> points to --> uint32_t, targets[] @@ -1114,7 +1118,7 @@ void TargetService::_configureTargetPool( if(TARG_ADDR_TRANSLATION_REQUIRED) { i_nodeInfoContainer.targets = static_cast<Target(*)[]>( - TARG_GET_SINGLETON(TARGETING::theAttrRP).translateAddr( + l_attrRP->translateAddr( i_nodeInfoContainer.targets, i_nodeInfoContainer.nodeId)); TARG_ASSERT(i_nodeInfoContainer.targets, TARG_ERR_LOC "FATAL: Could not determine location of targets after " @@ -1132,10 +1136,14 @@ void TargetService::_configureTargetPool( // TargetService::_maxTargets //****************************************************************************** -void TargetService::_maxTargets(NodeSpecificInfo& io_nodeInfoContainer) +void TargetService::_maxTargets(NodeSpecificInfo& io_nodeInfoContainer, + AttrRP *i_attrRP) { #define TARG_FN "_maxTargets(...)" + AttrRP *l_attrRP = (i_attrRP == NULL) + ? &TARG_GET_SINGLETON(TARGETING::theAttrRP) : i_attrRP; + // Target count found by following the pointer pointed to by the iv_pPnor // pointer. const AbstractPointer<uint32_t>* pNumTargetsPtr @@ -1149,8 +1157,8 @@ void TargetService::_maxTargets(NodeSpecificInfo& io_nodeInfoContainer) // can be statically computed at compile time. if(TARG_ADDR_TRANSLATION_REQUIRED) { - pNumTargets = static_cast<uint32_t*>( - TARG_GET_SINGLETON(TARGETING::theAttrRP).translateAddr( + pNumTargets = + static_cast<uint32_t*>(l_attrRP->translateAddr( pNumTargets, io_nodeInfoContainer.nodeId)); } @@ -1393,6 +1401,111 @@ void TargetService::getMasterNodeTarget( #undef TARG_FN } +//****************************************************************************** +// TargetService::getTargetRangeFilter +//****************************************************************************** + +TargetRangeFilter TargetService::getTargetRangeFilter(void *i_attrData, + AttrRP *i_attrRP, + uint32_t &o_maxTargets, + NODE_ID i_nodeId) +{ + #define TARG_FN "getTargetRangeFilter(...)" + TARG_ENTER(); + + // Get pointer to TargetingHeader for attribute data + TargetingHeader* l_header = + reinterpret_cast<TargetingHeader*>(i_attrData); + + // Verify TargetingHeader + TARG_ASSERT(l_header != NULL, TARG_ERR_LOC + "TargetingHeader for attribute data is NULL"); + TARG_ASSERT(l_header->eyeCatcher == PNOR_TARG_EYE_CATCHER, TARG_ERR_LOC + "TargetingHeader eyecatcher 0x%16llX is incorrect", + l_header->eyeCatcher) + + // Create node info + TargetService::NodeSpecificInfo l_nodeSpecificInfo; + l_nodeSpecificInfo.nodeId = i_nodeId; + + // Save away the address of the targeting data in pPnor field + l_nodeSpecificInfo.pPnor = + reinterpret_cast<uint32_t*>(reinterpret_cast<char*>(l_header) + + l_header->headerSize); + + (void)TargetService::_configureTargetPool(l_nodeSpecificInfo, + i_attrRP); + + l_nodeSpecificInfo.initialized = true; + + // 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)); + + // Create TargetRangeFilter for attribute data + TargetRangeFilter l_rangeFilter(TargetIterator(l_pFirstTarget), + TargetIterator(NULL), + NULL); + + // Set maximum target value to be returned + o_maxTargets = l_nodeSpecificInfo.maxTargets; + + TARG_EXIT(); + #undef TARG_FN + + return l_rangeFilter; +} + +//****************************************************************************** +// TargetService::getTargetAttributes +//****************************************************************************** + +uint32_t TargetService::getTargetAttributes(Target*i_target, + AttrRP *i_attrRP, + ATTRIBUTE_ID* &o_pAttrId, + AbstractPointer<void>* + &o_ppAttrAddr) +{ + #define TARG_FN "getTargetAttributes(...)" + // TARG_ENTER(); + + // Transform platform neutral pointers into platform specific pointers, and + // optimize processing by not having to do the conversion in the loop below + // (it's guaranteed that attribute metadata will be in the same contiguous + // VMM region) + o_pAttrId = TARG_TO_PLAT_PTR(i_target->iv_pAttrNames); + o_ppAttrAddr = TARG_TO_PLAT_PTR(i_target->iv_pAttrValues); + TARG_DBG("o_pAttrId before translation = %p, " + "o_ppAttrAddr before translation = %p", + o_pAttrId, + o_ppAttrAddr); + + // 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) + { + o_pAttrId = static_cast<ATTRIBUTE_ID*>( + i_attrRP->translateAddr(o_pAttrId, i_target)); + o_ppAttrAddr = static_cast<AbstractPointer<void>*>( + i_attrRP->translateAddr(o_ppAttrAddr, i_target)); + TARG_DBG("o_pAttrId after translation = %p, " + "o_ppAttrAddr after translation = %p", + o_pAttrId, + o_ppAttrAddr); + } + + // TARG_EXIT(); + #undef TARG_FN + + // Return the number of attributes for this target + return i_target->iv_attrs; +} + #undef TARG_CLASS #undef TARG_NAMESPACE diff --git a/src/usr/targeting/common/xmltohb/xmltohb.pl b/src/usr/targeting/common/xmltohb/xmltohb.pl index fc45c0280..fc1392e5f 100755 --- a/src/usr/targeting/common/xmltohb/xmltohb.pl +++ b/src/usr/targeting/common/xmltohb/xmltohb.pl @@ -2325,6 +2325,7 @@ sub writeTraitFileTraits { my($attributes,$outFile) = @_; my $typedefs = ""; + my $sizefunc = ""; my %attrValHash; @@ -2450,14 +2451,14 @@ sub writeTraitFileTraits { print $outFile "};\n\n"; $typedefs .= "// Type aliases and/or sizes for ATTR_" - . "$attribute->{id} attribute\n"; + . "$attribute->{id} attribute\n"; $typedefs .= "typedef " . $type . - " $attribute->{id}" . "_ATTR" . $dimensions . ";\n"; + " $attribute->{id}" . "_ATTR" . $dimensions . ";\n"; # Append a more friendly type alias for attribute $typedefs .= "typedef " . $type . - " ATTR_" . "$attribute->{id}" . "_type" . $dimensions . ";\n"; + " ATTR_" . "$attribute->{id}" . "_type" . $dimensions . ";\n"; # If a string, append max # of characters for the string if( (exists $attribute->{simpleType}) @@ -2465,11 +2466,21 @@ sub writeTraitFileTraits { { my $size = $attribute->{simpleType}->{string}->{sizeInclNull}-1; $typedefs .= "const size_t ATTR_" - . "$attribute->{id}" . "_max_chars = " - . "$size" - . ";\n"; + . "$attribute->{id}" . "_max_chars = " + . "$size" + . ";\n"; } $typedefs .= "\n"; + + # Create case definitions for attrSizeLookup function + + $sizefunc .= " // Get size for ATTR_$attribute->{id}" . + " attribute\n"; + $sizefunc .= " case ATTR_$attribute->{id}:\n"; + $sizefunc .= " l_attrSize = sizeof(ATTR_" . + "$attribute->{id}_type);\n"; + $sizefunc .= " break;\n"; + $sizefunc .= "\n"; } }; @@ -2477,6 +2488,36 @@ sub writeTraitFileTraits { print $outFile wrapBrief("Mapping of alias type name to underlying type"); print $outFile " */\n"; print $outFile $typedefs ."\n"; + + # Create attrSizeLookup function + + print $outFile <<VERBATIM; +/** + * \@brief Function to return size of specified attribute + * + * \@param[in] i_attrId Attribute ID for attribute to look up size + * \@return uint32_t Size of the attribute + * + * \@retval Size of the attribute if succeeded + * \@retval 0 if failed + * + */ +inline uint32_t attrSizeLookup(ATTRIBUTE_ID i_attrId) +{ + uint32_t l_attrSize = 0; + + switch(i_attrId) { +VERBATIM + print $outFile $sizefunc; + print $outFile <<VERBATIM; + default: + break; + } + + return l_attrSize; +} + +VERBATIM } ################################################################################ diff --git a/src/usr/targeting/runtime/attrrp_rt.C b/src/usr/targeting/runtime/attrrp_rt.C index 7262c0f5a..f0557fd64 100644 --- a/src/usr/targeting/runtime/attrrp_rt.C +++ b/src/usr/targeting/runtime/attrrp_rt.C @@ -29,6 +29,7 @@ #include <errl/errlentry.H> #include <targeting/common/targreasoncodes.H> #include <targeting/targplatreasoncodes.H> +#include <targeting/attrsync.H> #include <util/runtime/util_rt.H> #include "../attrrp_common.C" @@ -37,6 +38,98 @@ using namespace ERRORLOG; namespace TARGETING { + void AttrRP::fillInAttrRP(TargetingHeader* i_header) + { + TRACFCOMP(g_trac_targeting, ENTER_MRK"AttrRP::fillInAttrRP"); + + do + { + // Create AttributeSync + AttributeSync l_attributeSync = AttributeSync(); + + // 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<TargetingSection*>( + reinterpret_cast<uint64_t>(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<uint64_t>( + TARG_TO_PLAT_PTR(i_header->vmmBaseAddress)) + + i_header->vmmSectionOffset*i; + iv_sections[i].pnorAddress = + reinterpret_cast<uint64_t>(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); + } + + for (size_t i = 0; i < iv_sectionCount; ++i) + { + // get section data from current AttrRP + std::vector <TARGETING::sectionRefData>l_pages; + l_pages = + l_attributeSync.syncSectionFromAttrRP(iv_sections[i].type); + + // write section data to new AttrRP + uint8_t * l_dataPtr = nullptr; // ptr to Attribute address space + bool l_rc = true; // true if write is successful + + // for each page + for(std::vector<TARGETING::sectionRefData>::const_iterator + pageIter = l_pages.begin(); + (pageIter != l_pages.end()) && (true == l_rc); + ++pageIter) + { + // check that page number is within range + uint64_t l_pageOffset = (*pageIter).pageNumber * PAGESIZE; + if ( iv_sections[i].size < (l_pageOffset + PAGESIZE) ) + { + TARG_ERR("page offset 0x%lx is greater than " + "size 0x%lx of section %u", + l_pageOffset, + iv_sections[i].size, + iv_sections[i].type); + + l_rc = false; + break; + } + + // adjust the pointer out by page size * page number + l_dataPtr = + reinterpret_cast<uint8_t *>(iv_sections[i].pnorAddress) + + l_pageOffset; + + memcpy( l_dataPtr, (*pageIter).dataPtr, PAGESIZE ); + + } + } + } 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"); @@ -49,6 +142,7 @@ namespace TARGETING reinterpret_cast<TargetingHeader*>( hb_get_rt_rsvd_mem(Util::HBRT_MEM_LABEL_ATTR,0,attr_size)); + if ((NULL == l_header) || (l_header->eyeCatcher != PNOR_TARG_EYE_CATCHER)) { diff --git a/src/usr/targeting/runtime/makefile b/src/usr/targeting/runtime/makefile index b453a1f99..c2279f8b2 100644 --- a/src/usr/targeting/runtime/makefile +++ b/src/usr/targeting/runtime/makefile @@ -40,6 +40,7 @@ HOSTBOOT_RUNTIME_SPECIFIC_OBJS += rt_targeting.o HOSTBOOT_RUNTIME_SPECIFIC_OBJS += attrPlatOverride_rt.o HOSTBOOT_RUNTIME_SPECIFIC_OBJS += errludattribute.o HOSTBOOT_RUNTIME_SPECIFIC_OBJS += attributestrings.o +HOSTBOOT_RUNTIME_SPECIFIC_OBJS += attrsync.o OBJS += ${COMMON_TARGETING_OBJS} OBJS += ${HOSTBOOT_RT_IPL_COMMON_OBJS} diff --git a/src/usr/targeting/runtime/rt_targeting.C b/src/usr/targeting/runtime/rt_targeting.C index 96a024ffe..3b2d64ecd 100644 --- a/src/usr/targeting/runtime/rt_targeting.C +++ b/src/usr/targeting/runtime/rt_targeting.C @@ -34,12 +34,16 @@ #include <targeting/common/utilFilter.H> #include <targeting/common/trace.H> #include <targeting/common/targreasoncodes.H> +#include <targeting/common/attributeTank.H> +#include <targeting/attrrp.H> #include <arch/pirformat.H> #include <runtime/customize_attrs_for_payload.H> #include <runtime/rt_targeting.H> #include <runtime/interface.h> #include <map> #include <util/memoize.H> +#include <util/runtime/util_rt.H> +#include <util/utillidmgr.H> using namespace TARGETING; @@ -172,9 +176,537 @@ errlHndl_t getHbTarget( return Util::Memoize::memoize(_getHbTarget,i_rtTargetId,o_target); } +/** + * @brief Validate LID Structure against Reserved Memory. Check that the + * TargetingHeader eyecatchers are valid, that the TargetingHeader number of + * sections match, and that the types and sizes of each TargetingSection match. + * @param[in] Pointer to new LID Structure targeting binary data + * @param[in] Pointer to current Reserved Memory targeting binary data + * @return 0 on success, else return code + */ +int validateData(void *i_lidStructPtr, + void *i_rsvdMemPtr) +{ + TRACFCOMP(g_trac_targeting,ENTER_MRK"validateData"); + + int rc = 0; + + do + { + // Get pointers to TargetingHeader areas of each buffer + TargetingHeader* l_headerLid = + reinterpret_cast<TargetingHeader*>(i_lidStructPtr); + TargetingHeader* l_headerRsvd = + reinterpret_cast<TargetingHeader*>(i_rsvdMemPtr); + + // Find start to the first section in each buffer: + // (header address + size of header + offset in header) + TargetingSection* l_sectionLid = + reinterpret_cast<TargetingSection*>( + reinterpret_cast<uint64_t>(l_headerLid) + + sizeof(TargetingHeader) + + l_headerLid->offsetToSections); + TargetingSection* l_sectionRsvd = + reinterpret_cast<TargetingSection*>( + reinterpret_cast<uint64_t>(l_headerRsvd) + + sizeof(TargetingHeader) + + l_headerRsvd->offsetToSections); + + // Validate LID Structure TargetingHeader eyecatcher + if (l_headerLid->eyeCatcher != PNOR_TARG_EYE_CATCHER) + { + TRACFCOMP(g_trac_targeting, + "validateData: bad eyecatcher 0x%.8x found in " + "LID Structure TargetingHeader", + l_headerLid->eyeCatcher); + + rc = 1; + + break; + } + + // Validate Reserved Memory TargetingHeader eyecatcher + if (l_headerRsvd->eyeCatcher != PNOR_TARG_EYE_CATCHER) + { + TRACFCOMP(g_trac_targeting, + "validateData: bad eyecatcher 0x%.8x found in " + "Reserved Memory TargetingHeader", + l_headerRsvd->eyeCatcher); + + rc = 1; + + break; + } + + // Validate TargetingHeader number of sections + if (l_headerLid->numSections != l_headerRsvd->numSections) + { + TRACFCOMP(g_trac_targeting, + "validateData: TargetingHeader number of sections " + "miscompare, %d LID Structure sections,%d Reserved " + "Memory sections", + l_headerLid->numSections, + l_headerRsvd->numSections); + + rc = 1; + + break; + } + + // Count of attribute sections + size_t l_sectionCount = l_headerLid->numSections; + + // Loop on each TargetingSection + for (size_t i = 0; + i < l_sectionCount; + ++i, ++l_sectionLid, ++l_sectionRsvd) + { + // Validate TargetingSection type + if (l_sectionLid->sectionType != l_sectionRsvd->sectionType) + { + TRACFCOMP(g_trac_targeting, + "validateData: TargetingSection types miscompare, " + "LID Struct type 0x%0.4x, Rsvd Memory type 0x%0.4x", + l_sectionLid->sectionType, + l_sectionRsvd->sectionType); + + rc = 1; + + break; + } + + // Validate TargetingSection size + if (l_sectionLid->sectionSize != l_sectionRsvd->sectionSize) + { + TRACFCOMP(g_trac_targeting, + "validateData: TargetingSection sizes miscompare, " + "LID Struct size 0x%0.4x, Rsvd Memory size 0x%0.4x", + l_sectionLid->sectionSize, + l_sectionRsvd->sectionSize); + + // Just trace the size mismatch; Don't set rc or break + } + } + // *** Could check if rc was set in for loop and break from do loop + } while(false); + + TRACFCOMP(g_trac_targeting,EXIT_MRK"validateData"); + + return rc; +} + +/** + * @brief Save/Restore attribute values from current Reserved Memory data + * 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 + * @return 0 on success, else return code + */ +int saveRestoreAttrs(void *i_rsvdMemPtr, + void *io_lidStructPtr) +{ + TRACFCOMP( g_trac_targeting, + ENTER_MRK"saveRestoreAttrs: %p %p", + i_rsvdMemPtr, io_lidStructPtr); + + int rc = 0; + AttrRP *l_attrRPLid = nullptr; + + do + { + // Node ID + NODE_ID l_nodeId = 0; + + // Locate current Reserved Memory data via TargetService + TARGETING::TargetService l_targSrv; + (void)l_targSrv.init(); + AttrRP *l_attrRPRsvd = &TARG_GET_SINGLETON(TARGETING::theAttrRP); + + // Create temporary AttrRP instance for new LID Structure targeting data + l_attrRPLid = + new AttrRP(reinterpret_cast<TargetingHeader*>(io_lidStructPtr)); + + // Create TargetRangeFilter for LID Structure targeting data + uint32_t l_maxTargetsLid = 0; + TargetRangeFilter l_allTargetsLid = + l_targSrv.getTargetRangeFilter(io_lidStructPtr, + l_attrRPLid, + 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<void>* l_ppAttrAddrRsvd = nullptr; + uint32_t l_attrCountLid = 0; + ATTRIBUTE_ID* l_pAttrIdLid = nullptr; + AbstractPointer<void>* 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) && (rc == 0); + ++l_allTargetsLid, ++l_targetNum) + { + // Get attribute information for a target in LID Structure (new) + l_attrCountLid = l_targSrv.getTargetAttributes(*l_allTargetsLid, + l_attrRPLid, + l_pAttrIdLid, + l_ppAttrAddrLid); + + // Make sure that attributes were found + if(l_attrCountLid == 0) + { + // Continue to next target if there were no attributes + continue; + } + + l_huidLid = l_allTargetsLid->getAttr<ATTR_HUID>(); + if(l_huidLid != 0) + { + TRACFCOMP( g_trac_targeting, + "saveRestoreAttrs: target %3d has %3d attrs, " + "class %0.8x, type %0.8x, ordinal ID %0.8x, HUID " + "0x%0.8x", + l_targetNum, + l_attrCountLid, + l_allTargetsLid->getAttr<ATTR_CLASS>(), + l_allTargetsLid->getAttr<ATTR_TYPE>(), + l_allTargetsLid->getAttr<ATTR_ORDINAL_ID>(), + l_huidLid); + } + else + { + l_physPathLid = l_allTargetsLid->getAttr<ATTR_PHYS_PATH>(); + TRACFCOMP( g_trac_targeting, + "saveRestoreAttrs: target %3d has %3d attrs, " + "class %0.8x, type %0.8x, ordinal ID %0.8x, %s", + l_targetNum, + l_attrCountLid, + l_allTargetsLid->getAttr<ATTR_CLASS>(), + l_allTargetsLid->getAttr<ATTR_TYPE>(), + l_allTargetsLid->getAttr<ATTR_ORDINAL_ID>(), + l_physPathLid.toString()); + } + + // Create bool used while checking if target exists in current data + bool targetMatched = false; + + // Create TargetRangeFilter for current Reserved Memory data + TargetRangeFilter l_allTargetsRsvd(l_targSrv.begin(), + l_targSrv.end(), + NULL); + + // Walk through current Reserved Memory Targets + for(; + l_allTargetsRsvd; + ++l_allTargetsRsvd) + { + if((l_huidLid != 0) && + (l_allTargetsLid->getAttr<ATTR_CLASS>() == + l_allTargetsRsvd->getAttr<ATTR_CLASS>()) && + (l_allTargetsLid->getAttr<ATTR_TYPE>() == + l_allTargetsRsvd->getAttr<ATTR_TYPE>()) && + (l_allTargetsLid->getAttr<ATTR_ORDINAL_ID>() == + l_allTargetsRsvd->getAttr<ATTR_ORDINAL_ID>()) && + (l_huidLid == l_allTargetsRsvd->getAttr<ATTR_HUID>())) + { + // Flag the match + targetMatched = true; + + break; + } + else if((l_huidLid == 0) && + (l_allTargetsLid->getAttr<ATTR_CLASS>() == + l_allTargetsRsvd->getAttr<ATTR_CLASS>()) && + (l_allTargetsLid->getAttr<ATTR_TYPE>() == + l_allTargetsRsvd->getAttr<ATTR_TYPE>()) && + (l_allTargetsLid->getAttr<ATTR_ORDINAL_ID>() == + l_allTargetsRsvd->getAttr<ATTR_ORDINAL_ID>()) && + (l_physPathLid == + l_allTargetsRsvd->getAttr<ATTR_PHYS_PATH>())) + { + // Flag the match + targetMatched = true; + + break; + } + } + + // Check if target was matched up + if(!targetMatched) + { + if(l_huidLid != 0) + { + TRACFCOMP( g_trac_targeting, + "saveRestoreAttrs: Did not find target " + "HUID 0x%0.8x in Reserved Memory, " + "Keeping targeting data from LID Structure", + l_huidLid); + } + else + { + TRACFCOMP( g_trac_targeting, + "saveRestoreAttrs: Did not find target " + "%s in Reserved Memory, " + "Keeping targeting data from LID Structure", + l_physPathLid.toString()); + } + + // rc should not be changed + + // Go to next new LID Structure target + continue; + } + + // Get attribute information for a target in Reserved Memory (cur) + l_attrCountRsvd = l_targSrv.getTargetAttributes(*l_allTargetsRsvd, + l_attrRPRsvd, + l_pAttrIdRsvd, + l_ppAttrAddrRsvd); + TRACDCOMP( g_trac_targeting, + "Rsvd Memory: " + "HUID 0x%0.8x, attr cnt %d, AttrRP %p, pAttrId %p, " + "ppAttrAddr %p", + l_allTargetsRsvd->getAttr<ATTR_HUID>(), + l_attrCountRsvd, + l_attrRPRsvd, + l_pAttrIdRsvd, + l_ppAttrAddrRsvd); + + // Compare attribute counts for new LID Structure target and current + // Reserved Memory target to see if they differ or not + if(l_attrCountLid != l_attrCountRsvd) + { + // Trace when the attribute counts differ + TRACFCOMP( g_trac_targeting, + "saveRestoreAttrs: Attribute counts for target with " + "huid 0x%0.8x differ, LID Structure count %d, " + "Reserved Memory count %d", + l_huidLid, + l_attrCountLid, + l_attrCountRsvd); + } + + // Walk through Attributes for the new LID Structure target + for(uint32_t l_attrNumLid = 0; + (l_attrNumLid < l_attrCountLid) && (rc == 0); + ++l_attrNumLid) + { + // Get ID for attribute on this pass through loop + ATTRIBUTE_ID* l_pAttrId = l_pAttrIdLid + l_attrNumLid; + + // Get the Reserved Memory attribute value pointer + void* l_pAttrRsvd = nullptr; + l_allTargetsRsvd->_getAttrPtr(*l_pAttrId, + l_attrRPRsvd, + l_pAttrIdRsvd, + l_ppAttrAddrRsvd, + l_pAttrRsvd); + + // Check if attribute is in Reserved Memory data + if(l_pAttrRsvd != nullptr) + { + // Get the LID Structure attribute value pointer + void* l_pAttrLid = nullptr; + l_allTargetsLid->_getAttrPtr(*l_pAttrId, + l_attrRPLid, + l_pAttrIdLid, + l_ppAttrAddrLid, + l_pAttrLid); + + // Look up the size of the attribute + uint32_t l_attrSize = attrSizeLookup(*l_pAttrId); + + // Check that attribute has a valid size + if(l_attrSize == 0) + { + TRACFCOMP( g_trac_targeting, + "saveRestoreAttrs: Did not find size of " + "attribute for attribute ID 0x%.8x, target " + "huid 0x%0.8x in Reserved Memory", + *l_pAttrId, + l_allTargetsRsvd->getAttr<ATTR_HUID>()); + + rc = 1; + + break; + } + + // Check if new attribute value differs from current value + if(memcmp(l_pAttrRsvd, l_pAttrLid, l_attrSize) != 0) + { + TRACFCOMP( g_trac_targeting, + "saveRestoreAttrs: Found differing values " + "for attribute ID 0x%.8x, huid 0x%0.8x", + *l_pAttrId, + l_huidLid); + + TRACFBIN( g_trac_targeting, + "saveRestoreAttrs: Reserved Memory value", + l_pAttrRsvd, + l_attrSize); + + TRACFBIN( g_trac_targeting, + "saveRestoreAttrs: LID Structure value", + l_pAttrLid, + l_attrSize); + + // Copy attribute value from current Reserved Memory + // attribute to new LID Structure attribute + memcpy(l_pAttrRsvd, l_pAttrLid, l_attrSize); + } + } + else + { + TRACFCOMP( g_trac_targeting, + "saveRestoreAttrs: Did not find attribute ID " + "0x%.8x, target huid 0x%0.8x in Reserved " + "Memory, Keeping value from LID Structure", + *l_pAttrId, + l_huidLid); + + // rc should not be changed + } + } // for attributes + } // for targets + } while(false); + + delete l_attrRPLid; + l_attrRPLid = nullptr; + + TRACFCOMP( g_trac_targeting, EXIT_MRK"saveRestoreAttrs"); + + return rc; +} + int hbrt_update_prep(void) { int rc = 0; + errlHndl_t pError = nullptr; + UtilLidMgr l_lidMgr(Util::TARGETING_BINARY_LIDID); + void *l_lidStructPtr = nullptr; + + bool l_usingRealLID = false; + + do + { + // 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); + + // Set pointer to reserved memory targeting data + void *l_rsvdMemPtr = reinterpret_cast<void*>(l_rsvdMem); + + // Create lidMgr and get size of Targeting Binary LID + size_t l_lidSize = 0; + pError = l_lidMgr.getLidSize(l_lidSize); + if(pError) + { + pError->collectTrace(TARG_COMP_NAME); + errlCommit(pError,TARG_COMP_ID); + + rc = 1; + + // break; @TODO RTC: 181285 uncomment + l_lidSize = l_attr_size; // @TODO RTC: 181285 remove + } + + if(!rc) // @TODO RTC: 181285 remove + { // @TODO RTC: 181285 remove + if(l_lidSize > l_attr_size) + { + TRACFCOMP( g_trac_targeting, + ERR_MRK"hbrt_update_prep: Sizes of targeting data, " + "LID Structure(New) 0x%0.8x is too large for Rsvd " + "Memory(Current) 0x%0.8x", + l_lidSize, + l_attr_size); + + rc = 1; + + break; + } + + // Get new structure from LID + pError = l_lidMgr.getStoredLidImage(l_lidStructPtr, l_lidSize); + if(pError) + { + pError->collectTrace(TARG_COMP_NAME); + errlCommit(pError,TARG_COMP_ID); + + rc = 1; + + // break; @TODO RTC: 181285 uncomment + } + } // @TODO RTC: 181285 remove + + if(rc) // @TODO RTC: 181285 remove if(rc){...}else{...} start + { + l_lidStructPtr = malloc(l_attr_size); + memcpy(l_lidStructPtr, + l_rsvdMemPtr, + l_attr_size); + + rc = 0; + } + else + { + l_usingRealLID = true; + } // @TODO RTC: 181285 remove if(rc){...}else{...} end + + // Validate LID Structure against Reserved Memory + rc = validateData(l_lidStructPtr, + l_rsvdMemPtr); + if(rc) + { + break; + } + + // Save/Restore attribute values from current Reserved Memory data into + // new LID Structure data + rc = saveRestoreAttrs(l_rsvdMemPtr, + l_lidStructPtr); + if(rc) + { + break; + } + + // Copy new LID Structure data over current Reserved Memory data + size_t l_copySize = std::min(l_lidSize, l_attr_size); + TRACFCOMP( g_trac_targeting, + "hbrt_update_prep: Copy 0x%0.8x bytes of targeting data", + l_copySize); + memcpy(l_rsvdMemPtr, + l_lidStructPtr, + l_copySize); + TRACFCOMP( g_trac_targeting, + "hbrt_update_prep: Set 0x%0.8x bytes to 0", + l_attr_size - l_copySize); + memset(reinterpret_cast<void*>( + reinterpret_cast<uint64_t>(l_rsvdMemPtr) + l_copySize), + 0, + l_attr_size - l_copySize); + } while(false); + + if(l_usingRealLID) // @TODO RTC: 181285 remove + { // @TODO RTC: 181285 remove + pError = l_lidMgr.releaseLidImage(); + if(pError) + { + pError->collectTrace(TARG_COMP_NAME); + errlCommit(pError,TARG_COMP_ID); + + rc = 1; + } + } // @TODO RTC: 181285 remove + else // @TODO RTC: 181285 remove + { // @TODO RTC: 181285 remove + free(l_lidStructPtr); // @TODO RTC: 181285 remove + l_lidStructPtr = nullptr; // @TODO RTC: 181285 remove + } // @TODO RTC: 181285 remove return rc; } diff --git a/src/usr/util/runtime/utillidmgr_rt.C b/src/usr/util/runtime/utillidmgr_rt.C index e5d381a2c..6977d253c 100644 --- a/src/usr/util/runtime/utillidmgr_rt.C +++ b/src/usr/util/runtime/utillidmgr_rt.C @@ -348,9 +348,10 @@ const uint32_t * UtilLidMgr::getLidList(size_t * o_num) Util::WOF_LIDID, Util::WOF_CONTAINER_LIDID, Util::NIMBUS_HCODE_LIDID, - Util::HWREFIMG_RINGOVD_LIDID, + Util::CUMULUS_HCODE_LIDID, Util::HCODE_CONTAINER_LIDID, - Util::HWREFIMG_RINGOVD_LIDID + Util::HWREFIMG_RINGOVD_LIDID, + Util::TARGETING_BINARY_LIDID }; *o_num = sizeof(lidlist)/sizeof(lidlist[0]); return lidlist; @@ -365,7 +366,8 @@ bool UtilLidMgr::lidInHbResvMem(const uint32_t i_lidId) const i_lidId == Util::NIMBUS_HCODE_LIDID || i_lidId == Util::CUMULUS_HCODE_LIDID || i_lidId == Util::HCODE_CONTAINER_LIDID || - i_lidId == Util::HWREFIMG_RINGOVD_LIDID; + i_lidId == Util::HWREFIMG_RINGOVD_LIDID || + i_lidId == Util::TARGETING_BINARY_LIDID; } //------------------------------------------------------------------------ |
