diff options
| -rwxr-xr-x | src/build/citest/etc/workarounds.presimsetup | 7 | ||||
| -rw-r--r-- | src/include/usr/sbeio/sbeioreasoncodes.H | 3 | ||||
| -rw-r--r-- | src/include/usr/vmmconst.h | 10 | ||||
| -rw-r--r-- | src/usr/sbeio/sbe_memRegionMgr.C | 220 | ||||
| -rw-r--r-- | src/usr/sbeio/sbe_memRegionMgr.H | 19 | ||||
| -rw-r--r-- | src/usr/sbeio/sbe_psudd.C | 12 | ||||
| -rw-r--r-- | src/usr/sbeio/test/sbe_memregiontest.H | 133 |
7 files changed, 332 insertions, 72 deletions
diff --git a/src/build/citest/etc/workarounds.presimsetup b/src/build/citest/etc/workarounds.presimsetup index 9e47863ae..bc7b98e21 100755 --- a/src/build/citest/etc/workarounds.presimsetup +++ b/src/build/citest/etc/workarounds.presimsetup @@ -35,3 +35,10 @@ #echo "WSALIAS DEFAULT FIPSLEVEL env/gfwb/simics-4.2.0/simics-4.2.83/fips/fld36/fi120201a700.42" >> $sb/simu/data/simicsInfo #echo "WSALIAS DEFAULT SIMICSLEVEL env/vtechb/simics-4.2.0/simics-4.2.83/bin" >> $sb/simu/data/simicsInfo +# Pull in SBE Support of Unsecure Memory Regions +echo "Pull in SBE Support of Unsecure Memory Regions" +sbex -t 1030098 +mkdir -p $sb/sbei/sbfw/ +cd $sb/sbei/sbfw +chmod 777 -R . +mk -a -k diff --git a/src/include/usr/sbeio/sbeioreasoncodes.H b/src/include/usr/sbeio/sbeioreasoncodes.H index 43c33395e..4746ff16e 100644 --- a/src/include/usr/sbeio/sbeioreasoncodes.H +++ b/src/include/usr/sbeio/sbeioreasoncodes.H @@ -102,6 +102,7 @@ enum sbeioReasonCode // SBE Unsecure Memory Region error codes SBEIO_MEM_REGION_DOES_NOT_EXIST = SBEIO_COMP_ID | 0x50, + SBEIO_EXCEEDS_MAXIMUM_MEM_REGIONS = SBEIO_COMP_ID | 0x51, // Remove once we collect the FFDC ourselves - @todo-RTC:144313 //termination_rc @@ -115,6 +116,6 @@ enum UserDetailsTypes }; -}; // end SBE +}; // end SBEIO #endif diff --git a/src/include/usr/vmmconst.h b/src/include/usr/vmmconst.h index b19980941..dc422a1f9 100644 --- a/src/include/usr/vmmconst.h +++ b/src/include/usr/vmmconst.h @@ -214,6 +214,10 @@ enum BlockPriority /** Block size used in remove pages test */ #define VMM_SIZE_RMVPAGE_TEST (8 * PAGESIZE) +/** + * Physical Memory Constants + */ + /** Physical memory location of the TCE Table */ /** - needs to be aligned on 4MB boundary */ #define TCE_TABLE_ADDR (88*MEGABYTE) @@ -221,4 +225,10 @@ enum BlockPriority /** The TCE Table size is 512K entries each uint64_t (8 bytes) in size */ #define TCE_TABLE_SIZE ((512*KILOBYTE)*sizeof(uint64_t)) +/** Physical memory location used for Unsecure Memory Region Testing */ +/** - place it after TCE Table */ +#define UNSECURE_MEM_REGION_ADDR_TEST (TCE_TABLE_ADDR + TCE_TABLE_SIZE) + +#define UNSECURE_MEM_REGION_SIZE_TEST (1*KILOBYTE) + #endif /* _VMMCONST_H */ diff --git a/src/usr/sbeio/sbe_memRegionMgr.C b/src/usr/sbeio/sbe_memRegionMgr.C index b598b3cef..01c6ed5c5 100644 --- a/src/usr/sbeio/sbe_memRegionMgr.C +++ b/src/usr/sbeio/sbe_memRegionMgr.C @@ -36,16 +36,16 @@ #include <targeting/common/targetservice.H> #include <vmmconst.h> #include <sys/misc.h> +#include <secureboot/service.H> #include "sbe_memRegionMgr.H" extern trace_desc_t* g_trac_sbeio; #define SBE_TRACD(printf_string,args...) \ -TRACDCOMP(g_trac_sbeio,"memRegion: " printf_string,##args) - + TRACDCOMP(g_trac_sbeio,"memRegion: " printf_string,##args) #define SBE_TRACF(printf_string,args...) \ -TRACFCOMP(g_trac_sbeio,"memRegion: " printf_string,##args) + TRACFCOMP(g_trac_sbeio,"memRegion: " printf_string,##args) namespace SBEIO { @@ -102,7 +102,7 @@ MemRegionMgr::MemRegionMgr() hb_dump_region.flags = SbePsu::SBE_MEM_REGION_OPEN_READ_ONLY; iv_memRegions.push_back(hb_dump_region); - SBE_TRACF("MemRegionMgr Constructor: Initial region(s):"); + SBE_TRACD("MemRegionMgr Constructor: Initial region(s):"); printIvMemRegions(); SBE_TRACD(EXIT_MRK"MemRegionMgr Constructor"); @@ -130,6 +130,7 @@ errlHndl_t MemRegionMgr::openUnsecureMemRegion( errlHndl_t errl = nullptr; regionData l_region; + uint8_t region_count = iv_memRegions.size(); bool itr_region_closed = false; const uint8_t input_flags = i_isWritable ? SbePsu::SBE_MEM_REGION_OPEN_READ_WRITE : @@ -137,22 +138,19 @@ errlHndl_t MemRegionMgr::openUnsecureMemRegion( SBE_TRACF(ENTER_MRK"openUnsecureMemRegion: i_tgt=0x%X: " "i_start_addr=0x%.16llX, i_size=0x%.8X, i_isWritable=%d " - "(flags=0x%.2X)", + "(flags=0x%.2X), count=%d", TARGETING::get_huid(i_target), i_start_addr, i_size, - i_isWritable, input_flags); + i_isWritable, input_flags, region_count); assert(i_size!=0, "openUnsecureMemRegion: i_size=0"); do { // Handle 'Open' Request - // -- Look for identical region - // ---- if so, fail // -- Look for possible overlap with existing regions // ---- If overlap, close existing regions and re-open // all regions as necessary // ---- If no overlap, open requested region - - // @TODO RTC 174970 - Add checks to not exceed 8 memory regions + // Throughout check that no more than 8 memory regions are opened auto itr = iv_memRegions.begin(); while (itr != iv_memRegions.end()) @@ -191,31 +189,42 @@ errlHndl_t MemRegionMgr::openUnsecureMemRegion( } else { + // Update count + --region_count; + // This region will be removed from the cache list later itr_region_closed = true; } // Re-Open Non-overlapping initial part of Existing Region - l_region.start_addr = itr->start_addr; + // NOTE: skipping max count check since we already closed a + // region above l_region.size = i_start_addr - itr->start_addr; l_region.flags = itr->flags; l_region.tgt = itr->tgt; - errl = doUnsecureMemRegionOp(l_region); - - if (errl) + if (l_region.size > 0) { - SBE_TRACF(ERR_MRK "openUnsecureMemRegion: Re-Open Op " - "Failed: err rc=0x%.4X plid=0x%.8X", - ERRL_GETRC_SAFE(errl), ERRL_GETPLID_SAFE(errl)); + errl = doUnsecureMemRegionOp(l_region); - // Return error to caller ASAP - break; - } - else - { - // Add the region to the cache list - iv_memRegions.push_front(l_region); + if (errl) + { + SBE_TRACF(ERR_MRK "openUnsecureMemRegion: Re-Open Op " + "Failed: err rc=0x%.4X plid=0x%.8X", + ERRL_GETRC_SAFE(errl), + ERRL_GETPLID_SAFE(errl)); + + // Return error to caller ASAP + break; + } + else + { + // Update count + ++region_count; + + // Add the region to the cache list + iv_memRegions.push_front(l_region); + } } } @@ -258,7 +267,14 @@ errlHndl_t MemRegionMgr::openUnsecureMemRegion( } // Re-open, non-overlapping back end part of - // Existing Region + // Existing Region, but first check that we're not exceeding + // the maximum allowed number of regions + errl = checkNumberOfMemRegions(region_count); + if (errl) + { + break; + } + l_region.start_addr = i_start_addr + i_size; l_region.size = (itr->start_addr + itr->size) - (i_start_addr + i_size); @@ -279,6 +295,9 @@ errlHndl_t MemRegionMgr::openUnsecureMemRegion( } else { + // Update count + ++region_count; + // Add the region to the cache list iv_memRegions.push_front(l_region); } @@ -317,6 +336,9 @@ errlHndl_t MemRegionMgr::openUnsecureMemRegion( } else { + // Update count + --region_count; + // This region will be removed from the cache list later itr_region_closed = true; } @@ -340,8 +362,14 @@ errlHndl_t MemRegionMgr::openUnsecureMemRegion( break; } + // Open Requested Region, but first check that we're not exceeding + // the maximum allowed number of regions + errl = checkNumberOfMemRegions(region_count); + if (errl) + { + break; + } - // Open Requested Region l_region.start_addr = i_start_addr; l_region.size = i_size; l_region.flags = input_flags; @@ -366,7 +394,6 @@ errlHndl_t MemRegionMgr::openUnsecureMemRegion( } while (0); - // TODO RTC 174970 remove when base support is working printIvMemRegions(); SBE_TRACF(EXIT_MRK "openUnsecureMemRegion: i_tgt=0x%X: " @@ -374,6 +401,18 @@ errlHndl_t MemRegionMgr::openUnsecureMemRegion( TARGETING::get_huid(i_target), i_start_addr, ERRL_GETRC_SAFE(errl)); + if(errl) + { + errl->collectTrace(SBEIO_COMP_NAME); + + // If error log is informational, commit it here rather + // than passing back an error and risk stopping the IPL + if (errl->sev() == ERRORLOG::ERRL_SEV_INFORMATIONAL) + { + errlCommit(errl, SBEIO_COMP_ID); + } + } + return errl; } @@ -457,6 +496,9 @@ errlHndl_t MemRegionMgr::closeUnsecureMemRegion( i_start_addr, iv_memRegions.size(), true /*Add HB SW Callout*/ ); + + errl->collectTrace(SBEIO_COMP_NAME); + break; } @@ -464,10 +506,22 @@ errlHndl_t MemRegionMgr::closeUnsecureMemRegion( while (0); SBE_TRACF(EXIT_MRK "closeUnsecureMemRegion: i_tgt: 0x%X: " - "i_start_addr0x%.16llX: err_rc=0x%4X", + "i_start_addr0x%.16llX: err_rc=0x%.4X", TARGETING::get_huid(i_target), i_start_addr, ERRL_GETRC_SAFE(errl)); + if(errl) + { + errl->collectTrace(SBEIO_COMP_NAME); + + // If error log is informational, commit it here rather + // than passing back an error and risk stopping the IPL + if (errl->sev() == ERRORLOG::ERRL_SEV_INFORMATIONAL) + { + errlCommit(errl, SBEIO_COMP_ID); + } + } + return errl; } @@ -513,7 +567,7 @@ errlHndl_t MemRegionMgr::closeAllUnsecureMemRegions() // commit new error with orignal err PLID errl->plid(errl_orig->plid()); - + errl->collectTrace(SBEIO_COMP_NAME); errlCommit(errl, SBEIO_COMP_ID); // Skip region since it failed to close @@ -547,6 +601,17 @@ errlHndl_t MemRegionMgr::closeAllUnsecureMemRegions() "err_rc=0x%.4X", iv_memRegions.size(), ERRL_GETRC_SAFE(errl_orig)); + if(errl_orig) + { + errl_orig->collectTrace(SBEIO_COMP_NAME); + + // If error log is informational, commit it here rather + // than passing back an error and risk stopping the IPL + if (errl_orig->sev() == ERRORLOG::ERRL_SEV_INFORMATIONAL) + { + errlCommit(errl_orig, SBEIO_COMP_ID); + } + } return errl_orig; } @@ -560,8 +625,7 @@ errlHndl_t MemRegionMgr::doUnsecureMemRegionOp(regionData & i_region) errlHndl_t errl = nullptr; TARGETING::Target * l_tgt = i_region.tgt; - // @TODO RTC 174970 - make TRACD when SBE support is tested - SBE_TRACF(ENTER_MRK"doUnsecureMemRegionOp: tgt=0x%.8X: " + SBE_TRACD(ENTER_MRK"doUnsecureMemRegionOp: tgt=0x%.8X: " "start_addr=0x%.16llX, size=0x%.8X, controlFlags=0x%.2X", TARGETING::get_huid(l_tgt), i_region.start_addr, i_region.size, i_region.flags); @@ -599,29 +663,43 @@ errlHndl_t MemRegionMgr::doUnsecureMemRegionOp(regionData & i_region) l_psuCommand.cd6_memRegion_Size = i_region.size; l_psuCommand.cd6_memRegion_Start_Addr = i_region.start_addr; -// @TODO RTC 174970 - Activate code block when SBE support is tested -#if 0 errl = SBEIO::SbePsu::getTheInstance().performPsuChipOp(l_tgt, &l_psuCommand, &l_psuResponse, SbePsu::MAX_PSU_SHORT_TIMEOUT_NS, - SbePsu::SBE_MEMORY_REGION_REQ_USED_REGS, - SbePsu::SBE_MEMORY_REGION_RSP_USED_REGS); -#endif + SbePsu::SBE_MEM_REGION_REQ_USED_REGS, + SbePsu::SBE_MEM_REGION_RSP_USED_REGS); + if (errl) { SBE_TRACF(ERR_MRK "doUnsecureMemRegionOp: PSU Cmd Failed: " "err rc=0x%.4X plid=0x%.8X (mbxReg0=0x%.16llX)", ERRL_GETRC_SAFE(errl), ERRL_GETPLID_SAFE(errl), l_psuCommand.mbxReg0); + + // If Secureboot is not enabled, make the error from the SBE not + // supporting Security Control Messages Control command class (which + // includes the Unsecure Memory Region commands) Informational + if ((!SECUREBOOT::enabled()) && + (l_psuResponse.primaryStatus == + SbePsu::SBE_PRI_INVALID_COMMAND) && + (l_psuResponse.secondaryStatus == + SbePsu::SBE_SEC_COMMAND_CLASS_NOT_SUPPORTED) + ) + { + SBE_TRACF(ERR_MRK "doUnsecureMemRegionOp: Secureboot NOT " + "Enabled - Changing 'Command Class Not Supported' " + "Error Log To Informational."); + errl->setSev(ERRORLOG::ERRL_SEV_INFORMATIONAL); + errl->collectTrace(SBEIO_COMP_NAME); + } + break; } - } while (0); - // @TODO RTC 174970 - make TRACD when SBE support is tested - SBE_TRACF(EXIT_MRK "doUnsecureMemRegionOp: tgt=0x%.8X: " + SBE_TRACD(EXIT_MRK "doUnsecureMemRegionOp: tgt=0x%.8X: " "start_addr=0x%.16llX, size=0x%.8X, controlFlags=0x%.2X: " "err_rc=0x%.4X", TARGETING::get_huid(l_tgt), i_region.start_addr, i_region.size, @@ -631,22 +709,68 @@ errlHndl_t MemRegionMgr::doUnsecureMemRegionOp(regionData & i_region) } /** + * MemRegionMgr::checkNumberOfMemRegions + * - see sbe_unsecureMemRegionMgr.H for details + */ +errlHndl_t MemRegionMgr::checkNumberOfMemRegions(uint8_t i_count) const +{ + errlHndl_t errl = nullptr; + + if (i_count >= SBEIO_MAX_UNSECURE_MEMORY_REGIONS) + { + SBE_TRACF(ERR_MRK"checkNumberOfMemRegions: Current count=%d, max=%d. " + "New Region Cannot Be Opened", + i_count, SBEIO_MAX_UNSECURE_MEMORY_REGIONS); + + /*@ + * @errortype + * @moduleid SBEIO_MEM_REGION + * @reasoncode SBEIO_EXCEEDS_MAXIMUM_MEM_REGIONS + * @userdata1 Current Count of Unsecure Memory Regions + * @userdata2 Maximum Number of Unsecure Memomory Regions + * @devdesc Attempt To Open Too Many Unsecure Memory Regions + * @custdesc A problem occurred during the IPL + */ + errl = new ERRORLOG::ErrlEntry( + ERRORLOG::ERRL_SEV_UNRECOVERABLE, + SBEIO_MEM_REGION, + SBEIO_EXCEEDS_MAXIMUM_MEM_REGIONS, + i_count, + SBEIO_MAX_UNSECURE_MEMORY_REGIONS, + true /*Add HB SW Callout*/ ); + + errl->collectTrace(SBEIO_COMP_NAME); + } + + return errl; +} + +/** * MemRegionMgr::printIvMemRegions * - see sbe_unsecureMemRegionMgr.H for details */ void MemRegionMgr::printIvMemRegions(void) const { - SBE_TRACF("MemRegionMgr::printIvMemRegions: number of entries=%d", - iv_memRegions.size()); + const uint8_t size = iv_memRegions.size(); - for ( const auto& itr : iv_memRegions ) + if ( size == 0 ) + { + SBE_TRACD("MemRegionMgr::printIvMemRegions: number of entries=%d", + iv_memRegions.size()); + } + else { - SBE_TRACF("printIvMemRegions: tgt=0x%.8X: start_addr=0x%.16llX, " - "size=0x%.8X, flags=0x%.2X (%s)", - TARGETING::get_huid(itr.tgt), itr.start_addr, - itr.size, itr.flags, - itr.flags == SbePsu::SBE_MEM_REGION_OPEN_READ_ONLY ? - "Read-Only" : "Read-Write"); + uint8_t count = 1; + for ( const auto& itr : iv_memRegions ) + { + SBE_TRACD("printIvMemRegions: %d/%d: tgt=0x%.8X: " + "start_addr=0x%.16llX, size=0x%.8X, flags=0x%.2X (%s)", + count, size, TARGETING::get_huid(itr.tgt), + itr.start_addr, itr.size, itr.flags, + itr.flags == SbePsu::SBE_MEM_REGION_OPEN_READ_ONLY ? + "Read-Only" : "Read-Write"); + ++count; + } } } diff --git a/src/usr/sbeio/sbe_memRegionMgr.H b/src/usr/sbeio/sbe_memRegionMgr.H index d0b3fc4b1..0fc9f27bf 100644 --- a/src/usr/sbeio/sbe_memRegionMgr.H +++ b/src/usr/sbeio/sbe_memRegionMgr.H @@ -32,6 +32,11 @@ namespace SBEIO { +/* + * @brief Define Specifying The Maximum Number Of Unsecure Memory Regions That + * the SBE Supports + */ +#define SBEIO_MAX_UNSECURE_MEMORY_REGIONS 8 /* * @brief Struct containing specifics of a Unsecure Memory Region @@ -77,6 +82,18 @@ class MemRegionMgr */ errlHndl_t doUnsecureMemRegionOp(regionData & i_region); + /** + * @brief Checks That The Maximum Number of Unsecure Memory Regions That The + * SBE Supports Is Not Exceeded If A New Region Is Opened + * + * @param[in] i_count Current count of opened unsecure memory regions + * + * @return errlHndl_t Error log handle if current size of iv_memRegions is + * equal to or exceeds the maximum number of regions that + * the SBE Supports; otherwise, returns nullptr + */ + errlHndl_t checkNumberOfMemRegions(uint8_t i_count) const; + public: /** * @brief Constructor. Initializes instance variables. @@ -120,7 +137,7 @@ class MemRegionMgr const bool i_isWritable, TARGETING::Target* i_target); - /** + /** * @brief Close Unsecure Memory Region * * @note: See closeUnsecureMemRegion() function in sbeioif.H for details diff --git a/src/usr/sbeio/sbe_psudd.C b/src/usr/sbeio/sbe_psudd.C index 7c24cf327..7796cd55b 100644 --- a/src/usr/sbeio/sbe_psudd.C +++ b/src/usr/sbeio/sbe_psudd.C @@ -164,7 +164,11 @@ errlHndl_t SbePsu::performPsuChipOp(TARGETING::Target * i_target, mutex_unlock(&l_psuOpMux); - if( errl && (SBEIO_PSU == errl->moduleId()) ) + if( errl && (SBEIO_PSU == errl->moduleId()) + // For this special case pass back errl without commiting or + // collecting FFDC/shutting down + && (SBE_PSU_SET_UNSECURE_MEMORY_REGION_CMD != i_pPsuRequest->command) + ) { SBE_TRACF( "Forcing shutdown for FSP to collect FFDC" ); @@ -217,7 +221,11 @@ errlHndl_t SbePsu::writeRequest(TARGETING::Target * i_target, { // assign sequence ID and save to check that response matches i_pPsuRequest->seqID = ++l_seqID; - SBE_TRACF("Sending Req = %.16X", i_pPsuRequest->mbxReg0); + SBE_TRACF("Sending Req = %.16X %.16X %.16X %.16X", + i_pPsuRequest->mbxReg0, + i_pPsuRequest->mbxReg1, + i_pPsuRequest->mbxReg2, + i_pPsuRequest->mbxReg3); // Read SBE doorbell to confirm ready to accept command. // Since the device driver single threads the requests, we should diff --git a/src/usr/sbeio/test/sbe_memregiontest.H b/src/usr/sbeio/test/sbe_memregiontest.H index 2c2c87121..87cb4a040 100644 --- a/src/usr/sbeio/test/sbe_memregiontest.H +++ b/src/usr/sbeio/test/sbe_memregiontest.H @@ -22,11 +22,11 @@ /* permissions and limitations under the License. */ /* */ /* IBM_PROLOG_END_TAG */ -#ifndef __SBE_MEMREGION_H -#define __SBE_MEMREGION_H +#ifndef __SBE_MEMREGIONTEST_H +#define __SBE_MEMREGIONTEST_H /** - * @file sbe_ffdctest.H + * @file sbe_memregiontest.H * * @brief Test cases for Opening/Closing SBE/HB Memory Regions */ @@ -35,7 +35,14 @@ #include <errl/errlentry.H> #include <errl/errlmanager.H> #include <sbeio/sbeioif.H> +#include <sbeio/sbeioreasoncodes.H> +#include <vmmconst.h> +#include <sys/mm.h> +#include "../sbe_memRegionMgr.H" + +#define SBE_TRACD_MRT(printf_string,args...) \ + TRACDCOMP(g_trac_sbeio,"memRegionTest: " printf_string,##args) #define SBE_TRACF_MRT(printf_string,args...) \ TRACFCOMP(g_trac_sbeio,"memRegionTest: " printf_string,##args) @@ -57,17 +64,68 @@ class SbeMemRegionTest : public CxxTest::TestSuite // Reserve and Open Random Overlapping Memory Regions to force // MemRegionMgr to update regions around each other - // Malloc memory buffer to play with - // @TODO RTC 174970 - reserve a buffer of Physical Memory and use - // Physical addresses so that SBEIO commands will be successful - uint32_t mem_buf_size = 256; - void * mem_buf = malloc(mem_buf_size); - uint64_t mem_buf_start_addr = - reinterpret_cast<uint64_t>(mem_buf); + // Reserve the Physical Memory set aside in vmmconst.h to use + // for this test so that the SBEIO commands will work + uint32_t mem_buf_size = UNSECURE_MEM_REGION_SIZE_TEST; + uint64_t mem_buf_start_addr = UNSECURE_MEM_REGION_ADDR_TEST; + void * tmp_virtual_addr = mm_block_map( + reinterpret_cast<void*> + (UNSECURE_MEM_REGION_ADDR_TEST), + UNSECURE_MEM_REGION_SIZE_TEST); + assert(tmp_virtual_addr!=nullptr, "memRegionTest1: tmp_virtual_addr is nullptr"); do { + // Loop Test: Open MAX+1 to force a fail + for (size_t i = 1; i<=SBEIO_MAX_UNSECURE_MEMORY_REGIONS+1 ; i++) + { + errl = SBEIO::openUnsecureMemRegion(mem_buf_start_addr + + ((i-1)*32), + 16, + true); //true=Read-Write + + if (i <= SBEIO_MAX_UNSECURE_MEMORY_REGIONS) + { + // Expect the open to succeed + if (errl) + { + TS_FAIL("memRegionTest1: Loop Test-%d: SBEIO::openUnsecureMemRegion() Failed: rc=0x%X, plid=0x%X", + i, ERRL_GETRC_SAFE(errl), ERRL_GETPLID_SAFE(errl)); + break; + } + else + { + SBE_TRACD_MRT("memRegionTest1: Loop Test-%d: SBEIO::openUnsecureMemRegion() SUCCESSFUL", i); + } + } + else // i = SBEIO_MAX_UNSECURE_MEMORY_REGIONS + 1 + { + // Expect the open to fail with the return code + // SBEIO_EXCEEDS_MAXIMUM_MEM_REGIONS + if (ERRL_GETRC_SAFE(errl)==SBEIO::SBEIO_EXCEEDS_MAXIMUM_MEM_REGIONS) + { + SBE_TRACF_MRT("memRegionTest1: Loop Test-%d: SBEIO::openUnsecureMemRegion() Returned Expected Fail: rc=0x%X, plid=0x%X", + i, ERRL_GETRC_SAFE(errl), ERRL_GETPLID_SAFE(errl)); + delete errl; + errl = nullptr; + } + else + { + TS_FAIL("memRegionTest1: Loop Test-%d: SBEIO::openUnsecureMemRegion() Did NOT Return Expected Fail rc=0x%X: got rc=0x%X, plid=0x%X", + i, SBEIO::SBEIO_EXCEEDS_MAXIMUM_MEM_REGIONS, + ERRL_GETRC_SAFE(errl), ERRL_GETPLID_SAFE(errl)); + break; + } + } + } + + // Skip the rest of the testcase if we already have an error log + if(errl) + { + break; + } + // Test 1: Open Read-Write region for front half of memory buffer errl = SBEIO::openUnsecureMemRegion(mem_buf_start_addr, mem_buf_size/2, @@ -80,7 +138,7 @@ class SbeMemRegionTest : public CxxTest::TestSuite } else { - SBE_TRACF_MRT("memRegionTest1: T1: SBEIO::openUnsecureMemRegion() SUCCESSFUL"); + SBE_TRACD_MRT("memRegionTest1: T1: SBEIO::openUnsecureMemRegion() SUCCESSFUL"); } // Test 2: Open Overlapping Read-Only region for middle chunk of @@ -96,7 +154,7 @@ class SbeMemRegionTest : public CxxTest::TestSuite } else { - SBE_TRACF_MRT("memRegionTest1: T2: SBEIO::openUnsecureMemRegion() SUCCESSFUL"); + SBE_TRACD_MRT("memRegionTest1: T2: SBEIO::openUnsecureMemRegion() SUCCESSFUL"); } // Test 3: Open Overlapping Read-Write region completely enclosed by @@ -112,7 +170,7 @@ class SbeMemRegionTest : public CxxTest::TestSuite } else { - SBE_TRACF_MRT("memRegionTest1: T3: SBEIO::openUnsecureMemRegion() SUCCESSFUL"); + SBE_TRACD_MRT("memRegionTest1: T3: SBEIO::openUnsecureMemRegion() SUCCESSFUL"); } // Test 4: Open Overlapping Read-Write region that completely encloses @@ -128,7 +186,7 @@ class SbeMemRegionTest : public CxxTest::TestSuite } else { - SBE_TRACF_MRT("memRegionTest1: T4: SBEIO::openUnsecureMemRegion() SUCCESSFUL"); + SBE_TRACD_MRT("memRegionTest1: T4: SBEIO::openUnsecureMemRegion() SUCCESSFUL"); } // Test 5: Open Non-Overlapping Read-Only Region at the end @@ -144,10 +202,38 @@ class SbeMemRegionTest : public CxxTest::TestSuite } else { - SBE_TRACF_MRT("memRegionTest1: T5: SBEIO::openUnsecureMemRegion() SUCCESSFUL"); + SBE_TRACD_MRT("memRegionTest1: T5: SBEIO::openUnsecureMemRegion() SUCCESSFUL"); } - // @TODO RTC 174970 Add testcases for open/close fail scenarios + // Test 6: Close Single Region That Exists + errl = SBEIO::closeUnsecureMemRegion(mem_buf_start_addr+(mem_buf_size/8)*7); + if (errl) + { + TS_FAIL("memRegionTest1: T6: SBEIO::closeUnsecureMemRegion() Failed: rc=0x%X, plid=0x%X", + ERRL_GETRC_SAFE(errl), ERRL_GETPLID_SAFE(errl)); + break; + } + else + { + SBE_TRACD_MRT("memRegionTest1: T6: SBEIO::closeUnsecureMemRegion() SUCCESSFUL"); + } + + // Test 7: Re-Close Single Region and look for expected fail + errl = SBEIO::closeUnsecureMemRegion(mem_buf_start_addr+(mem_buf_size/8)*7); + if (ERRL_GETRC_SAFE(errl) == SBEIO::SBEIO_MEM_REGION_DOES_NOT_EXIST) + { + SBE_TRACF_MRT("memRegionTest1: T7: SBEIO::closeUnsecureMemRegion() Returned Expected Fail: rc=0x%X, plid=0x%X", + ERRL_GETRC_SAFE(errl), ERRL_GETPLID_SAFE(errl)); + delete errl; + errl = nullptr; + } + else + { + TS_FAIL("memRegionTest1: T7: SBEIO::closeUnsecureMemRegion() Did NOT Return Expected Fail rc=0x%X: got rc=0x%X, plid=0x%X", + SBEIO::SBEIO_MEM_REGION_DOES_NOT_EXIST, + ERRL_GETRC_SAFE(errl), ERRL_GETPLID_SAFE(errl)); + break; + } // Test 99: Close all Memory Regions errl = SBEIO::closeAllUnsecureMemRegions(); @@ -155,6 +241,7 @@ class SbeMemRegionTest : public CxxTest::TestSuite { TS_FAIL("memRegionTest1: T99: SBEIO::closeAllUnsecureMemRegions Failed: rc=0x%X, plid=0x%X", ERRL_GETRC_SAFE(errl), ERRL_GETPLID_SAFE(errl)); + break; } else { @@ -163,12 +250,18 @@ class SbeMemRegionTest : public CxxTest::TestSuite }while(0); - free (mem_buf); - mem_buf = nullptr; - + // Commit any unexpected error logs if (errl) { - errlCommit(errl, SBEIO_COMP_ID); + errlCommit(errl, SBEIO_COMP_ID); + } + + // Unmap the reserved memory using the virtual address + int rc = mm_block_unmap(tmp_virtual_addr); + + if (rc) + { + TS_FAIL("memRegionTest1: mm_block_unmap failed with rc=%d", rc); } TS_TRACE(EXIT_MRK"memRegionTest1"); |
