diff options
Diffstat (limited to 'decoder/tests/source/mem_acc_test.cpp')
| -rw-r--r-- | decoder/tests/source/mem_acc_test.cpp | 771 |
1 files changed, 771 insertions, 0 deletions
diff --git a/decoder/tests/source/mem_acc_test.cpp b/decoder/tests/source/mem_acc_test.cpp new file mode 100644 index 0000000..80666fb --- /dev/null +++ b/decoder/tests/source/mem_acc_test.cpp @@ -0,0 +1,771 @@ +/* + * \file mem_acc_test.cpp + * \brief OpenCSD : Component tests for memory accessor and caching + * + * \copyright Copyright (c) 2023, ARM Limited. All Rights Reserved. + */ + + + /* + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * 3. Neither the name of the copyright holder nor the names of its contributors + * may be used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * Test program to validate the memory accessor and caching. + * + * Checks for memory spaces, overlapping VA, cache sizes + */ + +#include <cstdio> +#include <string> +#include <iostream> +#include <sstream> +#include <cstring> + +#include "opencsd.h" + +// logging +static ocsdMsgLogger logger; +static ocsdDefaultErrorLogger err_log; +static ocsd_hndl_err_log_t err_log_handle; +static int logOpts = ocsdMsgLogger::OUT_STDOUT | ocsdMsgLogger::OUT_FILE; +static std::string logfileName = "mem_acc_test.ppl"; + +// test pass fail counts +static int tests_passed = 0; +static int tests_failed = 0; + +// number of blocks per memory area +#define NUM_BLOCKS 2 +// number of 32 but words in each block +#define BLOCK_NUM_WORDS 8192 +// size of block in bytes +#define BLOCK_SIZE_BYTES (4 * BLOCK_NUM_WORDS) + +// some memory areas to use for testing +static uint32_t el01_ns_blocks[NUM_BLOCKS][BLOCK_NUM_WORDS]; +static uint32_t el2_ns_blocks[NUM_BLOCKS][BLOCK_NUM_WORDS]; +static uint32_t el01_s_blocks[NUM_BLOCKS][BLOCK_NUM_WORDS]; +static uint32_t el2_s_blocks[NUM_BLOCKS][BLOCK_NUM_WORDS]; +static uint32_t el3_blocks[NUM_BLOCKS][BLOCK_NUM_WORDS]; +static uint32_t el01_r_blocks[NUM_BLOCKS][BLOCK_NUM_WORDS]; +static uint32_t el2_r_blocks[NUM_BLOCKS][BLOCK_NUM_WORDS]; +static uint32_t el3_root_blocks[NUM_BLOCKS][BLOCK_NUM_WORDS]; + +#define BLOCK_VAL(mem_space, block_num, index) (uint32_t)(((uint32_t)mem_space << 24) | ((uint32_t)block_num << 16) | (uint32_t)index) + +// memory access mapper - used for tests +static TrcMemAccMapGlobalSpace mapper; + + + +void populate_block(const ocsd_mem_space_acc_t mem_space, uint32_t block_array[NUM_BLOCKS][BLOCK_NUM_WORDS]) +{ + for (int i = 0; i < NUM_BLOCKS; i++) { + for (int j = 0; j < BLOCK_NUM_WORDS; j++) + block_array[i][j] = BLOCK_VAL(mem_space, i, j); + } +} + +void populate_all_blocks() +{ + populate_block(OCSD_MEM_SPACE_EL1N, el01_ns_blocks); + populate_block(OCSD_MEM_SPACE_EL2, el2_ns_blocks); + populate_block(OCSD_MEM_SPACE_EL1S, el01_s_blocks); + populate_block(OCSD_MEM_SPACE_EL2S, el2_s_blocks); + populate_block(OCSD_MEM_SPACE_EL3, el3_blocks); + populate_block(OCSD_MEM_SPACE_EL1R, el01_r_blocks); + populate_block(OCSD_MEM_SPACE_EL2R, el2_r_blocks); + populate_block(OCSD_MEM_SPACE_ROOT, el3_root_blocks); +} + +bool process_cmd_line_logger_opts(int argc, char* argv[]) +{ + bool goodLoggerOpts = true; + bool bChangingOptFlags = false; + int newlogOpts = ocsdMsgLogger::OUT_NONE; + std::string opt; + if (argc > 1) + { + int options_to_process = argc - 1; + int optIdx = 1; + while (options_to_process > 0) + { + opt = argv[optIdx]; + if (opt == "-logstdout") + { + newlogOpts |= ocsdMsgLogger::OUT_STDOUT; + bChangingOptFlags = true; + } + else if (opt == "-logstderr") + { + newlogOpts |= ocsdMsgLogger::OUT_STDERR; + bChangingOptFlags = true; + } + else if (opt == "-logfile") + { + newlogOpts |= ocsdMsgLogger::OUT_FILE; + bChangingOptFlags = true; + } + else if (opt == "-logfilename") + { + options_to_process--; + optIdx++; + if (options_to_process) + { + logfileName = argv[optIdx]; + newlogOpts |= ocsdMsgLogger::OUT_FILE; + bChangingOptFlags = true; + } + else + { + goodLoggerOpts = false; + } + } + options_to_process--; + optIdx++; + } + } + if (bChangingOptFlags) + logOpts = newlogOpts; + return goodLoggerOpts; +} + +void log_error(const ocsdError& err) +{ + err_log.LogError(err_log_handle, &err); +} + +void log_test_start(const char* testname) +{ + std::ostringstream oss; + oss << "*** Test " << testname << " Starting.\n"; + logger.LogMsg(oss.str()); +} + +void log_test_end(const char* testname, const int pass, const int fail) +{ + std::ostringstream oss; + oss << "*** Test " << testname << " complete. (Pass: " << pass << "; Fail:" << fail << ")\n"; + logger.LogMsg(oss.str()); +} + +void test_overlap_regions() +{ + // test adding regions that overlap + // overlap in difference memory spaces is ok, otherwise fail + TrcMemAccBufPtr Acc1, Acc2, Acc3, Acc4; + ocsd_err_t err; + std::ostringstream oss; + int passed = 0, failed = 0; + + log_test_start(__FUNCTION__); + + // add single accessor + Acc1.initAccessor(0x0000, (const uint8_t*)&el01_ns_blocks[0], BLOCK_SIZE_BYTES); + Acc1.setMemSpace(OCSD_MEM_SPACE_EL1N); + err = mapper.AddAccessor(&Acc1, 0); + if (err != OCSD_OK) { + log_error(ocsdError(OCSD_ERR_SEV_ERROR, err, "Failed to set memory accessor")); + failed++; + } + else + passed++; + + // overlapping region - same memory space. + Acc2.initAccessor(0x1000, (const uint8_t*)&el01_ns_blocks[1], BLOCK_SIZE_BYTES); + Acc2.setMemSpace(OCSD_MEM_SPACE_EL1N); + err = mapper.AddAccessor(&Acc2, 0); + if (err != OCSD_ERR_MEM_ACC_OVERLAP) { + oss.str(""); + oss << "Error: expected OCSD_ERR_MEM_ACC_OVERLAP error for overlapping accessor range.\n"; + logger.LogMsg(oss.str()); + failed++; + } + else + passed++; + + // non overlapping region - same memory space. + Acc2.setRange(0x8000, 0x8000 + BLOCK_SIZE_BYTES - 1); + err = mapper.AddAccessor(&Acc2, 0); + if (err != OCSD_OK) { + log_error(ocsdError(OCSD_ERR_SEV_ERROR, err, "Failed to set non overlapping memory accessor")); + failed++; + } + else + passed++; + + // overlapping region - different memory space + Acc3.initAccessor(0x0000, (const uint8_t*)&el01_s_blocks[0], BLOCK_SIZE_BYTES); + Acc3.setMemSpace(OCSD_MEM_SPACE_EL1S); + err = mapper.AddAccessor(&Acc3, 0); + if (err != OCSD_OK) { + log_error(ocsdError(OCSD_ERR_SEV_ERROR, err, "Failed to set overlapping memory accessor in other memory space")); + failed++; + } + else + passed++; + + // overlapping region - more general memory space. + Acc4.initAccessor(0x0000, (const uint8_t*)&el2_s_blocks[0], BLOCK_SIZE_BYTES); + Acc4.setMemSpace(OCSD_MEM_SPACE_S); + err = mapper.AddAccessor(&Acc4, 0); + if (err != OCSD_ERR_MEM_ACC_OVERLAP) { + oss.str(""); + oss << "Error: expected OCSD_ERR_MEM_ACC_OVERLAP error for overlapping general _S accessor range.\n"; + logger.LogMsg(oss.str()); + failed++; + } + else + passed++; + + // clean up mapper + mapper.RemoveAllAccessors(); + tests_passed += passed; + tests_failed += failed; + + log_test_end(__FUNCTION__, passed, failed); +} +/************************************************************************ + * Test trcID specific memory regions - using callback function. + * Emulates clinets such as perf where memory regions change over the + * trace run as tasks switched in and out. Tests caching mechanisms in + * mapper. + */ +typedef struct test_range { + ocsd_vaddr_t s_address; + uint32_t size; + const uint8_t* buffer; + ocsd_mem_space_acc_t mem_space; + uint8_t trcID; +} test_range_t; + +typedef struct test_range_array { + int num_ranges; + test_range_t* ranges; +} test_range_array_t; + +#define IN_MEM_SPACE(m1, m2) (bool)(((uint32_t)m1)&((uint32_t)m2)) + +static int AccCallbackCount = 0; + +uint32_t TestMemAccCB(const void* p_context, const ocsd_vaddr_t address, const ocsd_mem_space_acc_t mem_space, const uint8_t trcID, const uint32_t reqBytes, uint8_t* byteBuffer) +{ + test_range_array_t* ranges = (test_range_array_t*)p_context; + uint32_t bytes_read = 0; + + for (int i = 0; i < ranges->num_ranges; i++) + { + if ( IN_MEM_SPACE(mem_space, ranges->ranges[i].mem_space) && + (trcID == ranges->ranges[i].trcID) + ) + { + if ( (address >= ranges->ranges[i].s_address) && + (address < (ranges->ranges[i].s_address + ranges->ranges[i].size)) + ) + { + // in range - get offset into buffer + uint32_t offset = address - ranges->ranges[i].s_address; + + // copy all bytes if enough left in range - otherwise what if left + if (ranges->ranges[i].size - offset >= reqBytes) + bytes_read = reqBytes; + else + bytes_read = ranges->ranges[i].size - offset; + + memcpy(byteBuffer, &(ranges->ranges[i].buffer[offset]), bytes_read); + break; + } + } + } + AccCallbackCount++; + return bytes_read; +} + +void set_test_range(test_range_t& range, ocsd_vaddr_t s_address, uint32_t size, + const uint8_t* buffer, ocsd_mem_space_acc_t mem_space, uint8_t trcID) +{ + range.s_address = s_address; + range.size = size; + range.buffer = buffer; + range.mem_space = mem_space; + range.trcID = trcID; +} + +// read value through mapper and direct from range - check value and callback happened +// allows testing of expected caching and callback events +bool read_and_check_from_range(const int test_idx, const int range, test_range_array_t& ranges, const ocsd_vaddr_t byte_offset, bool callback) +{ + uint32_t read_val, num_bytes_read, expected_val; + uint8_t* p_local_buff = (uint8_t*)&read_val; + int PrevAccCallbackCount = AccCallbackCount; + ocsd_err_t err; + ocsd_vaddr_t read_address; + bool pass = true, mem_callback_occurred = false; + std::ostringstream oss; + std::string memSpaceStr; + ocsd_mem_space_acc_t mem_space; + uint8_t traceID; + + + mem_space = ranges.ranges[range].mem_space; + read_address = ranges.ranges[range].s_address + byte_offset; // set address value + num_bytes_read = 4; // request 4 bytes + expected_val = *((uint32_t *)(&(ranges.ranges[range].buffer[byte_offset]))); + traceID = ranges.ranges[range].trcID; + TrcMemAccessorBase::getMemAccSpaceString(memSpaceStr, mem_space); + + oss << "Read Test(" << test_idx << "): Address 0x" << std::hex << std::setw(8) << std::setfill('0') << read_address << "; "; + oss << memSpaceStr << "; Traced ID 0x" << std::setw(2) << (uint32_t)traceID << "; "; + logger.LogMsg(oss.str()); + + err = mapper.ReadTargetMemory(read_address, ranges.ranges[range].trcID, OCSD_MEM_SPACE_EL1N, &num_bytes_read, p_local_buff); + + mem_callback_occurred = (bool)(PrevAccCallbackCount != AccCallbackCount); + if (mem_callback_occurred) + oss.str("MemCB read; "); + else + oss.str("No MemCB; "); + logger.LogMsg(oss.str()); + + if (err != OCSD_OK) { + oss.str(""); + oss << "Error reading target memory\n"; + logger.LogMsg(oss.str()); + log_error(ocsdError(OCSD_ERR_SEV_ERROR, err, oss.str())); + pass = false; + goto exit_test; + } + + if (num_bytes_read != 4) { + oss.str(""); + oss << "Read Fail: Requested bytes not found (4 != " << num_bytes_read << ")\n"; + logger.LogMsg(oss.str()); + pass = false; + goto exit_test; + } + + if (expected_val != read_val) { + oss.str(""); + oss << "Read Fail: value read mismatch; 0x" << std::hex << read_val << " != 0x" << expected_val << "\n"; + logger.LogMsg(oss.str()); + pass = false; + goto exit_test; + } + + if (callback && !mem_callback_occurred) { + oss.str(""); + oss << "Read Fail: Expected callback to access memory\n"; + logger.LogMsg(oss.str()); + pass = false; + goto exit_test; + } + + if (!callback && mem_callback_occurred) { + oss.str(""); + oss << "Read Fail: Unexpected callback to access memory\n"; + logger.LogMsg(oss.str()); + pass = false; + goto exit_test; + } + + if (pass) { + oss.str("\n"); + logger.LogMsg(oss.str()); + } + +exit_test: + return pass; +} + +void test_trcid_cache_mem_cb() +{ + TrcMemAccCB CBAcc; + test_range_array_t ranges; + int passed = 0, failed = 0; + std::ostringstream oss; + ocsd_err_t err; + int read_test_idx = 1; + + + log_test_start(__FUNCTION__); + + // set up the ranges + ranges.num_ranges = 6; + ranges.ranges = new test_range_t[6]; + + // 1st range 0x0000, EL1N, trcID 0x10 - 1st CPU + set_test_range(ranges.ranges[0], 0x0000, BLOCK_SIZE_BYTES, (const uint8_t*)&el01_ns_blocks[0], OCSD_MEM_SPACE_EL1N, 0x10); + // 2nd range 0x0000, EL1N, trcID 0x11 - 2nd cpu, same addresses, different data. + set_test_range(ranges.ranges[1], 0x0000, BLOCK_SIZE_BYTES, (const uint8_t*)&el01_ns_blocks[1], OCSD_MEM_SPACE_EL1N, 0x11); + // 2nd range 0x8000, EL2N, trcID 0x10 - 2nd cpu, same addresses, different data. + set_test_range(ranges.ranges[2], 0x8000, BLOCK_SIZE_BYTES, (const uint8_t*)&el2_ns_blocks[0], OCSD_MEM_SPACE_EL2, 0x10); + // 2nd range 0x10000, EL2N, trcID 0x11 - 2nd cpu, + set_test_range(ranges.ranges[3], 0x10000, BLOCK_SIZE_BYTES, (const uint8_t*)&el2_ns_blocks[1], OCSD_MEM_SPACE_EL2, 0x11); + // 2nd range 0x0000, EL1 realm, trcID 0x10 - cpu 1 realm + set_test_range(ranges.ranges[4], 0x0000, BLOCK_SIZE_BYTES, (const uint8_t*)&el01_r_blocks[0], OCSD_MEM_SPACE_EL1R, 0x10); + // 2nd range 0x0000, EL2 realm, trcID 0x11 - 2nd cpu - realm . + set_test_range(ranges.ranges[5], 0x0000, BLOCK_SIZE_BYTES, (const uint8_t*)&el2_r_blocks[0], OCSD_MEM_SPACE_EL2R, 0x11); + + // add the callback to the mapper + CBAcc.initAccessor(0, 0xFFFFFFFF, OCSD_MEM_SPACE_ANY); + CBAcc.setCBIDIfFn(TestMemAccCB, (void*)&ranges); + err = mapper.AddAccessor(&CBAcc, 0); + if (err != OCSD_OK) { + log_error(ocsdError(OCSD_ERR_SEV_ERROR, err, "Failed to set callback memory accessor")); + failed++; + goto cleanup; + } + + // run some tests + // initial read - should callback and load cache page + read_and_check_from_range(read_test_idx++, 0, ranges, 0, true) ? passed++ : failed++; + + // next read - should not callback but use cache + read_and_check_from_range(read_test_idx++, 0, ranges, 0x10, false) ? passed++ : failed++; + + // different cpu - same address - should callback for cache load + read_and_check_from_range(read_test_idx++, 1, ranges, 0x10, true) ? passed++ : failed++; + + // different cpu - same address - use cache + read_and_check_from_range(read_test_idx++, 1, ranges, 0x10, false) ? passed++ : failed++; + + + // clean up mapper +cleanup: + mapper.RemoveAllAccessors(); + tests_passed += passed; + tests_failed += failed; + delete[] ranges.ranges; + + log_test_end(__FUNCTION__, passed, failed); +} + +/************************************************************************ + * Test trcID specific memory regions - using callback function. + * Emulates clinets such as perf where memory regions change over the + * trace run as tasks switched in and out. Tests caching mechanisms in + * mapper. + */ + +#define TEST_ADDR_COMMON 0x000000 +#define TEST_ADDR_EL1N 0x008000 +#define TEST_ADDR_EL2 0x010000 +#define TEST_ADDR_EL1S 0x018000 +#define TEST_ADDR_EL2S 0x020000 +#define TEST_ADDR_EL3 0x028000 +#define TEST_ADDR_EL1R 0x030000 +#define TEST_ADDR_EL2R 0x038000 +#define TEST_ADDR_EL3R 0x040000 + +bool read_and_check_value(ocsd_vaddr_t addr, const uint8_t* p_block_buffer, ocsd_mem_space_acc_t space) +{ + ocsd_err_t err; + uint32_t read_val, check_val, num_bytes; + std::ostringstream oss; + std::string memSpaceStr; + + + TrcMemAccessorBase::getMemAccSpaceString(memSpaceStr, space); + oss << "Read Test: Address 0x" << std::hex << std::setw(8) << std::setfill('0') << addr << "; "; + oss << std::setw(4) << std::setfill(' ') << memSpaceStr << ";" ; + logger.LogMsg(oss.str()); + + + num_bytes = 4; + err = mapper.ReadTargetMemory(addr, 0, space, &num_bytes, (uint8_t*)&read_val); + if (err != OCSD_OK) { + log_error(ocsdError(OCSD_ERR_SEV_ERROR, err, "Failed to read from mapper")); + return false; + } + + check_val = *((uint32_t *)p_block_buffer); + if (check_val != read_val) + { + oss.str(""); + oss << "Read Fail: value read mismatch; 0x" << std::hex << read_val << " != 0x" << check_val << "\n"; + logger.LogMsg(oss.str()); + return false; + } + + oss.str(""); + oss << " [0x" << std::hex << std::setw(8) << std::setfill('0') << read_val << "]\n"; + logger.LogMsg(oss.str()); + return true; +} + +void test_mem_spaces() +{ + ocsd_err_t err; + int passed = 0, failed = 0; + std::ostringstream oss; + + + log_test_start(__FUNCTION__); + + // check each memory space, 8 of them, and a each block. + #define NUM_ACCS (NUM_BLOCKS * 8) + TrcMemAccBufPtr accs[NUM_ACCS]; + + // set-up accessors - block 0 in each space is the same - the next will have no overlap + accs[0].initAccessor(TEST_ADDR_COMMON, (const uint8_t*)&el01_ns_blocks[0], BLOCK_SIZE_BYTES); + accs[0].setMemSpace(OCSD_MEM_SPACE_EL1N); + accs[1].initAccessor(TEST_ADDR_EL1N, (const uint8_t*)&el01_ns_blocks[1], BLOCK_SIZE_BYTES); + accs[1].setMemSpace(OCSD_MEM_SPACE_EL1N); + + accs[2].initAccessor(TEST_ADDR_COMMON, (const uint8_t*)&el2_ns_blocks[0], BLOCK_SIZE_BYTES); + accs[2].setMemSpace(OCSD_MEM_SPACE_EL2); + accs[3].initAccessor(TEST_ADDR_EL2, (const uint8_t*)&el2_ns_blocks[1], BLOCK_SIZE_BYTES); + accs[3].setMemSpace(OCSD_MEM_SPACE_EL2); + + accs[4].initAccessor(TEST_ADDR_COMMON, (const uint8_t*)&el01_s_blocks[0], BLOCK_SIZE_BYTES); + accs[4].setMemSpace(OCSD_MEM_SPACE_EL1S); + accs[5].initAccessor(TEST_ADDR_EL1S, (const uint8_t*)&el01_s_blocks[1], BLOCK_SIZE_BYTES); + accs[5].setMemSpace(OCSD_MEM_SPACE_EL1S); + + accs[6].initAccessor(TEST_ADDR_COMMON, (const uint8_t*)&el2_s_blocks[0], BLOCK_SIZE_BYTES); + accs[6].setMemSpace(OCSD_MEM_SPACE_EL2S); + accs[7].initAccessor(TEST_ADDR_EL2S, (const uint8_t*)&el2_s_blocks[1], BLOCK_SIZE_BYTES); + accs[7].setMemSpace(OCSD_MEM_SPACE_EL2S); + + accs[8].initAccessor(TEST_ADDR_COMMON, (const uint8_t*)&el3_blocks[0], BLOCK_SIZE_BYTES); + accs[8].setMemSpace(OCSD_MEM_SPACE_EL3); + accs[9].initAccessor(TEST_ADDR_EL3, (const uint8_t*)&el3_blocks[1], BLOCK_SIZE_BYTES); + accs[9].setMemSpace(OCSD_MEM_SPACE_EL3); + + accs[10].initAccessor(TEST_ADDR_COMMON, (const uint8_t*)&el01_r_blocks[0], BLOCK_SIZE_BYTES); + accs[10].setMemSpace(OCSD_MEM_SPACE_EL1R); + accs[11].initAccessor(TEST_ADDR_EL1R, (const uint8_t*)&el01_r_blocks[1], BLOCK_SIZE_BYTES); + accs[11].setMemSpace(OCSD_MEM_SPACE_EL1R); + + accs[12].initAccessor(TEST_ADDR_COMMON, (const uint8_t*)&el2_r_blocks[0], BLOCK_SIZE_BYTES); + accs[12].setMemSpace(OCSD_MEM_SPACE_EL2R); + accs[13].initAccessor(TEST_ADDR_EL2R, (const uint8_t*)&el2_r_blocks[1], BLOCK_SIZE_BYTES); + accs[13].setMemSpace(OCSD_MEM_SPACE_EL2R); + + accs[14].initAccessor(TEST_ADDR_COMMON, (const uint8_t*)&el3_root_blocks[0], BLOCK_SIZE_BYTES); + accs[14].setMemSpace(OCSD_MEM_SPACE_ROOT); + accs[15].initAccessor(TEST_ADDR_EL3R, (const uint8_t*)&el3_root_blocks[1], BLOCK_SIZE_BYTES); + accs[15].setMemSpace(OCSD_MEM_SPACE_ROOT); + + // add accessors to mapper. + for (int i = 0; i < NUM_ACCS; i++) { + err = mapper.AddAccessor(&accs[i], 0); + if (err != OCSD_OK) { + log_error(ocsdError(OCSD_ERR_SEV_ERROR, err, "Failed to set callback memory accessor")); + failed++; + } + else + passed++; + } + + // test a bunch of reads - use specific space then check match if more global spaces are used. + oss.str("Test EL1N registered block\n"); + logger.LogMsg(oss.str()); + read_and_check_value(TEST_ADDR_COMMON, (const uint8_t*)&el01_ns_blocks[0], OCSD_MEM_SPACE_EL1N) ? passed++ : failed++; + read_and_check_value(TEST_ADDR_EL1N, (const uint8_t*)&el01_ns_blocks[1], OCSD_MEM_SPACE_EL1N) ? passed++ : failed++; + read_and_check_value(TEST_ADDR_EL1N, (const uint8_t*)&el01_ns_blocks[1], OCSD_MEM_SPACE_N) ? passed++ : failed++; + read_and_check_value(TEST_ADDR_EL1N, (const uint8_t*)&el01_ns_blocks[1], OCSD_MEM_SPACE_ANY) ? passed++ : failed++; + + oss.str("Test EL1N registered block\n"); + logger.LogMsg(oss.str()); + read_and_check_value(TEST_ADDR_COMMON, (const uint8_t*)&el2_ns_blocks[0], OCSD_MEM_SPACE_EL2) ? passed++ : failed++; + read_and_check_value(TEST_ADDR_EL2, (const uint8_t*)&el2_ns_blocks[1], OCSD_MEM_SPACE_EL2) ? passed++ : failed++; + read_and_check_value(TEST_ADDR_EL2, (const uint8_t*)&el2_ns_blocks[1], OCSD_MEM_SPACE_N) ? passed++ : failed++; + read_and_check_value(TEST_ADDR_EL2, (const uint8_t*)&el2_ns_blocks[1], OCSD_MEM_SPACE_ANY) ? passed++ : failed++; + + oss.str("Test EL1S registered block\n"); + logger.LogMsg(oss.str()); + read_and_check_value(TEST_ADDR_COMMON, (const uint8_t*)&el01_s_blocks[0], OCSD_MEM_SPACE_EL1S) ? passed++ : failed++; + read_and_check_value(TEST_ADDR_EL1S, (const uint8_t*)&el01_s_blocks[1], OCSD_MEM_SPACE_EL1S) ? passed++ : failed++; + read_and_check_value(TEST_ADDR_EL1S, (const uint8_t*)&el01_s_blocks[1], OCSD_MEM_SPACE_S) ? passed++ : failed++; + read_and_check_value(TEST_ADDR_EL1S, (const uint8_t*)&el01_s_blocks[1], OCSD_MEM_SPACE_ANY) ? passed++ : failed++; + + oss.str("Test EL2S registered block\n"); + logger.LogMsg(oss.str()); + read_and_check_value(TEST_ADDR_COMMON, (const uint8_t*)&el2_s_blocks[0], OCSD_MEM_SPACE_EL2S) ? passed++ : failed++; + read_and_check_value(TEST_ADDR_EL2S, (const uint8_t*)&el2_s_blocks[1], OCSD_MEM_SPACE_EL2S) ? passed++ : failed++; + read_and_check_value(TEST_ADDR_EL2S, (const uint8_t*)&el2_s_blocks[1], OCSD_MEM_SPACE_S) ? passed++ : failed++; + read_and_check_value(TEST_ADDR_EL2S, (const uint8_t*)&el2_s_blocks[1], OCSD_MEM_SPACE_ANY) ? passed++ : failed++; + + oss.str("Test EL3 registered block\n"); + logger.LogMsg(oss.str()); + read_and_check_value(TEST_ADDR_COMMON, (const uint8_t*)&el3_blocks[0], OCSD_MEM_SPACE_EL3) ? passed++ : failed++; + read_and_check_value(TEST_ADDR_EL3, (const uint8_t*)&el3_blocks[1], OCSD_MEM_SPACE_EL3) ? passed++ : failed++; + read_and_check_value(TEST_ADDR_EL3, (const uint8_t*)&el3_blocks[1], OCSD_MEM_SPACE_S) ? passed++ : failed++; + read_and_check_value(TEST_ADDR_EL3, (const uint8_t*)&el3_blocks[1], OCSD_MEM_SPACE_ANY) ? passed++ : failed++; + + oss.str("Test EL1R registered block\n"); + logger.LogMsg(oss.str()); + read_and_check_value(TEST_ADDR_COMMON, (const uint8_t*)&el01_r_blocks[0], OCSD_MEM_SPACE_EL1R) ? passed++ : failed++; + read_and_check_value(TEST_ADDR_EL1R, (const uint8_t*)&el01_r_blocks[1], OCSD_MEM_SPACE_EL1R) ? passed++ : failed++; + read_and_check_value(TEST_ADDR_EL1R, (const uint8_t*)&el01_r_blocks[1], OCSD_MEM_SPACE_R) ? passed++ : failed++; + read_and_check_value(TEST_ADDR_EL1R, (const uint8_t*)&el01_r_blocks[1], OCSD_MEM_SPACE_ANY) ? passed++ : failed++; + + oss.str("Test EL2R registered block\n"); + logger.LogMsg(oss.str()); + read_and_check_value(TEST_ADDR_COMMON, (const uint8_t*)&el2_r_blocks[0], OCSD_MEM_SPACE_EL2R) ? passed++ : failed++; + read_and_check_value(TEST_ADDR_EL2R, (const uint8_t*)&el2_r_blocks[1], OCSD_MEM_SPACE_EL2R) ? passed++ : failed++; + read_and_check_value(TEST_ADDR_EL2R, (const uint8_t*)&el2_r_blocks[1], OCSD_MEM_SPACE_R) ? passed++ : failed++; + read_and_check_value(TEST_ADDR_EL2R, (const uint8_t*)&el2_r_blocks[1], OCSD_MEM_SPACE_ANY) ? passed++ : failed++; + + oss.str("Test ROOT registered block\n"); + logger.LogMsg(oss.str()); + read_and_check_value(TEST_ADDR_COMMON, (const uint8_t*)&el3_root_blocks[0], OCSD_MEM_SPACE_ROOT) ? passed++ : failed++; + read_and_check_value(TEST_ADDR_EL3R, (const uint8_t*)&el3_root_blocks[1], OCSD_MEM_SPACE_ROOT) ? passed++ : failed++; + read_and_check_value(TEST_ADDR_EL3R, (const uint8_t*)&el3_root_blocks[1], OCSD_MEM_SPACE_ANY) ? passed++ : failed++; + + // clear for this test + mapper.RemoveAllAccessors(); + + // test access more global from specific - set ANY, N S and R spaces + accs[0].initAccessor(TEST_ADDR_COMMON, (const uint8_t*)&el01_ns_blocks[0], BLOCK_SIZE_BYTES); + accs[0].setMemSpace(OCSD_MEM_SPACE_ANY); + accs[1].initAccessor(TEST_ADDR_EL1N, (const uint8_t*)&el01_ns_blocks[1], BLOCK_SIZE_BYTES); + accs[1].setMemSpace(OCSD_MEM_SPACE_N); + accs[2].initAccessor(TEST_ADDR_EL2, (const uint8_t*)&el2_ns_blocks[0], BLOCK_SIZE_BYTES); + accs[2].setMemSpace(OCSD_MEM_SPACE_S); + accs[3].initAccessor(TEST_ADDR_EL3, (const uint8_t*)&el2_ns_blocks[1], BLOCK_SIZE_BYTES); + accs[3].setMemSpace(OCSD_MEM_SPACE_R); + + for (int i = 0; i < 4; i++) { + err = mapper.AddAccessor(&accs[i], 0); + if (err != OCSD_OK) { + log_error(ocsdError(OCSD_ERR_SEV_ERROR, err, "Failed to set callback memory accessor")); + failed++; + } + else + passed++; + } + + // for ANY space should match all other spaces + uint32_t offset = 0; + oss.str("Test ANY registered block\n"); + logger.LogMsg(oss.str()); + read_and_check_value(TEST_ADDR_COMMON + offset, ((const uint8_t*)&el01_ns_blocks[0]) +offset, OCSD_MEM_SPACE_EL1N) ? passed++ : failed++; + offset += 4; + read_and_check_value(TEST_ADDR_COMMON + offset, ((const uint8_t*)&el01_ns_blocks[0]) + offset, OCSD_MEM_SPACE_EL2) ? passed++ : failed++; + offset += 4; + read_and_check_value(TEST_ADDR_COMMON + offset, ((const uint8_t*)&el01_ns_blocks[0]) + offset, OCSD_MEM_SPACE_EL1S) ? passed++ : failed++; + offset += 4; + read_and_check_value(TEST_ADDR_COMMON + offset, ((const uint8_t*)&el01_ns_blocks[0]) + offset, OCSD_MEM_SPACE_EL2S) ? passed++ : failed++; + offset += 4; + read_and_check_value(TEST_ADDR_COMMON + offset, ((const uint8_t*)&el01_ns_blocks[0]) + offset, OCSD_MEM_SPACE_EL3) ? passed++ : failed++; + offset += 4; + read_and_check_value(TEST_ADDR_COMMON + offset, ((const uint8_t*)&el01_ns_blocks[0]) + offset, OCSD_MEM_SPACE_EL1R) ? passed++ : failed++; + offset += 4; + read_and_check_value(TEST_ADDR_COMMON + offset, ((const uint8_t*)&el01_ns_blocks[0]) + offset, OCSD_MEM_SPACE_EL2R) ? passed++ : failed++; + offset += 4; + read_and_check_value(TEST_ADDR_COMMON + offset, ((const uint8_t*)&el01_ns_blocks[0]) + offset, OCSD_MEM_SPACE_S) ? passed++ : failed++; + offset += 4; + read_and_check_value(TEST_ADDR_COMMON + offset, ((const uint8_t*)&el01_ns_blocks[0]) + offset, OCSD_MEM_SPACE_N) ? passed++ : failed++; + offset += 4; + read_and_check_value(TEST_ADDR_COMMON + offset, ((const uint8_t*)&el01_ns_blocks[0]) + offset, OCSD_MEM_SPACE_R) ? passed++ : failed++; + offset += 4; + read_and_check_value(TEST_ADDR_COMMON + offset, ((const uint8_t*)&el01_ns_blocks[0]) + offset, OCSD_MEM_SPACE_ROOT) ? passed++ : failed++; + + oss.str("Test Any N registered block\n"); + logger.LogMsg(oss.str()); + offset = 0; + read_and_check_value(TEST_ADDR_EL1N + offset, ((const uint8_t*)&el01_ns_blocks[1]) + offset, OCSD_MEM_SPACE_EL1N) ? passed++ : failed++; + offset += 4; + read_and_check_value(TEST_ADDR_EL1N + offset, ((const uint8_t*)&el01_ns_blocks[1]) + offset, OCSD_MEM_SPACE_EL2) ? passed++ : failed++; + offset += 4; + read_and_check_value(TEST_ADDR_EL1N + offset, ((const uint8_t*)&el01_ns_blocks[1]) + offset, OCSD_MEM_SPACE_N) ? passed++ : failed++; + + oss.str("Test Any S registered block\n"); + logger.LogMsg(oss.str()); + offset = 0; + read_and_check_value(TEST_ADDR_EL2 + offset, ((const uint8_t*)&el2_ns_blocks[0]) + offset, OCSD_MEM_SPACE_EL1S) ? passed++ : failed++; + offset += 4; + read_and_check_value(TEST_ADDR_EL2 + offset, ((const uint8_t*)&el2_ns_blocks[0]) + offset, OCSD_MEM_SPACE_EL2S) ? passed++ : failed++; + offset += 4; + read_and_check_value(TEST_ADDR_EL2 + offset, ((const uint8_t*)&el2_ns_blocks[0]) + offset, OCSD_MEM_SPACE_EL3) ? passed++ : failed++; + offset += 4; + read_and_check_value(TEST_ADDR_EL2 + offset, ((const uint8_t*)&el2_ns_blocks[0]) + offset, OCSD_MEM_SPACE_S) ? passed++ : failed++; + + oss.str("Test Any R registered block\n"); + logger.LogMsg(oss.str()); + offset = 0; + read_and_check_value(TEST_ADDR_EL3 + offset, ((const uint8_t*)&el2_ns_blocks[1]) + offset, OCSD_MEM_SPACE_EL1R) ? passed++ : failed++; + offset += 4; + read_and_check_value(TEST_ADDR_EL3 + offset, ((const uint8_t*)&el2_ns_blocks[1]) + offset, OCSD_MEM_SPACE_EL2R) ? passed++ : failed++; + offset += 4; + read_and_check_value(TEST_ADDR_EL3 + offset, ((const uint8_t*)&el2_ns_blocks[1]) + offset, OCSD_MEM_SPACE_R) ? passed++ : failed++; + offset += 4; + + // clean up + mapper.RemoveAllAccessors(); + tests_passed += passed; + tests_failed += failed; + log_test_end(__FUNCTION__, passed, failed); + } + +/************************************************************************ + * main program + */ +int main(int argc, char* argv[]) +{ + std::ostringstream oss; + + if (!process_cmd_line_logger_opts(argc, argv)) + { + std::cout << "Bad logger command line options\nProgram Exiting\n"; + return -1; + } + + // init the loggers. + logger.setLogOpts(logOpts); + logger.setLogFileName(logfileName.c_str()); + err_log.initErrorLogger(OCSD_ERR_SEV_INFO); + err_log_handle = err_log.RegisterErrorSource("MEMACCTEST"); + err_log.setOutputLogger(&logger); + + oss << "OpenCSD memory access tests.\n"; + oss << "----------------------------\n\n"; + oss << "Library Version : " << ocsdVersion::vers_str() << "\n\n"; + logger.LogMsg(oss.str()); + + // set up test data + populate_all_blocks(); + + // init the mapper + mapper.setErrorLog(&err_log); + mapper.enableCaching(true); + + // call the test routines + test_overlap_regions(); + + test_trcid_cache_mem_cb(); + + test_mem_spaces(); + + + oss.str(""); + oss << "\n*** Memory access tests complete.***\nPassed: " << tests_passed << "; Failed: " << tests_failed << "\n"; + logger.LogMsg(oss.str()); + return (tests_failed == 0) ? 0 : -2; +} |