diff options
Diffstat (limited to 'src/usr/diag/prdf/framework/service/prdfServiceDataCollector.C')
| -rwxr-xr-x | src/usr/diag/prdf/framework/service/prdfServiceDataCollector.C | 397 |
1 files changed, 397 insertions, 0 deletions
diff --git a/src/usr/diag/prdf/framework/service/prdfServiceDataCollector.C b/src/usr/diag/prdf/framework/service/prdfServiceDataCollector.C new file mode 100755 index 000000000..8374b8434 --- /dev/null +++ b/src/usr/diag/prdf/framework/service/prdfServiceDataCollector.C @@ -0,0 +1,397 @@ +/* IBM_PROLOG_BEGIN_TAG */ +/* This is an automatically generated prolog. */ +/* */ +/* $Source: src/usr/diag/prdf/framework/service/prdfServiceDataCollector.C $ */ +/* */ +/* IBM CONFIDENTIAL */ +/* */ +/* COPYRIGHT International Business Machines Corp. 2004,2012 */ +/* */ +/* p1 */ +/* */ +/* Object Code Only (OCO) source materials */ +/* Licensed Internal Code Source Materials */ +/* IBM HostBoot Licensed Internal Code */ +/* */ +/* The source code for this program is not published or otherwise */ +/* divested of its trade secrets, irrespective of what has been */ +/* deposited with the U.S. Copyright Office. */ +/* */ +/* Origin: 30 */ +/* */ +/* IBM_PROLOG_END_TAG */ + +/** + @file prdfServiceDataCollector.C + @brief ServiceDataCollector definition +*/ +//------------------------------------------------------------------------------ +// Includes +//------------------------------------------------------------------------------ +#include <string.h> // for memcpy +#define prdfServiceDataCollector_C + +#ifdef __HOSTBOOT_MODULE + // these are no-ops in HB + #define htonl(foo) (foo) + #define htons(foo) (foo) + #define ntohl(foo) (foo) + #define ntohs(foo) (foo) +#else + #include <netinet/in.h> +#endif + +#include <iipServiceDataCollector.h> +#include <prdfPlatServices.H> +#include <prdfTrace.H> +#undef prdfServiceDataCollector_C + +using namespace PRDF; + +//------------------------------------------------------------------------------ +// User Types, Constants, macros, prototypes, globals +//------------------------------------------------------------------------------ + +//------------------------------------------------------------------------------ +// Member Function Specifications +//------------------------------------------------------------------------------ +#ifndef __HOSTBOOT_MODULE + +inline void buffer_append(uint8_t *&ptr, uint32_t value) +{ + uint32_t l_tmp32 = htonl(value); + memcpy(ptr, &l_tmp32, sizeof(uint32_t)); + ptr += sizeof(uint32_t); +} + +inline void buffer_append(uint8_t *&ptr, uint16_t value) +{ + uint16_t l_tmp16 = htons(value); + memcpy(ptr, &l_tmp16, sizeof(uint16_t)); + ptr += sizeof(uint16_t); +} + +inline void buffer_append(uint8_t *&ptr, uint8_t value) +{ + memcpy(ptr, &value, sizeof(value)); + ptr += sizeof(uint8_t); +} + +inline uint32_t buffer_get32(const uint8_t * &ptr) +{ + uint32_t l_tmp32 = 0; + memcpy(&l_tmp32, ptr, sizeof(uint32_t)); + ptr += sizeof(uint32_t); + return ntohl(l_tmp32); +} + +inline uint16_t buffer_get16(const uint8_t * &ptr) +{ + uint16_t l_tmp16 = 0; + memcpy(&l_tmp16, ptr, sizeof(uint16_t)); + ptr += sizeof(uint16_t); + return ntohs(l_tmp16); +} + +inline uint8_t buffer_get8(const uint8_t * &ptr) +{ + uint8_t l_tmp8 = 0; + memcpy(&l_tmp8, ptr, sizeof(uint8_t)); + ptr += sizeof(uint8_t); + return l_tmp8; +} + +inline TARGETING::TargetHandle_t buffer_getTarget( const uint8_t *&ptr ) +{ + HUID l_chipHuid = INVALID_HUID; + uint32_t l_size = sizeof( l_chipHuid ); + memcpy( &l_chipHuid, ptr, l_size ); + l_chipHuid = ntohl( l_chipHuid ); + TARGETING::TargetHandle_t l_tempChipHandle = PlatServices::getTarget( l_chipHuid ); + ptr += l_size; + + return l_tempChipHandle; +} + +#endif + +//------------------------------------------------------------------------------ + +void ServiceDataCollector::SetCallout( PRDcallout mru, + PRDpriority priority ) +{ + bool found = false; + + if ( PRDcallout::TYPE_TARGET == mru.getType() ) + { + // Ensuring target is not NULL + if ( NULL == mru.getTarget() ) + { + PRDF_ERR( "[ServiceDataCollector::SetCallout] " + "skipping NULL callout" ); + return; + } + } + + for ( SDC_MRU_LIST::iterator i = xMruList.begin(); + i != xMruList.end() && found == false; ++i ) + { + if ( i->callout == mru ) + { + found = true; + if ( priority < i->priority ) + { + i->priority = priority; + } + } + } + + if ( found == false ) + { + xMruList.push_back( SdcCallout(mru, priority) ); + } +} + +//------------------------------------------------------------------------------ + +void ServiceDataCollector::AddSignatureList(TARGETING::TargetHandle_t i_pTargetHandle, + uint32_t i_signature) +{ + bool found = false; + if(NULL == i_pTargetHandle) + { + PRDF_ERR(" ServiceDataCollector::AddSignatureList could not add invalid target "); + return; + } + for(PRDF_SIGNATURES::iterator i = iv_SignatureList.begin(); + i != iv_SignatureList.end(); i++) + { + if((i->iv_pSignatureHandle == i_pTargetHandle) && + (i->iv_signature == i_signature)) + { + found = true; + break; + } + } + if(found == false) + { + iv_SignatureList.push_back(PrdfSignatureList(i_pTargetHandle, i_signature)); + } +} + + +#ifndef __HOSTBOOT_MODULE + +//------------------------------------------------------------------------------ + +uint32_t ServiceDataCollector::Flatten(uint8_t * i_buffer, uint32_t & io_size) const +{ + uint32_t max_size = io_size; + uint32_t rc = SUCCESS; + //getting the actual size of prdfHcdbChangeItem and PrdfSignatureList that gets saved in memory. since + //instead of handle we save the entity path + uint32_t l_sizeHcdbChange = iv_HcdbChangeList.size() * sizeof(PrdfHcdbChangeItem); + uint32_t l_sizeSignList = iv_SignatureList.size() * sizeof(PrdfSignatureList); + uint32_t l_sizeMruList = xMruList.size() * sizeof(SdcCallout); + // approximate space needed for essentials. This estimate is slightly higher than actual + const uint32_t MIN_FLAT_SIZE = sizeof(ServiceDataCollector) + sizeof(struct PrdTimer::prdftm_t) + + l_sizeMruList + l_sizeHcdbChange + l_sizeSignList; + + uint8_t * current_ptr = i_buffer; + + if(max_size > MIN_FLAT_SIZE) + { + // must have this + uint32_t l_huid = error_signature.getChipId(); + buffer_append(current_ptr,l_huid); + buffer_append(current_ptr,error_signature.getSigId()); + // callouts + buffer_append(current_ptr,xMruList.size()); + for ( SDC_MRU_LIST::const_iterator i = xMruList.begin(); + i != xMruList.end(); ++i ) + { + buffer_append( current_ptr, (uint32_t)i->callout.getType() ); + buffer_append( current_ptr, i->callout.flatten() ); + buffer_append( current_ptr, (uint32_t)i->priority ); + } + buffer_append(current_ptr, iv_HcdbChangeList.size()); + for(HCDB_CHANGE_LIST::const_iterator i = iv_HcdbChangeList.begin(); + i != iv_HcdbChangeList.end(); ++i) + { + buffer_append(current_ptr,(TARGETING::TargetHandle_t)i->iv_phcdbtargetHandle); + buffer_append(current_ptr,(uint32_t)i->iv_compSubType); + buffer_append(current_ptr,(uint32_t)i->iv_compType); + } + buffer_append(current_ptr, iv_SignatureList.size()); + for(PRDF_SIGNATURES::const_iterator i = iv_SignatureList.begin(); + i != iv_SignatureList.end(); ++i) + { + buffer_append(current_ptr,(TARGETING::TargetHandle_t)i->iv_pSignatureHandle); + buffer_append(current_ptr,(uint32_t)i->iv_signature); + } + buffer_append(current_ptr,maskId); + buffer_append(current_ptr,(uint32_t)attentionType); + buffer_append(current_ptr,flags); + buffer_append(current_ptr,hitCount); + buffer_append(current_ptr,threshold); + buffer_append(current_ptr,reasonCode); + buffer_append(current_ptr,startingPoint); + buffer_append(current_ptr,(uint32_t)errorType); + //@ecdf - Removed ivDumpRequestType. + buffer_append(current_ptr,ivDumpRequestContent); + buffer_append(current_ptr,ivpDumpRequestChipHandle); + PrdTimer::prdftm_t l_tm = ivCurrentEventTime.gettm(); + const uint32_t PRDFTM_SIZE = sizeof(struct PrdTimer::prdftm_t); + memcpy(current_ptr,&l_tm,PRDFTM_SIZE); + current_ptr += PRDFTM_SIZE; + buffer_append(current_ptr,(uint32_t)causeAttentionType); + buffer_append(current_ptr,ivpThermalChipHandle); + + // Add as much capture data as we have room. + uint8_t * cap_size_ptr = current_ptr; // Place for Capture data size + current_ptr += sizeof(uint32_t); + + uint32_t cap_size = captureData.Copy(current_ptr,max_size - (current_ptr - i_buffer)); + current_ptr += cap_size; + buffer_append(cap_size_ptr,cap_size); + + } + else // buffer is not big enough to capture the essentials + { + rc = 2; + } + + io_size = current_ptr - i_buffer; + + return rc; +} + +//------------------------------------------------------------------------------ + +ServiceDataCollector & ServiceDataCollector::operator=(const uint8_t * i_flatdata) +{ + error_signature.setChipId(buffer_get32(i_flatdata)); + error_signature.setSigId( buffer_get32(i_flatdata) ); + + uint32_t value = buffer_get32(i_flatdata); // number of callouts + ClearCallouts(); + for(uint32_t i = 0; i < value; ++i) + { + MruType mt = (MruType) buffer_get32(i_flatdata); // callout type + if ( PRDcallout::TYPE_TARGET == mt ) + { + // Retrieving target. + TARGETING::TargetHandle_t l_pChipHandle + = buffer_getTarget(i_flatdata); + + if(NULL !=l_pChipHandle) + { + //Resurrecting prdcallout from all the data elements + PRDcallout callout((TARGETING:: + TargetHandle_t)l_pChipHandle, + mt); + xMruList.push_back( SdcCallout( callout, + (PRDpriority)buffer_get32 + (i_flatdata)) + ); // callout priority + } + + } + else + { + uint32_t mru = buffer_get32(i_flatdata); // other callouts + //Resurrecting prdcallout from all the data elements + PRDcallout callout(mru,mt); + xMruList.push_back( SdcCallout(callout, + (PRDpriority)buffer_get32(i_flatdata))); // callout priority + } + } + ClearHcdbList(); + value = buffer_get32(i_flatdata); // number of HcdbEntries. + for(uint32_t i = 0; i < value; ++i) + { + TARGETING::TargetHandle_t l_pChipHandle = buffer_getTarget(i_flatdata); + hcdb::comp_subtype_t l_compSubType = (hcdb::comp_subtype_t)buffer_get32(i_flatdata); + comp_id_t l_compType = (comp_id_t)buffer_get32(i_flatdata); + if(NULL !=l_pChipHandle) + { + PrdfHcdbChangeItem l_item(l_pChipHandle, l_compSubType, l_compType); + iv_HcdbChangeList.push_back(l_item); + + } + } + ClearSignatureList(); + value = buffer_get32(i_flatdata); // number of HcdbEntries. + for(uint32_t i = 0; i < value; ++i) + { + TARGETING::TargetHandle_t l_pChipHandle = buffer_getTarget(i_flatdata); + uint32_t l_signature = (uint32_t) buffer_get32(i_flatdata); + if(NULL !=l_pChipHandle) + { + PrdfSignatureList l_item(l_pChipHandle, l_signature); + iv_SignatureList.push_back(l_item); + } + } + + maskId = buffer_get32(i_flatdata); + attentionType = (ATTENTION_TYPE)buffer_get32(i_flatdata); + flags = buffer_get32(i_flatdata); //mp02 c from buffer_get16 + hitCount = buffer_get8(i_flatdata); + threshold = buffer_get8(i_flatdata); + reasonCode = buffer_get16(i_flatdata); //mp04 a + startingPoint = buffer_getTarget(i_flatdata); + errorType = (GardResolution::ErrorType)buffer_get32(i_flatdata); + ivDumpRequestContent = (hwTableContent) buffer_get32(i_flatdata); //@ecdf + ivpDumpRequestChipHandle = buffer_getTarget(i_flatdata); + + PrdTimer::prdftm_t l_tm; + const uint32_t PRDFTM_SIZE = sizeof(struct PrdTimer::prdftm_t); + memcpy(&l_tm,i_flatdata,PRDFTM_SIZE); + i_flatdata += PRDFTM_SIZE; + ivCurrentEventTime.settm(l_tm); + + causeAttentionType = (ATTENTION_TYPE) buffer_get32(i_flatdata); + ivpThermalChipHandle = buffer_getTarget(i_flatdata); + + // Capture data - oh joy + // do we re-expand the data or change capture date to hang onto the already flattened data? + // lets give it back to the capture data object and let it decide. + + captureData = i_flatdata; + + return *this; +} + +//------------------------------------------------------------------------------ + +void ServiceDataCollector::AddChangeForHcdb(TARGETING::TargetHandle_t i_pTargetHandle , + hcdb::comp_subtype_t i_testType, + comp_id_t i_compType) +{ + bool found = false; + //Ensuring the handles are valid before pushing to the list + if(NULL == i_pTargetHandle) + { + PRDF_ERR(" ServiceDataCollector::AddChangeForHcdb could not add invalid target "); + return; + } + + for(HCDB_CHANGE_LIST::iterator i = iv_HcdbChangeList.begin(); + i != iv_HcdbChangeList.end(); i++) + { + if((i->iv_phcdbtargetHandle ==i_pTargetHandle) && + (i->iv_compSubType == i_testType) && + (i->iv_compType == i_compType)) + { + found = true; + break; + } + } + if(found == false) + { + iv_HcdbChangeList.push_back( PrdfHcdbChangeItem(i_pTargetHandle, i_testType, i_compType)); + } +} + +#endif + |
