diff options
-rw-r--r-- | src/usr/dump/dumpCollect.C | 807 | ||||
-rw-r--r-- | src/usr/dump/dumpCollect.H | 7 | ||||
-rw-r--r-- | src/usr/dump/test/dumptest.H | 92 |
3 files changed, 474 insertions, 432 deletions
diff --git a/src/usr/dump/dumpCollect.C b/src/usr/dump/dumpCollect.C index 1d712b719..972803c10 100644 --- a/src/usr/dump/dumpCollect.C +++ b/src/usr/dump/dumpCollect.C @@ -5,7 +5,7 @@ /* */ /* IBM CONFIDENTIAL */ /* */ -/* COPYRIGHT International Business Machines Corp. 2012,2013 */ +/* COPYRIGHT International Business Machines Corp. 2012,2014 */ /* */ /* p1 */ /* */ @@ -39,6 +39,7 @@ #include <sys/msg.h> // message Q's #include <mbox/mbox_queues.H> // +#include <kernel/vmmmgr.H> // Trace definition trace_desc_t* g_trac_dump = NULL; @@ -99,469 +100,510 @@ errlHndl_t doDumpCollect(void) return (l_err); } +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// +// Returns the physical address corresponding to a PHYP MDST/MDRT entry +void* getPhysAddr( uint64_t i_phypAddr ) +{ + uint64_t phys_addr = 0; - /////////////////////////////////////////////////////////////////////////////// - /////////////////////////////////////////////////////////////////////////////// - - errlHndl_t copySrcToDest(dumpEntry *srcTableEntry, uint64_t srcTableSize, - dumpEntry *destTableEntry, uint64_t destTableSize, - resultsEntry *resultsTableEntry, uint64_t resultsTableSize) + // Physical Address + if( VmmManager::FORCE_PHYS_ADDR & i_phypAddr ) + { + // lop off the top bit so our vmm code works + phys_addr = (i_phypAddr & ~VmmManager::FORCE_PHYS_ADDR); + } + // Relative to PHYP HRMOR + else { - TRACFCOMP(g_trac_dump, "copySrcToDest - start "); + TARGETING::Target * sys = NULL; + TARGETING::targetService().getTopLevelTarget( sys ); + assert(sys != NULL); + + // add the hrmor/payload_base to the value in the table + TARGETING::ATTR_PAYLOAD_BASE_type payload_base + = sys->getAttr<TARGETING::ATTR_PAYLOAD_BASE>(); + phys_addr = payload_base*MEGABYTE + i_phypAddr; + } - errlHndl_t l_err = NULL; - int rc = 0; - bool invalidSrcSize = false; - bool invalidDestSize = false; - uint32_t l_resultCount = 0x0; + return reinterpret_cast<void*>(ALIGN_PAGE_DOWN(phys_addr)); +} - // local src table info - uint64_t *vaSrcTableAddr = 0; - uint64_t *vaMapSrcTableAddr = 0; - uint64_t curSrcTableAddr = 0; +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// - // destination table info - uint64_t *vaDestTableAddr = 0; - uint64_t *vaMapDestTableAddr = 0; - uint64_t curDestTableAddr = 0; +errlHndl_t copySrcToDest(dumpEntry *srcTableEntry, + uint64_t srcTableSize, + dumpEntry *destTableEntry, + uint64_t destTableSize, + resultsEntry *resultsTableEntry, + uint64_t resultsTableSize) +{ + TRACFCOMP(g_trac_dump, "copySrcToDest - start "); - // Data sizes - uint64_t sizeToCopy = 0; - uint64_t bytesLeftInSrc = 0; - uint64_t bytesLeftInDest = 0; + errlHndl_t l_err = NULL; + int rc = 0; + bool invalidSrcSize = false; + bool invalidDestSize = false; + uint32_t l_resultCount = 0x0; + + // local src table info + uint64_t *vaSrcTableAddr = 0; + uint64_t *vaMapSrcTableAddr = 0; + uint64_t curSrcTableAddr = 0; + + // destination table info + uint64_t *vaDestTableAddr = 0; + uint64_t *vaMapDestTableAddr = 0; + uint64_t curDestTableAddr = 0; + + // Data sizes + uint64_t sizeToCopy = 0; + uint64_t bytesLeftInSrc = 0; + uint64_t bytesLeftInDest = 0; - do - { + do + { - // Need to loop through all the source entries.. Copying into a - // destination entry. Note the src could be larger than the - // destination size and could require multiple copies.. In addition - // the size of the destination could be larger than 1 source entry. - // These entries need to be packed into the destination.. so 1 - // destination entry could have multiple source entries in it. - // After each copy need to write an entry into the results table - // source/destination/size. - - // Figure out the num of entries in the src table - uint64_t maxSrcEntries = srcTableSize/(sizeof (dumpEntry)); - - // Figure out the num of entries in the dest table - uint64_t maxDestEntries = destTableSize/(sizeof (dumpEntry)); - - // Figure out the max result entires - uint64_t maxResultEntries = resultsTableSize/(sizeof - (resultsEntry)); - - // Index into each Dump table - uint64_t curSourceIndex = 0; - uint64_t curDestIndex = 0; - uint64_t curResultIndex = 0; - - // Map in the first source and destination entries from their - // corresponding tables. - // NOTE: When mapping a device the address we are mapping needs to - // be page aligned. In addition the VA returned is page - // aligned so we need to add the offset of the page aligned address - // to the VA returned - - // Get the first Source address and size - curSrcTableAddr = srcTableEntry[curSourceIndex].dataAddr; - bytesLeftInSrc = srcTableEntry[curSourceIndex].dataSize; - - // Get the first destination address and size. - curDestTableAddr = destTableEntry[curDestIndex].dataAddr; - bytesLeftInDest = destTableEntry[curDestIndex].dataSize; - - // Determine the src and destination offset. - uint64_t destOffset = curDestTableAddr - ALIGN_PAGE_DOWN(curDestTableAddr); - uint64_t srcOffset = curSrcTableAddr - ALIGN_PAGE_DOWN(curSrcTableAddr); - - // If the data size is greater then 32GB after page alignment - // create an error. Current limitation on DevMap is 32GB in size. - // Not sure yet if we will ever see a table entry > 3GB. - if (bytesLeftInSrc + srcOffset > THIRTYTWO_GB) - { - invalidSrcSize = true; - break; - } - else if ((bytesLeftInDest + destOffset > THIRTYTWO_GB)) - { - invalidDestSize = true; - break; - } + // Need to loop through all the source entries.. Copying into a + // destination entry. Note the src could be larger than the + // destination size and could require multiple copies.. In addition + // the size of the destination could be larger than 1 source entry. + // These entries need to be packed into the destination.. so 1 + // destination entry could have multiple source entries in it. + // After each copy need to write an entry into the results table + // source/destination/size. + + // Figure out the num of entries in the src table + uint64_t maxSrcEntries = srcTableSize/(sizeof (dumpEntry)); + + // Figure out the num of entries in the dest table + uint64_t maxDestEntries = destTableSize/(sizeof (dumpEntry)); + + // Figure out the max result entires + uint64_t maxResultEntries = resultsTableSize/(sizeof + (resultsEntry)); + + // Index into each Dump table + uint64_t curSourceIndex = 0; + uint64_t curDestIndex = 0; + uint64_t curResultIndex = 0; + + // Map in the first source and destination entries from their + // corresponding tables. + // NOTE: When mapping a device the address we are mapping needs to + // be page aligned. In addition the VA returned is page + // aligned so we need to add the offset of the page aligned address + // to the VA returned + + // Get the first Source address and size + curSrcTableAddr = srcTableEntry[curSourceIndex].dataAddr; + bytesLeftInSrc = srcTableEntry[curSourceIndex].dataSize; + + // Get the first destination address and size. + curDestTableAddr = destTableEntry[curDestIndex].dataAddr; + bytesLeftInDest = destTableEntry[curDestIndex].dataSize; + + // Determine the src and destination offset. + uint64_t destOffset = curDestTableAddr + - ALIGN_PAGE_DOWN(curDestTableAddr); + uint64_t srcOffset = curSrcTableAddr + - ALIGN_PAGE_DOWN(curSrcTableAddr); + + // If the data size is greater then 32GB after page alignment + // create an error. Current limitation on DevMap is 32GB in size. + // Not sure yet if we will ever see a table entry > 3GB. + if (bytesLeftInSrc + srcOffset > THIRTYTWO_GB) + { + invalidSrcSize = true; + break; + } + else if ((bytesLeftInDest + destOffset > THIRTYTWO_GB)) + { + invalidDestSize = true; + break; + } - vaMapSrcTableAddr = - (static_cast<uint64_t*>(mm_block_map( - reinterpret_cast<void*>(ALIGN_PAGE_DOWN - (curSrcTableAddr & RM_TOP_NIBBLE_MASK)), - THIRTYTWO_GB))); + vaMapSrcTableAddr = (static_cast<uint64_t*>(mm_block_map( + getPhysAddr(curSrcTableAddr), + THIRTYTWO_GB))); - vaSrcTableAddr = vaMapSrcTableAddr; + vaSrcTableAddr = vaMapSrcTableAddr; - vaMapDestTableAddr = - (static_cast<uint64_t*>(mm_block_map( - reinterpret_cast<void*>(ALIGN_PAGE_DOWN - (curDestTableAddr & RM_TOP_NIBBLE_MASK)), - THIRTYTWO_GB))); + vaMapDestTableAddr = (static_cast<uint64_t*>(mm_block_map( + getPhysAddr(curDestTableAddr), + THIRTYTWO_GB))); - vaDestTableAddr = vaMapDestTableAddr; + vaDestTableAddr = vaMapDestTableAddr; - // add the offset to the src and destination VAs, - vaSrcTableAddr += (srcOffset/(sizeof (uint64_t))); + // add the offset to the src and destination VAs, + vaSrcTableAddr += (srcOffset/(sizeof (uint64_t))); - vaDestTableAddr += (destOffset/(sizeof (uint64_t))); + vaDestTableAddr += (destOffset/(sizeof (uint64_t))); - // Current Source physical and Va address - TRACFCOMP(g_trac_dump, "copySrcToDest SrcTableIndex = %d, srcTableAddr = %.16X, VA = %.16X", curSourceIndex, curSrcTableAddr, vaSrcTableAddr); + // Current Source physical and Va address + TRACFCOMP(g_trac_dump, "copySrcToDest SrcTableIndex = %d, srcTableAddr = %.16X, VA = %.16X", curSourceIndex, curSrcTableAddr, vaSrcTableAddr); - // Current Destination physical and Va address - TRACFCOMP(g_trac_dump, "HBDumpCopySrcToDest DestTableIndex = %d, DestTableAddr = %.16X, VA = %.16X", curDestIndex, curDestTableAddr, vaDestTableAddr); + // Current Destination physical and Va address + TRACFCOMP(g_trac_dump, "HBDumpCopySrcToDest DestTableIndex = %d, DestTableAddr = %.16X, VA = %.16X", curDestIndex, curDestTableAddr, vaDestTableAddr); - resultsTableEntry->dataSize = 0x0; + resultsTableEntry->dataSize = 0x0; - while(1) + while(1) + { + // If we have copied all the bytes in the src entry + if (bytesLeftInSrc == 0) { - // If we have copied all the bytes in the src entry - if (bytesLeftInSrc == 0) + // unmap the previous src entry + rc = mm_block_unmap( + reinterpret_cast<void*>(vaMapSrcTableAddr)); + + if (rc != 0) { - // unmap the previous src entry - rc = mm_block_unmap( - reinterpret_cast<void*>(vaMapSrcTableAddr)); + /*@ + * @errortype + * @moduleid DUMP::DUMP_COLLECT + * @reasoncode DUMP::DUMP_CANNOT_UNMAP_SRC + * @userdata1 VA address of the MDST to unmap + * @userdata2 rc value from unmap + * @devdesc Cannot unmap the source table section + */ + l_err = new ERRORLOG::ErrlEntry( + ERRORLOG::ERRL_SEV_UNRECOVERABLE, + DUMP_COLLECT, + DUMP_CANNOT_UNMAP_SRC, + (uint64_t)vaMapSrcTableAddr, + rc); - if (rc != 0) - { - /*@ - * @errortype - * @moduleid DUMP::DUMP_COLLECT - * @reasoncode DUMP::DUMP_CANNOT_UNMAP_SRC - * @userdata1 VA address of the MDST to unmap - * @userdata2 rc value from unmap - * @devdesc Cannot unmap the source table section - */ - l_err = new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE, - DUMP_COLLECT, - DUMP_CANNOT_UNMAP_SRC, - (uint64_t)vaMapSrcTableAddr, - rc); + // commit the error and continue. + // Leave the devices unmapped for now. + errlCommit(l_err,DUMP_COMP_ID); - // commit the error and continue. Leave the devices unmapped for now. - errlCommit(l_err,DUMP_COMP_ID); + l_err = NULL; - l_err = NULL; + } - } + // increment to the next src entry + curSourceIndex++; - // increment to the next src entry - curSourceIndex++; + // if we have reach all entries + if (curSourceIndex >= maxSrcEntries) + { + TRACFCOMP(g_trac_dump, "HBDumpCopySrcToDest - through all src entries"); + break; + } - // if we have reach all entries - if (curSourceIndex >= maxSrcEntries) - { - TRACFCOMP(g_trac_dump, "HBDumpCopySrcToDest - through all src entries"); - break; - } + curSrcTableAddr = srcTableEntry[curSourceIndex].dataAddr; + bytesLeftInSrc = srcTableEntry[curSourceIndex].dataSize; - curSrcTableAddr = srcTableEntry[curSourceIndex].dataAddr; - bytesLeftInSrc = srcTableEntry[curSourceIndex].dataSize; + // If the current Src table Address is 0 we are done + if (curSrcTableAddr == 0) + { + break; + } - // If the current Src table Address is 0 we are done - if (curSrcTableAddr == 0) - { - break; - } + srcOffset = curSrcTableAddr - + ALIGN_PAGE_DOWN(curSrcTableAddr); - srcOffset = curSrcTableAddr - ALIGN_PAGE_DOWN(curSrcTableAddr); + // If the data size is less then 32GB after page alignment + if (bytesLeftInSrc + srcOffset > THIRTYTWO_GB) + { + invalidSrcSize = true; + break; + } - // If the data size is less then 32GB after page alignment - if (bytesLeftInSrc + srcOffset > THIRTYTWO_GB) - { - invalidSrcSize = true; - break; - } + // map the MDST entry to a device such that we can read and + // write from that memory address + vaMapSrcTableAddr = (static_cast<uint64_t*>(mm_block_map( + getPhysAddr(curSrcTableAddr), + THIRTYTWO_GB))); - // map the MDST entry to a device such that we can read and write from that memory - // address - vaMapSrcTableAddr = - (static_cast<uint64_t*>(mm_block_map( - reinterpret_cast<void*>(ALIGN_PAGE_DOWN - (curSrcTableAddr & RM_TOP_NIBBLE_MASK)), - THIRTYTWO_GB))); + vaSrcTableAddr = vaMapSrcTableAddr; - vaSrcTableAddr = vaMapSrcTableAddr; + vaSrcTableAddr += (srcOffset/(sizeof (uint64_t))); - vaSrcTableAddr += (srcOffset/(sizeof (uint64_t))); + // Current Source physical and Va address + TRACFCOMP(g_trac_dump, "copySrcToDest SrcTableIndex = %d, srcTableAddr = %.16X, VA = %.16X", curSourceIndex, curSrcTableAddr, vaSrcTableAddr); - // Current Source physical and Va address - TRACFCOMP(g_trac_dump, "copySrcToDest SrcTableIndex = %d, srcTableAddr = %.16X, VA = %.16X", curSourceIndex, curSrcTableAddr, vaSrcTableAddr); + } + + // If there is no more space in the destination area + if (bytesLeftInDest == 0) + { + // unmap the previous dest entry + rc = mm_block_unmap( + reinterpret_cast<void*>(vaMapDestTableAddr)); + if (rc != 0) + { + /*@ + * @errortype + * @moduleid DUMP::DUMP_COLLECT + * @reasoncode DUMP::DUMP_CANNOT_UNMAP_DEST + * @userdata1 VA address of the MDDT to unmap + * @userdata2 rc value from unmap + * @devdesc Cannot unmap the source table section + */ + l_err = new ERRORLOG::ErrlEntry( + ERRORLOG::ERRL_SEV_UNRECOVERABLE, + DUMP_COLLECT, + DUMP_CANNOT_UNMAP_DEST, + (uint64_t)vaMapDestTableAddr, + rc); + // commit the error and continue. + // Leave the devices unmapped? + errlCommit(l_err,DUMP_COMP_ID); + + l_err = NULL; } - // If there is no more space in the destination area - if (bytesLeftInDest == 0) + // increment to the next dest entry + curDestIndex++; + + // if made it through all dest entries. + if (curDestIndex >= maxDestEntries) { - // unmap the previous dest entry - rc = mm_block_unmap( - reinterpret_cast<void*>(vaMapDestTableAddr)); - if (rc != 0) + // need to check here to see if we still have SRC + // entries not copied. + if (bytesLeftInSrc != 0) { + // Write an error because we have more src entries + // then destination space available. + TRACFCOMP(g_trac_dump, "HBDumpCopySrcToDest: not enough Destination table entries"); + /*@ * @errortype * @moduleid DUMP::DUMP_COLLECT - * @reasoncode DUMP::DUMP_CANNOT_UNMAP_DEST - * @userdata1 VA address of the MDDT to unmap - * @userdata2 rc value from unmap - * @devdesc Cannot unmap the source table section + * @reasoncode DUMP::DUMP_MDDT_INSUFFICIENT_ENTRIES + * @userdata1 Source Entires bytes left to copy + * @userdata2 Index into the MDST table + * @devdesc MDDT table is not big enough to + * hold all src entries */ - l_err = new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE, - DUMP_COLLECT, - DUMP_CANNOT_UNMAP_DEST, - (uint64_t)vaMapDestTableAddr, - rc); - - // commit the error and continue. Leave the devices unmapped? - errlCommit(l_err,DUMP_COMP_ID); - - l_err = NULL; + l_err = new ERRORLOG::ErrlEntry( + ERRORLOG::ERRL_SEV_UNRECOVERABLE, + DUMP_COLLECT, + DUMP_MDDT_INSUFFICIENT_ENTRIES, + bytesLeftInSrc, + curSourceIndex); + + // do not commit this errorlog error as this is a + // real problem. + + // TODO: RTC: 64399 + // Need to add the src entries and sizes? that did + // not get copied to the destination. This error + // condition is such that the table entries are + // exceeded. } - // increment to the next dest entry - curDestIndex++; + break; + } - // if made it through all dest entries. - if (curDestIndex >= maxDestEntries) - { - // need to check here to see if we still have SRC - // entries not copied. - if (bytesLeftInSrc != 0) - { - // Write an error because we have more src entries - // then destination space available. - TRACFCOMP(g_trac_dump, "HBDumpCopySrcToDest: not enough Destination table entries"); - - /*@ - * @errortype - * @moduleid DUMP::DUMP_COLLECT - * @reasoncode DUMP::DUMP_MDDT_INSUFFICIENT_ENTRIES - * @userdata1 Source Entires bytes left to copy - * @userdata2 Index into the MDST table - * @devdesc MDDT table is not big enough to hold all src entries - */ - l_err = new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE, - DUMP_COLLECT, - DUMP_MDDT_INSUFFICIENT_ENTRIES, - bytesLeftInSrc, - curSourceIndex); - - // do not commit this errorlog error as this is a - // real problem. - - // TODO: RTC: 64399 - // Need to add the src entries and sizes? that did - // not get copied to the destination. This error - // condition is such that the table entries are exceeded. - } - - break; - } + curDestTableAddr = destTableEntry[curDestIndex].dataAddr; + bytesLeftInDest = destTableEntry[curDestIndex].dataSize; - curDestTableAddr = destTableEntry[curDestIndex].dataAddr; - bytesLeftInDest = destTableEntry[curDestIndex].dataSize; + //check to see if there are contiguous destination addresses + while ((destTableEntry[curDestIndex].dataAddr + + destTableEntry[curDestIndex].dataSize) == + destTableEntry[curDestIndex+1].dataAddr) + { + curDestIndex++; + bytesLeftInDest +=destTableEntry[curDestIndex].dataSize; + } - //check to see if there are contiguous destination addresses - while ((destTableEntry[curDestIndex].dataAddr + - destTableEntry[curDestIndex].dataSize) == - destTableEntry[curDestIndex+1].dataAddr) - { - curDestIndex++; - bytesLeftInDest +=destTableEntry[curDestIndex].dataSize; - } + // If the current dest addr or the size to copy are zero. + if ((curDestTableAddr == 0) || (bytesLeftInDest == 0)) + { - // If the current dest addr or the size to copy are zero. - if ((curDestTableAddr == 0) || (bytesLeftInDest == 0)) + // If there are still SRC entries to copy with no + // destination send an error back. + if (bytesLeftInSrc != 0) { + // Write an error because we have more src entries + // then destination space available. + TRACFCOMP(g_trac_dump, "HBDumpCopySrcToDest: not enough Destination table space"); - // If there are still SRC entries to copy with no - // destination send an error back. - if (bytesLeftInSrc != 0) - { - // Write an error because we have more src entries - // then destination space available. - TRACFCOMP(g_trac_dump, "HBDumpCopySrcToDest: not enough Destination table space"); - - /*@ - * @errortype - * @moduleid DUMP::DUMP_COLLECT - * @reasoncode DUMP::DUMP_MDDT_INSUFFICIENT_SPACE - * @userdata1 Source Entires bytes left to copy - * @userdata2 Index into the MDST table - * @devdesc MDDT table is not big enough to hold all src entries - */ - l_err = new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE, - DUMP_COLLECT, - DUMP_MDDT_INSUFFICIENT_SPACE, - bytesLeftInSrc, - curSourceIndex); - - // do not commit this errorlog error as this is a - // real problem. - - // TODO: RTC: 64399 - // Need to add the src entries and sizes? that did - // not get copied to the destination. This - // condition is such that we have a destination - // entry that either has a zero address or zero - // size.. Perhaps put the bad destination entry - // there as well - } - - break; - } - - destOffset = curDestTableAddr - ALIGN_PAGE_DOWN(curDestTableAddr); - - // If the data size is less then 32GB after page alignment - if (bytesLeftInDest + destOffset > THIRTYTWO_GB) - { - invalidDestSize = true; - break; + /*@ + * @errortype + * @moduleid DUMP::DUMP_COLLECT + * @reasoncode DUMP::DUMP_MDDT_INSUFFICIENT_SPACE + * @userdata1 Source Entires bytes left to copy + * @userdata2 Index into the MDST table + * @devdesc MDDT table is not big enough to + * hold all src entries + */ + l_err = new ERRORLOG::ErrlEntry( + ERRORLOG::ERRL_SEV_UNRECOVERABLE, + DUMP_COLLECT, + DUMP_MDDT_INSUFFICIENT_SPACE, + bytesLeftInSrc, + curSourceIndex); + + // do not commit this errorlog error as this is a + // real problem. + + // TODO: RTC: 64399 + // Need to add the src entries and sizes? that did + // not get copied to the destination. This + // condition is such that we have a destination + // entry that either has a zero address or zero + // size.. Perhaps put the bad destination entry + // there as well } - // map the MDDT to a VA addresss - vaMapDestTableAddr = - (static_cast<uint64_t*>(mm_block_map( - reinterpret_cast<void*>(ALIGN_PAGE_DOWN - (curDestTableAddr & RM_TOP_NIBBLE_MASK)), - THIRTYTWO_GB))); - - vaDestTableAddr = vaMapDestTableAddr; - - vaDestTableAddr += (destOffset/(sizeof(uint64_t))); - - // Current Destination physical and Va address - TRACFCOMP(g_trac_dump, "HBDumpCopySrcToDest DestTableIndex = %d, DestTableAddr = %.16X, VA = %.16X", curDestIndex, curDestTableAddr, vaDestTableAddr); - + break; } + destOffset = curDestTableAddr + - ALIGN_PAGE_DOWN(curDestTableAddr); - // Determine how much to copy.. - sizeToCopy = std::min(bytesLeftInSrc, bytesLeftInDest); - - // Do the copy of the data from the source to the destination - mm_tolerate_ue(1); - memcpy( vaDestTableAddr,vaSrcTableAddr, sizeToCopy); - mm_tolerate_ue(0); - - if (curResultIndex < maxResultEntries) + // If the data size is less then 32GB after page alignment + if (bytesLeftInDest + destOffset > THIRTYTWO_GB) { - // Update the results table - resultsTableEntry->srcAddr = curSrcTableAddr; - resultsTableEntry->destAddr = curDestTableAddr; - resultsTableEntry->dataSize = sizeToCopy; - resultsTableEntry++; - l_resultCount++; - curResultIndex++; + invalidDestSize = true; + break; } - else - { - TRACFCOMP(g_trac_dump, "HBDumpCopySrcToDest: not enough result table space"); - /*@ - * @errortype - * @moduleid DUMP::DUMP_COLLECT - * @reasoncode DUMP::DUMP_MDRT_INSUFFICIENT_SPACE - * @userdata1 Index into the MDRT - * @userdata2 max entries allowed given space allocated - * @devdesc MDRT table is not big enough to hold all entries - */ - l_err = new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE, - DUMP_COLLECT, - DUMP_MDRT_INSUFFICIENT_SPACE, - curResultIndex, - maxResultEntries); + // map the MDDT to a VA addresss + vaMapDestTableAddr = (static_cast<uint64_t*>(mm_block_map( + getPhysAddr(curDestTableAddr), + THIRTYTWO_GB))); - // commit the error and continue. - errlCommit(l_err,DUMP_COMP_ID); + vaDestTableAddr = vaMapDestTableAddr; - l_err = NULL; - } + vaDestTableAddr += (destOffset/(sizeof(uint64_t))); - // decrement the amount copied from the source and destination - bytesLeftInSrc -= sizeToCopy; - bytesLeftInDest -= sizeToCopy; + // Current Destination physical and Va address + TRACFCOMP(g_trac_dump, "HBDumpCopySrcToDest DestTableIndex = %d, DestTableAddr = %.16X, VA = %.16X", curDestIndex, curDestTableAddr, vaDestTableAddr); - uint64_t addrOffset = sizeToCopy/(sizeof (uint64_t)); + } - // increment the current src and dest addresses in both the - // physical and virtual addresses. - curSrcTableAddr += sizeToCopy; - curDestTableAddr += sizeToCopy; - vaSrcTableAddr += addrOffset; - vaDestTableAddr += addrOffset; - } // end of while loop + // Determine how much to copy.. + sizeToCopy = std::min(bytesLeftInSrc, bytesLeftInDest); - if (invalidSrcSize) - { - // Write an error because we have more src entries - // then destination space available. - TRACFCOMP(g_trac_dump, "HBDumpCopySrcToDest: Source TableSize > 32GB"); - - /*@ - * @errortype - * @moduleid DUMP::DUMP_COLLECT - * @reasoncode DUMP::DUMP_MDST_INVALID_TABLE_SIZE - * @userdata1 Size of Source Table Entry - * @userdata2 Size of Page Aligned Source Table Entry - * @devdesc MDST table entry with page aligned is greater than 32GB - */ - l_err = new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE, - DUMP_COLLECT, - DUMP_MDST_INVALID_TABLE_SIZE, - bytesLeftInSrc, - bytesLeftInSrc + srcOffset); - break; + // Do the copy of the data from the source to the destination + mm_tolerate_ue(1); + memcpy( vaDestTableAddr,vaSrcTableAddr, sizeToCopy); + mm_tolerate_ue(0); + if (curResultIndex < maxResultEntries) + { + // Update the results table + resultsTableEntry->srcAddr = + VmmManager::FORCE_PHYS_ADDR|curSrcTableAddr; + resultsTableEntry->destAddr = + VmmManager::FORCE_PHYS_ADDR|curDestTableAddr; + resultsTableEntry->dataSize = sizeToCopy; + resultsTableEntry++; + l_resultCount++; + curResultIndex++; } - if (invalidDestSize) + else { - // Write an error because we have more src entries - // then destination space available. - TRACFCOMP(g_trac_dump, "HBDumpCopySrcToDest: Destination TableSize > 32GB"); + TRACFCOMP(g_trac_dump, "HBDumpCopySrcToDest: not enough result table space"); /*@ * @errortype * @moduleid DUMP::DUMP_COLLECT - * @reasoncode DUMP::DUMP_MDDT_INVALID_TABLE_SIZE - * @userdata1 Size of Destination Table Entry - * @userdata2 Size of Page Aligned Destination Table Entry - * @devdesc MDDT table entry with page aligned is greater than 32GB + * @reasoncode DUMP::DUMP_MDRT_INSUFFICIENT_SPACE + * @userdata1 Index into the MDRT + * @userdata2 max entries allowed given space allocated + * @devdesc MDRT table is not big enough to hold all + * entries */ l_err = new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE, DUMP_COLLECT, - DUMP_MDDT_INVALID_TABLE_SIZE, - bytesLeftInDest, - bytesLeftInDest + destOffset); + DUMP_MDRT_INSUFFICIENT_SPACE, + curResultIndex, + maxResultEntries); - break; + // commit the error and continue. + errlCommit(l_err,DUMP_COMP_ID); + + l_err = NULL; } - //Update actual count in RUNTIME - RUNTIME::saveActualCount(RUNTIME::MS_DUMP_RESULTS_TBL, - l_resultCount); + // decrement the amount copied from the source and destination + bytesLeftInSrc -= sizeToCopy; + bytesLeftInDest -= sizeToCopy; + uint64_t addrOffset = sizeToCopy/(sizeof (uint64_t)); - //Write actual count into memory as well - // We know this will get whacked when FSP reloads the PHYP - // lid, but we want it to be valid before that to allow - // FSP code to consume the data from mainstore - RUNTIME::writeActualCount(RUNTIME::MS_DUMP_RESULTS_TBL); - }while(0);// end of do-while loop + // increment the current src and dest addresses in both the + // physical and virtual addresses. + curSrcTableAddr += sizeToCopy; + curDestTableAddr += sizeToCopy; + vaSrcTableAddr += addrOffset; + vaDestTableAddr += addrOffset; + } // end of while loop - // Got an errorlog back from get_host_data_sections - TRACFCOMP(g_trac_dump, "HBDumpCopySrcToDest - COMPLETE "); - return l_err; - } + if (invalidSrcSize) + { + // Write an error because we have more src entries + // then destination space available. + TRACFCOMP(g_trac_dump, "HBDumpCopySrcToDest: Source TableSize > 32GB"); + + /*@ + * @errortype + * @moduleid DUMP::DUMP_COLLECT + * @reasoncode DUMP::DUMP_MDST_INVALID_TABLE_SIZE + * @userdata1 Size of Source Table Entry + * @userdata2 Size of Page Aligned Source Table Entry + * @devdesc MDST table entry with page aligned is + * greater than 32GB + */ + l_err = new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE, + DUMP_COLLECT, + DUMP_MDST_INVALID_TABLE_SIZE, + bytesLeftInSrc, + bytesLeftInSrc + srcOffset); + break; + + } + if (invalidDestSize) + { + // Write an error because we have more src entries + // then destination space available. + TRACFCOMP(g_trac_dump, "HBDumpCopySrcToDest: Destination TableSize > 32GB"); + + /*@ + * @errortype + * @moduleid DUMP::DUMP_COLLECT + * @reasoncode DUMP::DUMP_MDDT_INVALID_TABLE_SIZE + * @userdata1 Size of Destination Table Entry + * @userdata2 Size of Page Aligned Destination Table Entry + * @devdesc MDDT table entry with page aligned is + * greater than 32GB + */ + l_err = new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE, + DUMP_COLLECT, + DUMP_MDDT_INVALID_TABLE_SIZE, + bytesLeftInDest, + bytesLeftInDest + destOffset); + + break; + } + + //Update actual count in RUNTIME + RUNTIME::saveActualCount(RUNTIME::MS_DUMP_RESULTS_TBL, + l_resultCount); + + + //Write actual count into memory as well + // We know this will get whacked when FSP reloads the PHYP + // lid, but we want it to be valid before that to allow + // FSP code to consume the data from mainstore + RUNTIME::writeActualCount(RUNTIME::MS_DUMP_RESULTS_TBL); + }while(0);// end of do-while loop + + // Got an errorlog back from get_host_data_sections + TRACFCOMP(g_trac_dump, "HBDumpCopySrcToDest - COMPLETE "); + + return l_err; +} @@ -685,7 +727,8 @@ errlHndl_t doDumpCollect(void) // Each results table entry has the Source,Destination and Size for // each copy that is done from source to destination - resultsTableEntry = reinterpret_cast<resultsEntry *>(resultsTableAddr); + resultsTableEntry = + reinterpret_cast<resultsEntry *>(resultsTableAddr); TRACFCOMP(g_trac_dump, "gethostDataPtrs SrcTableAddr = %.16x, DestTableAddr = %.16X, resultTableAddr = %.16X", diff --git a/src/usr/dump/dumpCollect.H b/src/usr/dump/dumpCollect.H index b7bf59c6f..6fbca9faa 100644 --- a/src/usr/dump/dumpCollect.H +++ b/src/usr/dump/dumpCollect.H @@ -5,7 +5,7 @@ /* */ /* IBM CONFIDENTIAL */ /* */ -/* COPYRIGHT International Business Machines Corp. 2012,2013 */ +/* COPYRIGHT International Business Machines Corp. 2012,2014 */ /* */ /* p1 */ /* */ @@ -32,11 +32,6 @@ namespace DUMP { - enum - { - RM_TOP_NIBBLE_MASK = 0x0FFFFFFFFFFFFFFFULL, - }; - /** * @brief This routine retrieves first entry of the MDST, MDDT and * MDRT and the size of each of those tables. diff --git a/src/usr/dump/test/dumptest.H b/src/usr/dump/test/dumptest.H index edf9a37aa..63a5f7442 100644 --- a/src/usr/dump/test/dumptest.H +++ b/src/usr/dump/test/dumptest.H @@ -5,7 +5,7 @@ /* */ /* IBM CONFIDENTIAL */ /* */ -/* COPYRIGHT International Business Machines Corp. 2012,2013 */ +/* COPYRIGHT International Business Machines Corp. 2012,2014 */ /* */ /* p1 */ /* */ @@ -122,12 +122,14 @@ class DumpTest: public CxxTest::TestSuite uint64_t src_data[8] = {DUMP_TEST_SRC_DATA_AREA, 64, // 450000 DUMP_TEST_SRC_DATA_AREA + 64, 64, - DUMP_TEST_SRC_DATA_AREA + 192, 64, + (0x8000000000000000 | DUMP_TEST_SRC_DATA_AREA) + + 192, 64, DUMP_TEST_SRC_DATA_AREA + 256, 64}; uint64_t dst_data[8] = {DUMP_TEST_DST_DATA_AREA, 64, // 460000 - DUMP_TEST_DST_DATA_AREA + 64, 64, + (0x8000000000000000 | DUMP_TEST_DST_DATA_AREA) + + 64, 64, DUMP_TEST_DST_DATA_AREA + 256, 64, DUMP_TEST_DST_DATA_AREA + 512, 64}; @@ -164,21 +166,21 @@ class DumpTest: public CxxTest::TestSuite // results output data expected uint64_t result_data[] = { - DUMP_TEST_SRC_DATA_AREA, - DUMP_TEST_DST_DATA_AREA, - 64, 0, + 0x8000000000000000|DUMP_TEST_SRC_DATA_AREA, + 0x8000000000000000|DUMP_TEST_DST_DATA_AREA, + 64, 0, - DUMP_TEST_SRC_DATA_AREA +64, - DUMP_TEST_DST_DATA_AREA +64, - 64, 0, + (0x8000000000000000|DUMP_TEST_SRC_DATA_AREA) +64, + (0x8000000000000000|DUMP_TEST_DST_DATA_AREA) +64, + 64, 0, - DUMP_TEST_SRC_DATA_AREA+192, - DUMP_TEST_DST_DATA_AREA+256, - 64, 0, + (0x8000000000000000|DUMP_TEST_SRC_DATA_AREA)+192, + (0x8000000000000000|DUMP_TEST_DST_DATA_AREA)+256, + 64, 0, - DUMP_TEST_SRC_DATA_AREA+256, - DUMP_TEST_DST_DATA_AREA+512, - 64, 0, + (0x8000000000000000|DUMP_TEST_SRC_DATA_AREA)+256, + (0x8000000000000000|DUMP_TEST_DST_DATA_AREA)+512, + 64, 0, }; uint64_t *va_mapsrcTableAddr = 0; @@ -389,20 +391,20 @@ class DumpTest: public CxxTest::TestSuite // results output data expected uint64_t result_data[] = { - DUMP_TEST_SRC_DATA_AREA+256, - DUMP_TEST_DST_DATA_AREA+1024, 64, 0, + (0x8000000000000000|DUMP_TEST_SRC_DATA_AREA)+256, + (0x8000000000000000|DUMP_TEST_DST_DATA_AREA)+1024, 64, 0, - DUMP_TEST_SRC_DATA_AREA+256+64, - DUMP_TEST_DST_DATA_AREA+1024+64, 32, 0, + (0x8000000000000000|DUMP_TEST_SRC_DATA_AREA)+256+64, + (0x8000000000000000|DUMP_TEST_DST_DATA_AREA)+1024+64, 32, 0, - DUMP_TEST_SRC_DATA_AREA+256+64+32, - DUMP_TEST_DST_DATA_AREA+1024+256, 32, 0, + (0x8000000000000000|DUMP_TEST_SRC_DATA_AREA)+256+64+32, + (0x8000000000000000|DUMP_TEST_DST_DATA_AREA)+1024+256, 32, 0, - DUMP_TEST_SRC_DATA_AREA+256+128, - DUMP_TEST_DST_DATA_AREA+1024+128, 64, 0, + (0x8000000000000000|DUMP_TEST_SRC_DATA_AREA)+256+128, + (0x8000000000000000|DUMP_TEST_DST_DATA_AREA)+1024+128, 64, 0, - DUMP_TEST_SRC_DATA_AREA+256+128+64, - DUMP_TEST_DST_DATA_AREA+1024+128+64, 64, 0, + (0x8000000000000000|DUMP_TEST_SRC_DATA_AREA)+256+128+64, + (0x8000000000000000|DUMP_TEST_DST_DATA_AREA)+1024+128+64, 64, 0, }; uint64_t *va_mapsrcTableAddr = 0; @@ -710,27 +712,27 @@ class DumpTest: public CxxTest::TestSuite // results output data expected - uint64_t result_data[] = { - DUMP_TEST_SRC_DATA_AREA+1024, - DUMP_TEST_DST_DATA_AREA+2048, - 16, 0, + uint64_t result_data[] = { + (0x8000000000000000|DUMP_TEST_SRC_DATA_AREA)+1024, + (0x8000000000000000|DUMP_TEST_DST_DATA_AREA)+2048, + 16, 0, - DUMP_TEST_SRC_DATA_AREA+2048, - DUMP_TEST_DST_DATA_AREA+2048+16, - 48, 0, + (0x8000000000000000|DUMP_TEST_SRC_DATA_AREA)+2048, + (0x8000000000000000|DUMP_TEST_DST_DATA_AREA)+2048+16, + 48, 0, - DUMP_TEST_SRC_DATA_AREA+3072, - DUMP_TEST_DST_DATA_AREA+2048+128, - 32, 0, + (0x8000000000000000|DUMP_TEST_SRC_DATA_AREA)+3072, + (0x8000000000000000|DUMP_TEST_DST_DATA_AREA)+2048+128, + 32, 0, - DUMP_TEST_SRC_DATA_AREA+4096, - DUMP_TEST_DST_DATA_AREA+3072, - 32, 0, + (0x8000000000000000|DUMP_TEST_SRC_DATA_AREA)+4096, + (0x8000000000000000|DUMP_TEST_DST_DATA_AREA)+3072, + 32, 0, - DUMP_TEST_SRC_DATA_AREA+4096+32, - DUMP_TEST_DST_DATA_AREA+3072+64, - 128, 0, - }; + (0x8000000000000000|DUMP_TEST_SRC_DATA_AREA)+4096+32, + (0x8000000000000000|DUMP_TEST_DST_DATA_AREA)+3072+64, + 128, 0, + }; do { @@ -1184,14 +1186,16 @@ class DumpTest: public CxxTest::TestSuite uint64_t *dstTablePtr = reinterpret_cast<uint64_t *>(destTable); uint64_t src_data[8] = {DUMP_TEST_SRC_DATA_AREA, 64, // 450000 - DUMP_TEST_SRC_DATA_AREA + 64, 64, + (0x8000000000000000 | DUMP_TEST_SRC_DATA_AREA) + + 64, 64, DUMP_TEST_SRC_DATA_AREA + 128, 64, DUMP_TEST_SRC_DATA_AREA + 192, 64}; uint64_t dst_data[8] = {DUMP_TEST_DST_DATA_AREA+4096, 64, // 4601000 DUMP_TEST_DST_DATA_AREA + 4096 + 64, 64, - DUMP_TEST_DST_DATA_AREA + 4096 + 128, 64, + (0x8000000000000000 | DUMP_TEST_DST_DATA_AREA) + + 4096 + 128, 64, DUMP_TEST_DST_DATA_AREA + 4096 + 192, 32}; // NOTE>> TOO SMALL of a space.. |