Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
47 changes: 47 additions & 0 deletions test/tx/cmake/module_manager/CMakeLists.txt
Original file line number Diff line number Diff line change
Expand Up @@ -393,3 +393,50 @@ target_compile_options(

add_test(${CMAKE_BUILD_TYPE}::threadx_module_manager_load_bounds_test
threadx_module_manager_load_bounds_test)

# This test checks the module options the Cortex-A35 module ports accept, so it is
# compiled once against each of their four headers rather than against a stand-in
# port. The SMP ports take the SMP kernel's headers. These ports are AArch64, whose
# ALIGN_TYPE is as wide as a pointer only at 64 bits, so these targets build at
# native 64-bit width rather than the suite's -m32. The port's alignment macro
# assigns the code and data alignments in place, including into the loaders' and
# utility's discarded copies, which -Wall reports as set but not used.
foreach(a35_port cortex_a35/gnu cortex_a35/ac6 cortex_a35_smp/gnu cortex_a35_smp/ac6)
string(REPLACE "/" "_" a35_name ${a35_port})
set(a35_target threadx_module_manager_${a35_name}_properties_test)

if(a35_port MATCHES "_smp/")
set(a35_common_inc ${REPO_ROOT}/common_smp/inc)
else()
set(a35_common_inc ${REPO_ROOT}/common/inc)
endif()

add_executable(
${a35_target}
${SOURCE_DIR}/threadx_module_manager_cortex_a35_properties_test.c
${module_manager_dir}/src/txm_module_manager_initialize.c
${module_manager_dir}/src/txm_module_manager_internal_load.c
${module_manager_dir}/src/txm_module_manager_in_place_load.c
${module_manager_dir}/src/txm_module_manager_absolute_load_extended.c
${module_manager_dir}/src/txm_module_manager_util.c)

target_include_directories(
${a35_target}
PRIVATE ${SOURCE_DIR}
${a35_common_inc}
${REPO_ROOT}/common_modules/inc
${module_manager_dir}/inc
${REPO_ROOT}/ports_module/${a35_port}/inc)

target_compile_options(
${a35_target}
PRIVATE -m64
-Wall
-Wextra
-Wno-unused-but-set-variable
-include ${SOURCE_DIR}/threadx_module_manager_host_test_port.h)

target_link_options(${a35_target} PRIVATE -m64)

add_test(${CMAKE_BUILD_TYPE}::${a35_target} ${a35_target})
endforeach()
Original file line number Diff line number Diff line change
@@ -0,0 +1,344 @@
/***************************************************************************
* Copyright (c) 2026 Eclipse ThreadX contributors
*
* This program and the accompanying materials are made available under the
* terms of the MIT License which is available at
* https://opensource.org/licenses/MIT.
*
* AI Disclosure: This file was largely AI-generated by Claude Code (Opus 5.5).
* The AI-generated portions may be considered public domain (CC0-1.0)
* and not subject to the project's licence. The human contributor has
* reviewed and verified that the code is correct.
*
* SPDX-License-Identifier: MIT and CC0-1.0
**************************************************************************/


/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Test */
/** */
/** Module Manager Cortex-A35 module properties */
/** */
/**************************************************************************/
/**************************************************************************/

/* The Cortex-A35 and Cortex-A35 SMP module ports start every module thread at the
Module Manager's own exception level, give it the kernel dispatcher directly, and
program no translation tables for it. They cannot isolate a module, so a module that
requests user mode or memory protection must be refused at load rather than run
privileged while its integrator believes it is confined.

The build compiles this test once against each of the four Cortex-A35 module port
headers. The supported and required options come from the port's own definitions,
through _txm_module_manager_initialize, and the two loaders that hold a copy of the
property check, the internal loader behind the in-place load and the absolute
loader, are each given modules requesting:

- user mode, and user mode with memory protection, which must be refused with
TXM_MODULE_INVALID_PROPERTIES;
- no option, and shared external memory access, which must still load.

A module requesting memory protection alone is refused on every port, because
memory protection requires user mode, so the loaders cannot show memory protection
refused on its own. The test therefore also checks that the supported options the
manager initialized from the port include neither property. */

#include <stdio.h>
#include <string.h>
#include <sys/mman.h>
#include <unistd.h>

#include "threadx_module_manager_host_test_port.h"

#include "tx_initialize.h"
#include "tx_thread.h"
#include "tx_timer.h"
#include "tx_queue.h"
#include "tx_event_flags.h"
#include "tx_semaphore.h"
#include "tx_mutex.h"
#include "tx_block_pool.h"
#include "tx_byte_pool.h"
#include "txm_module.h"


/* Define the stand-in interrupt lock the port shim counts through. */

unsigned int test_interrupt_disable_depth;
unsigned int test_interrupt_disable_max_depth;
unsigned int test_interrupt_restore_underflows;


/* Define the kernel state the sources under test link against; the Module Manager
state is defined by its initialization source. The SMP kernel reads the system
state through a per-core function instead. */

#ifdef TX_THREAD_SMP
ULONG _tx_thread_smp_current_state_get(VOID)
{
return((ULONG) 0);
}
#else
volatile ULONG _tx_thread_system_state;
#endif

TX_BLOCK_POOL *_tx_block_pool_created_ptr;
ULONG _tx_block_pool_created_count;
TX_BYTE_POOL *_tx_byte_pool_created_ptr;
ULONG _tx_byte_pool_created_count;
TX_EVENT_FLAGS_GROUP *_tx_event_flags_created_ptr;
ULONG _tx_event_flags_created_count;
TX_MUTEX *_tx_mutex_created_ptr;
ULONG _tx_mutex_created_count;
TX_QUEUE *_tx_queue_created_ptr;
ULONG _tx_queue_created_count;
TX_SEMAPHORE *_tx_semaphore_created_ptr;
ULONG _tx_semaphore_created_count;
TX_THREAD *_tx_thread_created_ptr;
ULONG _tx_thread_created_count;
TX_TIMER *_tx_timer_created_ptr;
ULONG _tx_timer_created_count;


static UINT test_failures;
static ULONG test_checks;


/* Record the outcome of one expectation. */
static VOID test_expect(const char *description, ULONG actual, ULONG expected)
{
test_checks++;

if (actual != expected)
{
printf("FAIL: %s (expected %lu, got %lu)\n", description, (unsigned long) expected, (unsigned long) actual);
test_failures++;
}
}


/* The protection mutex, which counts its owner so that a refusal that returns
holding it is caught. */

static ULONG test_mutex_depth;

UINT _tx_mutex_create(TX_MUTEX *mutex_ptr, CHAR *name_ptr, UINT inherit)
{
(VOID) mutex_ptr;
(VOID) name_ptr;
(VOID) inherit;

test_mutex_depth = ((ULONG) 0);

return(TX_SUCCESS);
}

UINT _tx_mutex_get(TX_MUTEX *mutex_ptr, ULONG wait_option)
{
(VOID) mutex_ptr;
(VOID) wait_option;

test_mutex_depth++;

return(TX_SUCCESS);
}

UINT _tx_mutex_put(TX_MUTEX *mutex_ptr)
{
(VOID) mutex_ptr;

test_mutex_depth--;

return(TX_SUCCESS);
}


/* The byte pool the in-place loader allocates module data from: a bump allocator
over the arena the manager is initialized with. */

static UCHAR *test_pool_start;
static ULONG test_pool_size;
static ULONG test_pool_offset;

UINT _tx_byte_pool_create(TX_BYTE_POOL *pool_ptr, CHAR *name_ptr, VOID *pool_start, ULONG pool_size)
{
(VOID) pool_ptr;
(VOID) name_ptr;

test_pool_start = (UCHAR *) pool_start;
test_pool_size = pool_size;
test_pool_offset = ((ULONG) 0);

return(TX_SUCCESS);
}

UINT _tx_byte_allocate(TX_BYTE_POOL *pool_ptr, VOID **memory_ptr, ULONG memory_size, ULONG wait_option)
{

UINT status;


(VOID) pool_ptr;
(VOID) wait_option;

if (memory_size > (test_pool_size - test_pool_offset))
{
status = TX_NO_MEMORY;
}
else
{
*memory_ptr = (VOID *) &test_pool_start[test_pool_offset];
test_pool_offset = test_pool_offset + memory_size;
status = TX_SUCCESS;
}

return(status);
}

UINT _tx_byte_release(VOID *memory_ptr)
{
(VOID) memory_ptr;

return(TX_SUCCESS);
}


/* The module image, its data area for the absolute loader, and the manager's arena.
The port's entry addresses are 32 bits wide, so the absolute loader can only place
a module below 4 GiB; the mapping is asked for there. */

#define TEST_MAPPING_HINT ((ALIGN_TYPE) 0x10000000)
#define TEST_MAPPING_BYTES ((ULONG) 16384)
#define TEST_IMAGE_BYTES ((ULONG) 512)
#define TEST_DATA_OFFSET ((ULONG) 4096)
#define TEST_ARENA_OFFSET ((ULONG) 8192)
#define TEST_SHELL_OFFSET ((ULONG) 128)
#define TEST_START_OFFSET ((ULONG) 132)
#define TEST_STOP_OFFSET ((ULONG) 136)
#define TEST_CALLBACK_OFFSET ((ULONG) 140)

static UCHAR *test_mapping;
static TXM_MODULE_INSTANCE test_instance;


/* Build a module image requesting the given options. The entry fields are offsets
for the in-place loader, or absolute addresses when absolute is set. */
static VOID test_image_build(ULONG options, UINT absolute)
{

TXM_MODULE_PREAMBLE *preamble;
ULONG base;


preamble = (TXM_MODULE_PREAMBLE *) test_mapping;

memset(test_mapping, 0, TEST_IMAGE_BYTES);

base = (absolute != TX_FALSE) ? (ULONG) (ALIGN_TYPE) test_mapping : ((ULONG) 0);

preamble -> txm_module_preamble_id = TXM_MODULE_ID;
preamble -> txm_module_preamble_preamble_size = ((ULONG) sizeof(TXM_MODULE_PREAMBLE)) / ((ULONG) sizeof(ULONG));
preamble -> txm_module_preamble_property_flags = TXM_MODULE_GNU_COMPILER | options;
preamble -> txm_module_preamble_shell_entry_function = base + TEST_SHELL_OFFSET;
preamble -> txm_module_preamble_start_function = base + TEST_START_OFFSET;
preamble -> txm_module_preamble_stop_function = base + TEST_STOP_OFFSET;
preamble -> txm_module_preamble_callback_function = base + TEST_CALLBACK_OFFSET;
preamble -> txm_module_preamble_start_stop_priority = ((ULONG) 10);
preamble -> txm_module_preamble_start_stop_stack_size = ((ULONG) 256);
preamble -> txm_module_preamble_callback_priority = ((ULONG) 10);
preamble -> txm_module_preamble_callback_stack_size = ((ULONG) 256);
preamble -> txm_module_preamble_code_size = TEST_IMAGE_BYTES;
preamble -> txm_module_preamble_data_size = ((ULONG) 128);
}


/* Load a module requesting the given options through one loader, from an empty
manager, and check the status and that the mutex is free afterwards. */
static VOID test_load_expect(UINT absolute, ULONG options, UINT expected, const char *what)
{

char description[200];
const char *loader_name;
UINT status;


memset(&test_instance, 0, sizeof(test_instance));
_txm_module_manager_loaded_list_ptr = TX_NULL;
_txm_module_manger_loaded_count = ((ULONG) 0);
test_pool_offset = ((ULONG) 0);

test_image_build(options, absolute);

if (absolute != TX_FALSE)
{
loader_name = "absolute_load_extended";
status = _txm_module_manager_absolute_load_extended(&test_instance, "module", test_mapping, test_mapping + TEST_DATA_OFFSET);
}
else
{
loader_name = "in_place_load";
status = _txm_module_manager_in_place_load(&test_instance, "module", test_mapping);
}

snprintf(description, sizeof(description), "%s: %s", loader_name, what);
test_expect(description, (ULONG) status, (ULONG) expected);

snprintf(description, sizeof(description), "%s: %s leaves the mutex free", loader_name, what);
test_expect(description, test_mutex_depth, ((ULONG) 0));
}


int main(void)
{

UINT absolute;


test_mapping = (UCHAR *) mmap((VOID *) TEST_MAPPING_HINT, (size_t) TEST_MAPPING_BYTES, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
if ((test_mapping == (UCHAR *) MAP_FAILED) ||
((ALIGN_TYPE) test_mapping > (ALIGN_TYPE) (((ULONG) 0xFFFFFFFFUL) - TEST_MAPPING_BYTES)))
{
printf("ERROR: could not map the module image below 4 GiB\n");
return(1);
}

(VOID) _txm_module_manager_initialize((VOID *) (test_mapping + TEST_ARENA_OFFSET), TEST_MAPPING_BYTES - TEST_ARENA_OFFSET);

test_expect("the manager is ready", (ULONG) _txm_module_manager_ready, (ULONG) TX_TRUE);
test_expect("the port does not support user mode",
_txm_module_manager_properties_supported & TXM_MODULE_USER_MODE, ((ULONG) 0));
test_expect("the port does not support memory protection",
_txm_module_manager_properties_supported & TXM_MODULE_MEMORY_PROTECTION, ((ULONG) 0));
test_expect("the port supports shared external memory access",
_txm_module_manager_properties_supported & TXM_MODULE_SHARED_EXTERNAL_MEMORY_ACCESS,
TXM_MODULE_SHARED_EXTERNAL_MEMORY_ACCESS);
test_expect("the port requires no option", _txm_module_manager_properties_required, ((ULONG) 0));

for (absolute = TX_FALSE; absolute <= TX_TRUE; absolute++)
{
test_load_expect(absolute, TXM_MODULE_USER_MODE, TXM_MODULE_INVALID_PROPERTIES,
"a user-mode module is refused");
test_load_expect(absolute, TXM_MODULE_USER_MODE | TXM_MODULE_MEMORY_PROTECTION, TXM_MODULE_INVALID_PROPERTIES,
"a user-mode, memory-protected module is refused");
test_load_expect(absolute, TXM_MODULE_USER_MODE | TXM_MODULE_MEMORY_PROTECTION | TXM_MODULE_SHARED_EXTERNAL_MEMORY_ACCESS,
TXM_MODULE_INVALID_PROPERTIES, "a user-mode, memory-protected module with shared memory is refused");
test_load_expect(absolute, ((ULONG) 0), TX_SUCCESS, "a privileged module loads");
test_load_expect(absolute, TXM_MODULE_SHARED_EXTERNAL_MEMORY_ACCESS, TX_SUCCESS,
"a privileged module with shared memory loads");
}

test_expect("the interrupt lock is balanced", (ULONG) test_interrupt_disable_depth, ((ULONG) 0));
test_expect("the interrupt lock never underflowed", (ULONG) test_interrupt_restore_underflows, ((ULONG) 0));

if (test_failures == 0U)
{
printf("SUCCESS! %lu expectations\n", (unsigned long) test_checks);
return(0);
}

printf("ERROR: %u expectation(s) failed of %lu\n", test_failures, (unsigned long) test_checks);
return(1);
}