/*************************************************************************** * 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). * 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 **************************************************************************/ /* This test drives every application timer and system time service with event tracing enabled. Each service carries one in-line trace insert, and that insert behaves differently according to the system state it runs in, whether its event is filtered, whether it is the entry that wraps the trace buffer, and whether a buffer-full notification is registered. The test walks the services once per combination, so every service's insert is driven through all of them. The timer and the time services sit in two different trace event classes, so the filtered pass filters both. Without event tracing compiled in the inserts expand to nothing, so the test only checks that the trace services report the feature as disabled. */ #include #include "tx_api.h" #define TX_SOURCE_CODE #include "tx_trace.h" #include "tx_initialize.h" /* Define the ISR dispatch. */ extern VOID (*test_isr_dispatch)(void); /* Define the services, in the order the test drives them. The scratch timer is created by the first and deleted by the last, and the resident timer is left deactivated with a full tick count by the change that follows its deactivation, so a pass over the whole list leaves the system as it found it. */ #define TIMER_SERVICE_CREATE 0 #define TIMER_SERVICE_ACTIVATE 1 #define TIMER_SERVICE_INFO_GET 2 #define TIMER_SERVICE_DEACTIVATE 3 #define TIMER_SERVICE_CHANGE 4 #define TIMER_SERVICE_TIME_GET 5 #define TIMER_SERVICE_TIME_SET 6 #define TIMER_SERVICE_DELETE 7 #define TIMER_SERVICES 8 /* The services an ISR is allowed to call. Create is rejected by the error checking shell from an interrupt, and delete from any caller that is not a thread. */ #define TIMER_ISR_FIRST_SERVICE TIMER_SERVICE_ACTIVATE #define TIMER_ISR_LAST_SERVICE TIMER_SERVICE_TIME_SET /* The expiration the resident timer carries. It is long enough that a pass cannot expire it, and the change service restores it after every deactivation so that the next activation always has ticks to run. */ #define TIMER_TICKS 100 static unsigned long thread_0_counter = 0; static TX_THREAD thread_0; static TX_TIMER timer_0; static TX_TIMER timer_1; static unsigned long timer_0_counter = 0; /* The system clock the time get service read, written back by the time set service that follows it. Driving the set with a value the get has just produced keeps the clock where the rest of the system expects it. */ static ULONG saved_time = 0; static ULONG buffer_full_count = 0; static ULONG isr_pass_done = 0; static UINT isr_status = TX_SUCCESS; /* The trace buffer is deliberately small. Several passes over the services fit in it many times over, so the wrap path is reached by ordinary use as well as by the positioned wrap below. */ static UCHAR trace_buffer[512]; #define TRACE_REGISTRY_ENTRIES 4 /* Define thread prototypes. */ static void thread_0_entry(ULONG thread_input); static void timer_0_entry(ULONG timer_input); /* Prototype for test control return. */ void test_control_return(UINT status); /* The resident timer's expiration function. The timer is deactivated by every pass long before it expires, so this only runs if a pass is interrupted for longer than its expiration. */ static void timer_0_entry(ULONG timer_input) { timer_0_counter++; } /* Drive one service through its published entry point. */ static UINT timer_service(UINT service) { UINT status; CHAR *name; UINT active; ULONG remaining_ticks; ULONG reschedule_ticks; TX_TIMER *next_timer; switch (service) { case TIMER_SERVICE_CREATE: status = tx_timer_create(&timer_1, "timer 1", timer_0_entry, 1, TIMER_TICKS, TIMER_TICKS, TX_NO_ACTIVATE); break; case TIMER_SERVICE_ACTIVATE: status = tx_timer_activate(&timer_0); break; case TIMER_SERVICE_INFO_GET: status = tx_timer_info_get(&timer_0, &name, &active, &remaining_ticks, &reschedule_ticks, &next_timer); break; case TIMER_SERVICE_DEACTIVATE: status = tx_timer_deactivate(&timer_0); break; case TIMER_SERVICE_CHANGE: status = tx_timer_change(&timer_0, TIMER_TICKS, TIMER_TICKS); break; case TIMER_SERVICE_TIME_GET: saved_time = tx_time_get(); status = TX_SUCCESS; break; case TIMER_SERVICE_TIME_SET: tx_time_set(saved_time); status = TX_SUCCESS; break; default: status = tx_timer_delete(&timer_1); break; } return(status); } #ifdef TX_ENABLE_EVENT_TRACE /* Drive one service through its internal entry point. The error checking shell rejects a create from an interrupt, a delete from any caller that is not a thread, and a change from initialization, so the inserts inside those three services cannot be reached from a forced system state through the published entry points. The shell itself is covered by its own tests; what is under test here is the insert behind it. */ static UINT timer_service_internal(UINT service) { UINT status; CHAR *name; UINT active; ULONG remaining_ticks; ULONG reschedule_ticks; TX_TIMER *next_timer; switch (service) { case TIMER_SERVICE_CREATE: status = _tx_timer_create(&timer_1, "timer 1", timer_0_entry, 1, TIMER_TICKS, TIMER_TICKS, TX_NO_ACTIVATE); break; case TIMER_SERVICE_ACTIVATE: status = _tx_timer_activate(&timer_0); break; case TIMER_SERVICE_INFO_GET: status = _tx_timer_info_get(&timer_0, &name, &active, &remaining_ticks, &reschedule_ticks, &next_timer); break; case TIMER_SERVICE_DEACTIVATE: status = _tx_timer_deactivate(&timer_0); break; case TIMER_SERVICE_CHANGE: status = _tx_timer_change(&timer_0, TIMER_TICKS, TIMER_TICKS); break; case TIMER_SERVICE_TIME_GET: saved_time = _tx_time_get(); status = TX_SUCCESS; break; case TIMER_SERVICE_TIME_SET: _tx_time_set(saved_time); status = TX_SUCCESS; break; default: status = _tx_timer_delete(&timer_1); break; } return(status); } /* Run a pass over the services with the system state forced to the value the insert has to see. Interrupts are held off across the pass, so the timer thread cannot observe the forced state and the interrupt nesting count the same variable carries is restored before anything else reads it. */ static UINT pass_with_system_state(ULONG system_state) { TX_INTERRUPT_SAVE_AREA UINT service; UINT status = TX_SUCCESS; ULONG saved_system_state; TX_DISABLE saved_system_state = _tx_thread_system_state; _tx_thread_system_state = system_state; for (service = 0; service < TIMER_SERVICES; service++) { if (timer_service_internal(service) != TX_SUCCESS) { status = TX_NOT_DONE; } } _tx_thread_system_state = saved_system_state; TX_RESTORE return(status); } /* Position the trace buffer one entry short of its end, so that the next event inserted is the one that wraps it. A wrap reached by filling the buffer lands on whichever service happens to write the last entry; positioning puts each service's own insert on the boundary in turn. No service here writes a trace entry ahead of its own insert, so one entry is the right distance for every one of them. */ static void position_at_buffer_end(void) { TX_INTERRUPT_SAVE_AREA TX_DISABLE _tx_trace_buffer_current_ptr = _tx_trace_buffer_end_ptr - 1; _tx_trace_header_ptr -> tx_trace_header_buffer_current_pointer = (ULONG) _tx_trace_buffer_current_ptr; TX_RESTORE } /* Run a pass over the services, wrapping the trace buffer on every one of them. */ static UINT pass_with_buffer_wrap(void) { UINT service; UINT status = TX_SUCCESS; for (service = 0; service < TIMER_SERVICES; service++) { position_at_buffer_end(); if (timer_service(service) != TX_SUCCESS) { status = TX_NOT_DONE; } } return(status); } /* Count the trace buffer wraps the kernel reports. */ static VOID trace_buffer_full(void *buffer) { buffer_full_count++; } /* Drive the services an ISR may call, once, from interrupt context. */ static void test_isr(void) { UINT service; if (isr_pass_done == 0) { for (service = TIMER_ISR_FIRST_SERVICE; service <= TIMER_ISR_LAST_SERVICE; service++) { if (timer_service(service) != TX_SUCCESS) { isr_status = TX_NOT_DONE; } } isr_pass_done = 1; } } #endif /* Define what the initial system looks like. */ #ifdef CTEST void test_application_define(void *first_unused_memory) #else void threadx_timer_trace_application_define(void *first_unused_memory) #endif { UINT status; CHAR *pointer; /* Put first available memory address into a character pointer. */ pointer = (CHAR *) first_unused_memory; /* Put system definition stuff in here, e.g. thread creates and other assorted create information. */ status = tx_thread_create(&thread_0, "thread 0", thread_0_entry, 1, pointer, TEST_STACK_SIZE_PRINTF, 16, 16, TX_NO_TIME_SLICE, TX_AUTO_START); pointer = pointer + TEST_STACK_SIZE_PRINTF; /* Check for status. */ if (status != TX_SUCCESS) { printf("Running Timer Trace Test........................................... ERROR #1\n"); test_control_return(1); } /* Create the timer the activate, change, deactivate and information services are driven against. It is left inactive, which is the state every pass starts and finishes in. */ status = tx_timer_create(&timer_0, "timer 0", timer_0_entry, 0, TIMER_TICKS, TIMER_TICKS, TX_NO_ACTIVATE); /* Check for status. */ if (status != TX_SUCCESS) { printf("Running Timer Trace Test........................................... ERROR #2\n"); test_control_return(1); } } /* Define the test thread. */ static void thread_0_entry(ULONG thread_input) { UINT status; UINT service; #ifdef TX_ENABLE_EVENT_TRACE ULONG wait; #endif /* Increment thread 0 counter. */ thread_0_counter++; /* Inform user of success getting to this test. */ printf("Running Timer Trace Test........................................... "); /* Enable event tracing. */ status = tx_trace_enable(trace_buffer, sizeof(trace_buffer), TRACE_REGISTRY_ENTRIES); #ifndef TX_ENABLE_EVENT_TRACE /* Without tracing compiled in the inserts expand to nothing, so there is nothing here to drive. Check that the service says so and finish. */ if (status != TX_FEATURE_NOT_ENABLED) { printf("ERROR #3\n"); test_control_return(1); } /* One pass over the services, so the test still exercises them. */ for (service = 0; service < TIMER_SERVICES; service++) { if (timer_service(service) != TX_SUCCESS) { printf("ERROR #4\n"); test_control_return(1); } } printf("SUCCESS!\n"); test_control_return(0); #else if (status != TX_SUCCESS) { printf("ERROR #5\n"); test_control_return(1); } /* Thread context, every event enabled: the insert runs and takes the current thread's priority. */ for (service = 0; service < TIMER_SERVICES; service++) { if (timer_service(service) != TX_SUCCESS) { printf("ERROR #6\n"); test_control_return(1); } } /* Timer and time events filtered out: the insert is reached and declines to record anything. The two classes are distinct, so both are filtered. */ status = tx_trace_event_filter(TX_TRACE_TIMER_EVENTS | TX_TRACE_TIME_EVENTS); if (status != TX_SUCCESS) { printf("ERROR #7\n"); test_control_return(1); } for (service = 0; service < TIMER_SERVICES; service++) { if (timer_service(service) != TX_SUCCESS) { printf("ERROR #8\n"); test_control_return(1); } } status = tx_trace_event_unfilter(TX_TRACE_TIMER_EVENTS | TX_TRACE_TIME_EVENTS); if (status != TX_SUCCESS) { printf("ERROR #9\n"); test_control_return(1); } /* Interrupt context: the insert records the interrupted thread instead of a priority. Bounded, so a tick that never arrives fails the test rather than hanging it. */ test_isr_dispatch = test_isr; wait = 0; while ((isr_pass_done == 0) && (wait < 100)) { tx_thread_sleep(1); wait++; } test_isr_dispatch = TX_NULL; if (isr_pass_done == 0) { printf("ERROR #10\n"); test_control_return(1); } if (isr_status != TX_SUCCESS) { printf("ERROR #11\n"); test_control_return(1); } /* Initialization context: the insert has no thread to record at all. */ if (pass_with_system_state(TX_INITIALIZE_IN_PROGRESS) != TX_SUCCESS) { printf("ERROR #12\n"); test_control_return(1); } /* The same state an ISR presents, for the services an ISR may not call. */ if (pass_with_system_state((ULONG) 1) != TX_SUCCESS) { printf("ERROR #13\n"); test_control_return(1); } /* Wrap the trace buffer on every service with no notification registered, then again with one. */ if (pass_with_buffer_wrap() != TX_SUCCESS) { printf("ERROR #14\n"); test_control_return(1); } status = tx_trace_buffer_full_notify(trace_buffer_full); if (status != TX_SUCCESS) { printf("ERROR #15\n"); test_control_return(1); } if (pass_with_buffer_wrap() != TX_SUCCESS) { printf("ERROR #16\n"); test_control_return(1); } /* Every service in the last pass wrapped the buffer, so the notification has to have been called once for each of them. */ if (buffer_full_count < TIMER_SERVICES) { printf("ERROR #17\n"); test_control_return(1); } status = tx_trace_buffer_full_notify(TX_NULL); if (status != TX_SUCCESS) { printf("ERROR #18\n"); test_control_return(1); } status = tx_trace_disable(); if (status != TX_SUCCESS) { printf("ERROR #19\n"); test_control_return(1); } printf("SUCCESS!\n"); test_control_return(0); #endif }