VOID - syntax, references, description

References

from 0/34 examples

Code

Location

#define VOID void

tx_port.h:107

#define VOID void

tx_port.h:77

VOID (*tx_timer_internal_timeout_function)(ULONG id);

tx_api.h:293

VOID *tx_thread_stack_ptr; /* Thread's stack pointer */

tx_api.h:378

VOID *tx_thread_stack_start; /* Stack starting address */

tx_api.h:379

VOID *tx_thread_stack_end; /* Stack ending address */

tx_api.h:380

VOID (*tx_thread_schedule_hook)(struct TX_THREAD_STRUCT *thread_ptr, ULONG id);

tx_api.h:406

VOID (*tx_thread_entry)(ULONG id);

tx_api.h:414

VOID (*tx_thread_suspend_cleanup)(struct TX_THREAD_STRUCT *thread_ptr, ULONG suspension_sequence);

tx_api.h:425

VOID *tx_thread_suspend_control_block;

tx_api.h:426

VOID *tx_thread_additional_suspend_info;

tx_api.h:431

VOID *tx_thread_filex_ptr;

tx_api.h:451

VOID *tx_thread_stack_highest_ptr; /* Stack highest usage pointer */

tx_api.h:504

VOID (*tx_thread_entry_exit_notify)(struct TX_THREAD_STRUCT *thread_ptr, UINT type);

tx_api.h:511

VOID (*tx_event_flags_group_set_notify)(struct TX_EVENT_FLAGS_GROUP_STRUCT *group_ptr);

tx_api.h:751

VOID (*tx_queue_send_notify)(struct TX_QUEUE_STRUCT *queue_ptr);

tx_api.h:927

VOID (*tx_semaphore_put_notify)(struct TX_SEMAPHORE_STRUCT *semaphore_ptr);

tx_api.h:982

VOID tx_application_define(VOID *first_unused_memory);

tx_api.h:1364

UINT _tx_block_allocate(TX_BLOCK_POOL *pool_ptr, VOID **block_ptr, ULONG wait_option);

tx_api.h:1372

VOID *pool_start, ULONG pool_size);

tx_api.h:1374

UINT _tx_block_release(VOID *block_ptr);

tx_api.h:1384

UINT _txe_block_allocate(TX_BLOCK_POOL *pool_ptr, VOID **block_ptr, ULONG wait_option);

tx_api.h:1390

VOID *pool_start, ULONG pool_size, UINT pool_control_block_size);

tx_api.h:1392

UINT _txe_block_release(VOID *block_ptr);

tx_api.h:1398

UINT _tx_byte_allocate(TX_BYTE_POOL *pool_ptr, VOID **memory_ptr, ULONG memory_size,

tx_api.h:1414

UINT _tx_byte_pool_create(TX_BYTE_POOL *pool_ptr, CHAR *name_ptr, VOID *pool_start,

tx_api.h:1416

UINT _tx_byte_release(VOID *memory_ptr);

tx_api.h:1427

UINT _txe_byte_allocate(TX_BYTE_POOL *pool_ptr, VOID **memory_ptr, ULONG memory_size,

tx_api.h:1433

UINT _txe_byte_pool_create(TX_BYTE_POOL *pool_ptr, CHAR *name_ptr, VOID *pool_start,

tx_api.h:1435

UINT _txe_byte_release(VOID *memory_ptr);

tx_api.h:1442

UINT _tx_event_flags_set_notify(TX_EVENT_FLAGS_GROUP *group_ptr, VOID (*events_set_notify)(TX_EVENT_FLAGS_GROUP *notify_group_ptr));

tx_api.h:1472

UINT _txe_event_flags_set_notify(TX_EVENT_FLAGS_GROUP *group_ptr, VOID (*events_set_notify)(TX_EVENT_FLAGS_GROUP *notify_group_ptr));

tx_api.h:1487

VOID _tx_initialize_kernel_enter(VOID);

tx_api.h:1504

VOID *queue_start, ULONG queue_size);

tx_api.h:1549

UINT _tx_queue_receive(TX_QUEUE *queue_ptr, VOID *destination_ptr, ULONG wait_option);

tx_api.h:1559

UINT _tx_queue_send(TX_QUEUE *queue_ptr, VOID *source_ptr, ULONG wait_option);

tx_api.h:1560

UINT _tx_queue_send_notify(TX_QUEUE *queue_ptr, VOID (*queue_send_notify)(TX_QUEUE *notify_queue_ptr));

tx_api.h:1561

UINT _tx_queue_front_send(TX_QUEUE *queue_ptr, VOID *source_ptr, ULONG wait_option);

tx_api.h:1562

VOID *queue_start, ULONG queue_size, UINT queue_control_block_size);

tx_api.h:1569

UINT _txe_queue_receive(TX_QUEUE *queue_ptr, VOID *destination_ptr, ULONG wait_option);

tx_api.h:1575

UINT _txe_queue_send(TX_QUEUE *queue_ptr, VOID *source_ptr, ULONG wait_option);

tx_api.h:1576

UINT _txe_queue_send_notify(TX_QUEUE *queue_ptr, VOID (*queue_send_notify)(TX_QUEUE *notify_queue_ptr));

tx_api.h:1577

UINT _txe_queue_front_send(TX_QUEUE *queue_ptr, VOID *source_ptr, ULONG wait_option);

tx_api.h:1578

UINT _tx_semaphore_put_notify(TX_SEMAPHORE *semaphore_ptr, VOID (*semaphore_put_notify)(TX_SEMAPHORE *notify_semaphore_ptr));

tx_api.h:1608

UINT _txe_semaphore_put_notify(TX_SEMAPHORE *semaphore_ptr, VOID (*semaphore_put_notify)(TX_SEMAPHORE *notify_semaphore_ptr));

tx_api.h:1623

VOID _tx_thread_context_save(VOID);

tx_api.h:1640

VOID _tx_thread_context_restore(VOID);

tx_api.h:1641

VOID (*entry_function)(ULONG entry_input), ULONG entry_input,

tx_api.h:1643

VOID *stack_start, ULONG stack_size,

tx_api.h:1644

UINT _tx_thread_entry_exit_notify(TX_THREAD *thread_ptr, VOID (*thread_entry_exit_notify)(TX_THREAD *notify_thread_ptr, UINT type));

tx_api.h:1648

TX_THREAD *_tx_thread_identify(VOID);

tx_api.h:1649

VOID _tx_thread_relinquish(VOID);

tx_api.h:1665

UINT _tx_thread_stack_error_notify(VOID (*stack_error_handler)(TX_THREAD *thread_ptr));

tx_api.h:1669

VOID (*entry_function)(ULONG entry_input), ULONG entry_input,

tx_api.h:1680

VOID *stack_start, ULONG stack_size,

tx_api.h:1681

UINT _txe_thread_entry_exit_notify(TX_THREAD *thread_ptr, VOID (*thread_entry_exit_notify)(TX_THREAD *notify_thread_ptr, UINT type));

tx_api.h:1685

VOID _txe_thread_relinquish(VOID);

tx_api.h:1693

VOID (*expiration_function)(ULONG input), ULONG expiration_input,

tx_api.h:1729

ULONG _tx_time_get(VOID);

tx_api.h:1740

VOID _tx_time_set(ULONG new_time);

tx_api.h:1741

VOID (*expiration_function)(ULONG input), ULONG expiration_input,

tx_api.h:1750

UINT _tx_trace_enable(VOID *trace_buffer_start, ULONG trace_buffer_size, ULONG registry_entries);

tx_api.h:1771

UINT _tx_trace_disable(VOID);

tx_api.h:1774

VOID _tx_trace_isr_enter_insert(ULONG isr_id);

tx_api.h:1775

VOID _tx_trace_isr_exit_insert(ULONG isr_id);

tx_api.h:1776

UINT _tx_trace_buffer_full_notify(VOID (*full_buffer_callback)(VOID *buffer));

tx_api.h:1777

#define TX_POINTER_TO_ULONG_CONVERT(a) ((ULONG) ((VOID *) (a)))

tx_api.h:1929

#define TX_INDIRECT_VOID_TO_UCHAR_POINTER_CONVERT(a) ((UCHAR **) ((VOID *) (a)))

tx_api.h:1943

#define TX_UCHAR_TO_INDIRECT_UCHAR_POINTER_CONVERT(a) ((UCHAR **) ((VOID *) (a)))

tx_api.h:1944

#define TX_BLOCK_POOL_TO_UCHAR_POINTER_CONVERT(a) ((UCHAR *) ((VOID *) (a)))

tx_api.h:1945

#define TX_VOID_TO_BLOCK_POOL_POINTER_CONVERT(a) ((TX_BLOCK_POOL *) ((VOID *) (a)))

tx_api.h:1946

#define TX_VOID_TO_UCHAR_POINTER_CONVERT(a) ((UCHAR *) ((VOID *) (a)))

tx_api.h:1947

#define TX_UCHAR_TO_BLOCK_POOL_POINTER_CONVERT(a) ((TX_BLOCK_POOL *) ((VOID *) (a)))

tx_api.h:1948

#define TX_VOID_TO_INDIRECT_UCHAR_POINTER_CONVERT(a) ((UCHAR **) ((VOID *) (a)))

tx_api.h:1949

#define TX_VOID_TO_BYTE_POOL_POINTER_CONVERT(a) ((TX_BYTE_POOL *) ((VOID *) (a)))

tx_api.h:1950

#define TX_BYTE_POOL_TO_UCHAR_POINTER_CONVERT(a) ((UCHAR *) ((VOID *) (a)))

tx_api.h:1951

#define TX_UCHAR_TO_ALIGN_TYPE_POINTER_CONVERT(a) ((ALIGN_TYPE *) ((VOID *) (a)))

tx_api.h:1953

#define TX_UCHAR_TO_INDIRECT_BYTE_POOL_POINTER(a) ((TX_BYTE_POOL **) ((VOID *) (a)))

tx_api.h:1955

#define TX_VOID_TO_EVENT_FLAGS_POINTER_CONVERT(a) ((TX_EVENT_FLAGS_GROUP *) ((VOID *) (a)))

tx_api.h:1956

#define TX_VOID_TO_ULONG_POINTER_CONVERT(a) ((ULONG *) ((VOID *) (a)))

tx_api.h:1957

#define TX_VOID_TO_MUTEX_POINTER_CONVERT(a) ((TX_MUTEX *) ((VOID *) (a)))

tx_api.h:1958

#define TX_VOID_TO_QUEUE_POINTER_CONVERT(a) ((TX_QUEUE *) ((VOID *) (a)))

tx_api.h:1959

#define TX_VOID_TO_SEMAPHORE_POINTER_CONVERT(a) ((TX_SEMAPHORE *) ((VOID *) (a)))

tx_api.h:1960

#define TX_UCHAR_TO_VOID_POINTER_CONVERT(a) ((VOID *) (a))

tx_api.h:1961

#define TX_ULONG_TO_THREAD_POINTER_CONVERT(a) ((TX_THREAD *) ((VOID *) (a)))

tx_api.h:1962

#define TX_TIMER_INDIRECT_TO_VOID_POINTER_CONVERT(a) ((VOID *) (a))

tx_api.h:1964

#define TX_CONST_CHAR_TO_CHAR_POINTER_CONVERT(a) ((CHAR *) ((VOID *) (a)))

tx_api.h:1969

UINT _tx_block_allocate(TX_BLOCK_POOL *pool_ptr, VOID **block_ptr, ULONG wait_option)

tx_block_allocate.c:80

thread_ptr -> tx_thread_suspend_control_block = (VOID *) pool_ptr;

tx_block_allocate.c:250

thread_ptr -> tx_thread_additional_suspend_info = (VOID *) block_ptr;

tx_block_allocate.c:253

VOID _tx_block_pool_initialize(VOID);

tx_block_pool.h:84

VOID _tx_block_pool_cleanup(TX_THREAD *thread_ptr, ULONG suspension_sequence);

tx_block_pool.h:90

VOID _tx_block_pool_cleanup(TX_THREAD *thread_ptr, ULONG suspension_sequence)

tx_block_pool_cleanup.c:78

VOID *pool_start, ULONG pool_size)

tx_block_pool_create.c:78

UINT _tx_block_release(VOID *block_ptr)

tx_block_release.c:75

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

tx_byte_allocate.c:82

*memory_ptr = (VOID *) work_ptr;

tx_byte_allocate.c:203

thread_ptr -> tx_thread_suspend_control_block = (VOID *) pool_ptr;

tx_byte_allocate.c:287

thread_ptr -> tx_thread_additional_suspend_info = (VOID *) memory_ptr;

tx_byte_allocate.c:290

VOID _tx_byte_pool_initialize(VOID);

tx_byte_pool.h:99

VOID _tx_byte_pool_cleanup(TX_THREAD *thread_ptr, ULONG suspension_sequence);

tx_byte_pool.h:106

VOID _tx_byte_pool_cleanup(TX_THREAD *thread_ptr, ULONG suspension_sequence)

tx_byte_pool_cleanup.c:78

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

tx_byte_pool_create.c:76

pool_ptr -> tx_byte_pool_available = pool_size - ((sizeof(VOID *)) + (sizeof(ALIGN_TYPE)));

tx_byte_pool_create.c:111

UINT _tx_byte_release(VOID *memory_ptr)

tx_byte_release.c:77

VOID _tx_event_flags_initialize(VOID);

tx_event_flags.h:85

VOID _tx_event_flags_cleanup(TX_THREAD *thread_ptr, ULONG suspension_sequence);

tx_event_flags.h:91

VOID _tx_event_flags_cleanup(TX_THREAD *thread_ptr, ULONG suspension_sequence)

tx_event_flags_cleanup.c:78

thread_ptr -> tx_thread_additional_suspend_info = (VOID *) actual_flags_ptr;

tx_event_flags_get.c:313

thread_ptr -> tx_thread_suspend_control_block = (VOID *) group_ptr;

tx_event_flags_get.c:317

VOID (*events_set_notify)(struct TX_EVENT_FLAGS_GROUP_STRUCT *notify_group_ptr);

tx_event_flags_set.c:105

UINT _tx_event_flags_set_notify(TX_EVENT_FLAGS_GROUP *group_ptr, VOID (*events_set_notify)(TX_EVENT_FLAGS_GROUP *notify_group_ptr))

tx_event_flags_set_notify.c:75

VOID _tx_initialize_high_level(VOID);

tx_initialize.h:63

VOID _tx_initialize_kernel_setup(VOID);

tx_initialize.h:64

VOID _tx_initialize_low_level(VOID);

tx_initialize.h:65

INITIALIZE_DECLARE VOID *_tx_initialize_unused_memory;

tx_initialize.h:110

VOID *_tx_initialize_unused_memory;

tx_initialize_high_level.c:52

VOID _tx_initialize_high_level(VOID)

tx_initialize_high_level.c:113

VOID _tx_initialize_kernel_enter(VOID)

tx_initialize_kernel_enter.c:92

VOID _tx_initialize_kernel_setup(VOID)

tx_initialize_kernel_setup.c:76

VOID tx_low_power_enter(VOID)

tx_low_power.c:85

VOID tx_low_power_exit(VOID)

tx_low_power.c:206

VOID tx_time_increment(ULONG time_increment)

tx_low_power.c:413

VOID tx_low_power_enter(VOID);

tx_low_power.h:52

VOID tx_low_power_exit(VOID);

tx_low_power.h:53

VOID tx_time_increment(ULONG time_increment);

tx_low_power.h:54

VOID _tx_mutex_initialize(VOID);

tx_mutex.h:86

VOID _tx_mutex_cleanup(TX_THREAD *thread_ptr, ULONG suspension_sequence);

tx_mutex.h:92

VOID _tx_mutex_thread_release(TX_THREAD *thread_ptr);

tx_mutex.h:93

VOID _tx_mutex_priority_change(TX_THREAD *thread_ptr, UINT new_priority);

tx_mutex.h:94

VOID _tx_mutex_cleanup(TX_THREAD *thread_ptr, ULONG suspension_sequence)

tx_mutex_cleanup.c:78

VOID _tx_mutex_thread_release(TX_THREAD *thread_ptr)

tx_mutex_cleanup.c:259

thread_ptr -> tx_thread_suspend_control_block = (VOID *) mutex_ptr;

tx_mutex_get.c:252

VOID _tx_mutex_priority_change(TX_THREAD *thread_ptr, UINT new_priority)

tx_mutex_priority_change.c:87

#define TX_THREAD_EXTENSION_2 VOID *tx_thread_module_instance_ptr; \

tx_port.h:169

VOID *tx_thread_module_entry_info_ptr; \

tx_port.h:170

VOID *tx_thread_module_kernel_stack_start; \

tx_port.h:174

VOID *tx_thread_module_kernel_stack_end; \

tx_port.h:175

VOID *tx_thread_module_stack_ptr; \

tx_port.h:177

VOID *tx_thread_module_stack_start; \

tx_port.h:178

VOID *tx_thread_module_stack_end; \

tx_port.h:179

VOID *tx_thread_module_reserved;

tx_port.h:181

#define TX_EVENT_FLAGS_GROUP_EXTENSION VOID *tx_event_flags_group_module_instance; \

tx_port.h:190

VOID (*tx_event_flags_group_set_module_notify)(struct TX_EVENT_FLAGS_GROUP_STRUCT *group_ptr);

tx_port.h:191

#define TX_QUEUE_EXTENSION VOID *tx_queue_module_instance; \

tx_port.h:193

VOID (*tx_queue_send_module_notify)(struct TX_QUEUE_STRUCT *queue_ptr);

tx_port.h:194

#define TX_SEMAPHORE_EXTENSION VOID *tx_semaphore_module_instance; \

tx_port.h:196

VOID (*tx_semaphore_put_module_notify)(struct TX_SEMAPHORE_STRUCT *semaphore_ptr);

tx_port.h:197

#define TX_TIMER_EXTENSION VOID *tx_timer_module_instance; \

tx_port.h:199

VOID (*tx_timer_module_expiration_function)(ULONG id);

tx_port.h:200

VOID _tx_queue_initialize(VOID);

tx_queue.h:84

VOID _tx_queue_cleanup(TX_THREAD *thread_ptr, ULONG suspension_sequence);

tx_queue.h:106

VOID _tx_queue_cleanup(TX_THREAD *thread_ptr, ULONG suspension_sequence)

tx_queue_cleanup.c:78

VOID *queue_start, ULONG queue_size)

tx_queue_create.c:78

UINT _tx_queue_front_send(TX_QUEUE *queue_ptr, VOID *source_ptr, ULONG wait_option)

tx_queue_front_send.c:80

VOID (*queue_send_notify)(struct TX_QUEUE_STRUCT *notify_queue_ptr);

tx_queue_front_send.c:94

thread_ptr -> tx_thread_suspend_control_block = (VOID *) queue_ptr;

tx_queue_front_send.c:312

thread_ptr -> tx_thread_additional_suspend_info = (VOID *) source_ptr;

tx_queue_front_send.c:313

UINT _tx_queue_receive(TX_QUEUE *queue_ptr, VOID *destination_ptr, ULONG wait_option)

tx_queue_receive.c:82

thread_ptr -> tx_thread_suspend_control_block = (VOID *) queue_ptr;

tx_queue_receive.c:407

thread_ptr -> tx_thread_additional_suspend_info = (VOID *) destination_ptr;

tx_queue_receive.c:408

UINT _tx_queue_send(TX_QUEUE *queue_ptr, VOID *source_ptr, ULONG wait_option)

tx_queue_send.c:80

VOID (*queue_send_notify)(struct TX_QUEUE_STRUCT *notify_queue_ptr);

tx_queue_send.c:94

thread_ptr -> tx_thread_suspend_control_block = (VOID *) queue_ptr;

tx_queue_send.c:314

thread_ptr -> tx_thread_additional_suspend_info = (VOID *) source_ptr;

tx_queue_send.c:315

UINT _tx_queue_send_notify(TX_QUEUE *queue_ptr, VOID (*queue_send_notify)(TX_QUEUE *notify_queue_ptr))

tx_queue_send_notify.c:75

VOID _tx_semaphore_initialize(VOID);

tx_semaphore.h:81

VOID _tx_semaphore_cleanup(TX_THREAD *thread_ptr, ULONG suspension_sequence);

tx_semaphore.h:87

VOID (*semaphore_put_notify)(struct TX_SEMAPHORE_STRUCT *notify_semaphore_ptr);

tx_semaphore_ceiling_put.c:83

VOID _tx_semaphore_cleanup(TX_THREAD *thread_ptr, ULONG suspension_sequence)

tx_semaphore_cleanup.c:78

thread_ptr -> tx_thread_suspend_control_block = (VOID *) semaphore_ptr;

tx_semaphore_get.c:155

VOID (*semaphore_put_notify)(struct TX_SEMAPHORE_STRUCT *notify_semaphore_ptr);

tx_semaphore_put.c:81

UINT _tx_semaphore_put_notify(TX_SEMAPHORE *semaphore_ptr, VOID (*semaphore_put_notify)(TX_SEMAPHORE *notify_semaphore_ptr))

tx_semaphore_put_notify.c:75

VOID _tx_thread_initialize(VOID);

tx_thread.h:278

VOID _tx_thread_schedule(VOID);

tx_thread.h:279

VOID _tx_thread_shell_entry(VOID);

tx_thread.h:280

VOID _tx_thread_stack_analyze(TX_THREAD *thread_ptr);

tx_thread.h:281

VOID _tx_thread_stack_build(TX_THREAD *thread_ptr, VOID (*function_ptr)(VOID));

tx_thread.h:282

VOID _tx_thread_stack_error(TX_THREAD *thread_ptr);

tx_thread.h:283

VOID _tx_thread_stack_error_handler(TX_THREAD *thread_ptr);

tx_thread.h:284

VOID _tx_thread_system_preempt_check(VOID);

tx_thread.h:285

VOID _tx_thread_system_resume(TX_THREAD *thread_ptr);

tx_thread.h:286

VOID _tx_thread_system_ni_resume(TX_THREAD *thread_ptr);

tx_thread.h:287

VOID _tx_thread_system_return(VOID);

tx_thread.h:288

VOID _tx_thread_system_suspend(TX_THREAD *thread_ptr);

tx_thread.h:289

VOID _tx_thread_system_ni_suspend(TX_THREAD *thread_ptr, ULONG wait_option);

tx_thread.h:290

VOID _tx_thread_time_slice(VOID);

tx_thread.h:291

VOID _tx_thread_timeout(ULONG timeout_input);

tx_thread.h:292

THREAD_DECLARE VOID * _tx_thread_system_stack_ptr;

tx_thread.h:308

THREAD_DECLARE VOID (*_tx_thread_mutex_release)(TX_THREAD *thread_ptr);

tx_thread.h:405

UINT _tx_thread_create(TX_THREAD *thread_ptr, CHAR *name_ptr, VOID (*entry_function)(ULONG id), ULONG entry_input,

tx_thread_create.c:93

VOID *stack_start, ULONG stack_size, UINT priority, UINT preempt_threshold,

tx_thread_create.c:94

UINT _tx_thread_entry_exit_notify(TX_THREAD *thread_ptr, VOID (*thread_entry_exit_notify)(TX_THREAD *notify_thread_ptr, UINT id))

tx_thread_entry_exit_notify.c:77

TX_THREAD *_tx_thread_identify(VOID)

tx_thread_identify.c:76

VOID * _tx_thread_system_stack_ptr;

tx_thread_initialize.c:42

VOID (*_tx_thread_mutex_release)(TX_THREAD *thread_ptr);

tx_thread_initialize.c:139

VOID _tx_thread_initialize(VOID)

tx_thread_initialize.c:321

VOID _tx_thread_relinquish(VOID)

tx_thread_relinquish.c:78

VOID _tx_thread_shell_entry(VOID)

tx_thread_shell_entry.c:76

VOID (*entry_exit_notify)(TX_THREAD *notify_thread_ptr, UINT type);

tx_thread_shell_entry.c:83

VOID _tx_thread_stack_analyze(TX_THREAD *thread_ptr)

tx_thread_stack_analyze.c:73

UINT _tx_thread_stack_error_notify(VOID (*stack_error_handler)(TX_THREAD *thread_ptr))

tx_thread_stack_error_notify.c:86

VOID _tx_thread_system_preempt_check(VOID)

tx_thread_system_preempt_check.c:73

VOID _tx_thread_system_resume(TX_THREAD *thread_ptr)

tx_thread_system_resume.c:81

VOID _tx_thread_system_suspend(TX_THREAD *thread_ptr)

tx_thread_system_suspend.c:83

VOID (*suspend_cleanup)(struct TX_THREAD_STRUCT *suspend_thread_ptr, ULONG suspension_sequence);

tx_thread_terminate.c:85

VOID (*entry_exit_notify)(TX_THREAD *notify_thread_ptr, UINT id);

tx_thread_terminate.c:87

VOID _tx_thread_time_slice(VOID)

tx_thread_time_slice.c:79

VOID _tx_thread_timeout(ULONG timeout_input)

tx_thread_timeout.c:79

VOID (*suspend_cleanup)(struct TX_THREAD_STRUCT *suspend_thread_ptr, ULONG suspension_sequence);

tx_thread_timeout.c:85

VOID (*suspend_cleanup)(struct TX_THREAD_STRUCT *suspend_thread_ptr, ULONG suspension_sequence);

tx_thread_wait_abort.c:81

ULONG _tx_time_get(VOID)

tx_time_get.c:75

VOID _tx_time_set(ULONG new_time)

tx_time_set.c:73

VOID _tx_timer_expiration_process(VOID);

tx_timer.h:62

VOID _tx_timer_initialize(VOID);

tx_timer.h:63

VOID _tx_timer_system_activate(TX_TIMER_INTERNAL *timer_ptr);

tx_timer.h:64

VOID _tx_timer_system_deactivate(TX_TIMER_INTERNAL *timer_ptr);

tx_timer.h:65

VOID _tx_timer_thread_entry(ULONG timer_thread_input);

tx_timer.h:66

TIMER_DECLARE VOID *_tx_timer_stack_start;

tx_timer.h:149

VOID (*expiration_function)(ULONG id), ULONG expiration_input,

tx_timer_create.c:79

VOID _tx_timer_expiration_process(VOID)

tx_timer_expiration_process.c:82

VOID *_tx_timer_stack_start;

tx_timer_initialize.c:100

VOID _tx_timer_initialize(VOID)

tx_timer_initialize.c:205

_tx_timer_stack_start = (VOID *) &_tx_timer_thread_stack_area[0];

tx_timer_initialize.c:246

VOID _tx_timer_system_activate(TX_TIMER_INTERNAL *timer_ptr)

tx_timer_system_activate.c:79

VOID _tx_timer_system_deactivate(TX_TIMER_INTERNAL *timer_ptr)

tx_timer_system_deactivate.c:74

VOID _tx_timer_thread_entry(ULONG timer_thread_input)

tx_timer_thread_entry.c:77

VOID (*timeout_function)(ULONG id);

tx_timer_thread_entry.c:87

VOID _tx_trace_initialize(VOID);

tx_trace.h:523

VOID _tx_trace_object_register(UCHAR object_type, VOID *object_ptr, CHAR *object_name, ULONG parameter_1, ULONG parameter_2);

tx_trace.h:524

VOID _tx_trace_object_unregister(VOID *object_ptr);

tx_trace.h:525

UINT _tx_trace_buffer_full_notify(VOID (*full_buffer_callback)(VOID *buffer))

tx_trace_buffer_full_notify.c:77

UINT _tx_trace_disable(VOID)

tx_trace_disable.c:71

UINT _tx_trace_enable(VOID *trace_buffer_start, ULONG trace_buffer_size, ULONG registry_entries)

tx_trace_enable.c:86

VOID _tx_trace_initialize(VOID)

tx_trace_initialize.c:138

VOID _tx_trace_isr_enter_insert(ULONG isr_id)

tx_trace_isr_enter_insert.c:75

VOID _tx_trace_isr_exit_insert(ULONG isr_id)

tx_trace_isr_exit_insert.c:75

VOID _tx_trace_object_register(UCHAR object_type, VOID *object_ptr, CHAR *object_name, ULONG parameter_1, ULONG parameter_2)

tx_trace_object_register.c:77

VOID _tx_trace_object_unregister(VOID *object_ptr)

tx_trace_object_unregister.c:72

UINT _txe_block_allocate(TX_BLOCK_POOL *pool_ptr, VOID **block_ptr, ULONG wait_option)

txe_block_allocate.c:80

VOID *pool_start, ULONG pool_size, UINT pool_control_block_size)

txe_block_pool_create.c:86

UINT _txe_block_release(VOID *block_ptr)

txe_block_release.c:72

UINT _txe_byte_allocate(TX_BYTE_POOL *pool_ptr, VOID **memory_ptr,

txe_byte_allocate.c:83

UINT _txe_byte_pool_create(TX_BYTE_POOL *pool_ptr, CHAR *name_ptr, VOID *pool_start, ULONG pool_size, UINT pool_control_block_size)

txe_byte_pool_create.c:84

UINT _txe_byte_release(VOID *memory_ptr)

txe_byte_release.c:76

UINT _txe_event_flags_set_notify(TX_EVENT_FLAGS_GROUP *group_ptr, VOID (*events_set_notify)(TX_EVENT_FLAGS_GROUP *notify_group_ptr))

txe_event_flags_set_notify.c:75

VOID *queue_start, ULONG queue_size, UINT queue_control_block_size)

txe_queue_create.c:84

UINT _txe_queue_front_send(TX_QUEUE *queue_ptr, VOID *source_ptr, ULONG wait_option)

txe_queue_front_send.c:78

UINT _txe_queue_receive(TX_QUEUE *queue_ptr, VOID *destination_ptr, ULONG wait_option)

txe_queue_receive.c:80

UINT _txe_queue_send(TX_QUEUE *queue_ptr, VOID *source_ptr, ULONG wait_option)

txe_queue_send.c:78

UINT _txe_queue_send_notify(TX_QUEUE *queue_ptr, VOID (*queue_send_notify)(TX_QUEUE *notify_queue_ptr))

txe_queue_send_notify.c:74

UINT _txe_semaphore_put_notify(TX_SEMAPHORE *semaphore_ptr, VOID (*semaphore_put_notify)(TX_SEMAPHORE *notify_semaphore_ptr))

txe_semaphore_put_notify.c:75

VOID (*entry_function)(ULONG id), ULONG entry_input,

txe_thread_create.c:91

VOID *stack_start, ULONG stack_size,

txe_thread_create.c:92

VOID *stack_end;

txe_thread_create.c:103

UINT _txe_thread_entry_exit_notify(TX_THREAD *thread_ptr, VOID (*thread_entry_exit_notify)(TX_THREAD *notify_thread_ptr, UINT type))

txe_thread_entry_exit_notify.c:75

VOID _txe_thread_relinquish(VOID)

txe_thread_relinquish.c:72

VOID (*expiration_function)(ULONG id), ULONG expiration_input,

txe_timer_create.c:86

VOID (*txm_module_callback_message_application_function)(VOID);

txm_module.h:411

VOID *txm_module_instance_code_allocation_ptr;

txm_module.h:433

VOID *txm_module_instance_code_start;

txm_module.h:435

VOID *txm_module_instance_code_end;

txm_module.h:436

VOID *txm_module_instance_data_allocation_ptr;

txm_module.h:438

VOID *txm_module_instance_data_start;

txm_module.h:440

VOID *txm_module_instance_data_end;

txm_module.h:441

VOID *txm_module_instance_module_data_base_address;

txm_module.h:442

VOID *txm_module_instance_start_stop_stack_start_address;

txm_module.h:445

VOID *txm_module_instance_start_stop_stack_end_address;

txm_module.h:446

VOID *txm_module_instance_callback_stack_start_address;

txm_module.h:447

VOID *txm_module_instance_callback_stack_end_address;

txm_module.h:448

VOID (*txm_module_instance_shell_entry_function)(TX_THREAD *, struct TXM_MODULE_INSTANCE_STRUCT *);

txm_module.h:450

VOID (*txm_module_instance_start_thread_entry)(ULONG);

txm_module.h:451

VOID (*txm_module_instance_stop_thread_entry)(ULONG);

txm_module.h:452

VOID (*txm_module_instance_callback_request_thread_entry)(ULONG);

txm_module.h:453

VOID *txm_module_thread_entry_info_data_base_address; /* Don't move this, referenced in stack build to setup module data base register. */

txm_module.h:495

VOID *txm_module_thread_entry_info_code_base_address;

txm_module.h:496

VOID (*txm_module_thread_entry_info_entry)(ULONG);

txm_module.h:497

VOID (*txm_module_thread_entry_info_exit_notify)(struct TX_THREAD_STRUCT *, UINT);

txm_module.h:499

VOID *txm_module_thread_entry_info_reserved;

txm_module.h:503

UINT _txm_module_manager_initialize(VOID *module_memory_start, ULONG module_memory_size);

txm_module.h:619

UINT _txm_module_manager_absolute_load(TXM_MODULE_INSTANCE *module_instance, CHAR *name, VOID *module_location);

txm_module.h:620

UINT _txm_module_manager_in_place_load(TXM_MODULE_INSTANCE *module_instance, CHAR *name, VOID *module_location);

txm_module.h:621

UINT _txm_module_manager_internal_load(TXM_MODULE_INSTANCE *module_instance, CHAR *name, VOID *module_location,

txm_module.h:622

ULONG code_size, VOID *code_allocation_ptr, ULONG code_allocation_size);

txm_module.h:623

UINT _txm_module_manager_object_allocate(VOID **object_ptr_ptr, ULONG object_size, TXM_MODULE_INSTANCE *module_instance);

txm_module.h:625

UINT _txm_module_manager_object_deallocate(VOID *object_ptr);

txm_module.h:626

UINT _txm_module_manager_object_pointer_get(UINT object_type, CHAR *name, VOID **object_ptr);

txm_module.h:627

UINT _txm_module_manager_object_pointer_get_extended(UINT object_type, CHAR *name, UINT name_length, VOID **object_ptr);

txm_module.h:628

UINT _txm_module_manager_object_pool_create(VOID *object_memory, ULONG object_memory_size);

txm_module.h:629

VOID _txm_module_manager_object_type_set(ULONG object_ptr, ULONG object_size, ULONG object_type);

txm_module.h:630

UINT _txm_module_manager_memory_load(TXM_MODULE_INSTANCE *module_instance, CHAR *module_name, VOID *module_location);

txm_module.h:631

UINT _txm_module_manager_thread_create(TX_THREAD *thread_ptr, CHAR *name, VOID (*shell_function)(TX_THREAD *, TXM_MODULE_INSTANCE *),

txm_module.h:635

VOID (*entry_function)(ULONG), ULONG entry_input,

txm_module.h:636

VOID *stack_start, ULONG stack_size, UINT priority, UINT preempt_threshold,

txm_module.h:637

VOID _txm_module_manager_name_build(CHAR *module_name, CHAR *thread_name, CHAR *combined_name);

txm_module.h:640

VOID _txm_module_manager_thread_stack_build(TX_THREAD *thread_ptr, VOID (*shell_function)(TX_THREAD *, TXM_MODULE_INSTANCE *));

txm_module.h:641

UINT _txm_module_manager_external_memory_enable(TXM_MODULE_INSTANCE *module_instance, VOID *start_address, ULONG length, UINT attributes);

txm_module.h:645

VOID _txm_module_manager_callback_request(TX_QUEUE *module_callback_queue, TXM_MODULE_CALLBACK_MESSAGE *callback_request);

txm_module.h:674

VOID _txm_module_manager_event_flags_notify_trampoline(TX_EVENT_FLAGS_GROUP *group_ptr);

txm_module.h:675

VOID _txm_module_manager_queue_notify_trampoline(TX_QUEUE *queue_ptr);

txm_module.h:676

VOID _txm_module_manager_semaphore_notify_trampoline(TX_SEMAPHORE *semaphore_ptr);

txm_module.h:677

VOID _txm_module_manager_thread_notify_trampoline(TX_THREAD *thread_ptr, UINT type);

txm_module.h:678

VOID _txm_module_manager_timer_notify_trampoline(ULONG id);

txm_module.h:679

UINT _txm_module_manager_absolute_load(TXM_MODULE_INSTANCE *module_instance, CHAR *module_name, VOID *module_location)

txm_module_manager_absolute_load.c:77

status = _tx_byte_allocate(&_txm_module_manager_byte_pool, (VOID **) &memory_ptr, data_allocation_size, TX_NO_WAIT);

txm_module_manager_absolute_load.c:270

module_instance -> txm_module_instance_data_allocation_ptr = (VOID *) memory_ptr;

txm_module_manager_absolute_load.c:300

module_instance -> txm_module_instance_data_start = (VOID *) (((CHAR *) module_preamble->txm_module_preamble_code_size) + sizeof(TXM_MODULE_PREAMBLE));

txm_module_manager_absolute_load.c:315

module_instance -> txm_module_instance_data_end = (VOID *) (((CHAR *) module_instance -> txm_module_instance_data_start) + module_preamble->txm_module_preamble_data_size);

txm_module_manager_absolute_load.c:316

module_instance -> txm_module_instance_code_allocation_ptr = (VOID *) NULL;

txm_module_manager_absolute_load.c:324

module_instance -> txm_module_instance_code_start = (VOID *) module_location;

txm_module_manager_absolute_load.c:330

module_instance -> txm_module_instance_code_end = (VOID *) (((CHAR *) module_location) + (code_size - 1));

txm_module_manager_absolute_load.c:331

module_instance -> txm_module_instance_start_stop_stack_start_address = (VOID *) (memory_ptr);

txm_module_manager_absolute_load.c:349

module_instance -> txm_module_instance_start_stop_stack_end_address = (VOID *) (memory_ptr + (start_stop_stack_size - 1));

txm_module_manager_absolute_load.c:351

module_instance -> txm_module_instance_callback_stack_start_address = (VOID *) (memory_ptr);

txm_module_manager_absolute_load.c:360

module_instance -> txm_module_instance_callback_stack_end_address = (VOID *) (memory_ptr + (callback_stack_size - 1));

txm_module_manager_absolute_load.c:362

module_instance -> txm_module_instance_module_data_base_address = (VOID *) (memory_ptr);

txm_module_manager_absolute_load.c:371

module_instance -> txm_module_instance_shell_entry_function = (VOID (*)(TX_THREAD *, TXM_MODULE_INSTANCE *)) ((VOID *) module_preamble -> txm_module_preamble_shell_entry_function);

txm_module_manager_absolute_load.c:380

module_instance -> txm_module_instance_start_thread_entry = (VOID (*)(ULONG)) ((VOID *) module_preamble -> txm_module_preamble_start_function);

txm_module_manager_absolute_load.c:381

module_instance -> txm_module_instance_callback_request_thread_entry = (VOID (*)(ULONG)) ((VOID *) module_preamble -> txm_module_preamble_callback_function);

txm_module_manager_absolute_load.c:382

module_instance -> txm_module_instance_stop_thread_entry = (VOID (*)(ULONG)) ((VOID *) module_preamble -> txm_module_preamble_stop_function);

txm_module_manager_absolute_load.c:393

VOID _txm_module_manager_alignment_adjust(TXM_MODULE_PREAMBLE *module_preamble,

txm_module_manager_alignment_adjust.c:134

VOID _txm_module_manager_callback_request(TX_QUEUE *module_callback_queue, TXM_MODULE_CALLBACK_MESSAGE *callback_message)

txm_module_manager_callback_request.c:70

status = _tx_queue_send(module_callback_queue, (VOID *) callback_message, TX_NO_WAIT);

txm_module_manager_callback_request.c:150

if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(VOID *)))

txm_module_manager_dispatch.h:39

(VOID **) param_1,

txm_module_manager_dispatch.h:45

(VOID *) extra_parameters[1],

txm_module_manager_dispatch.h:85

return_value = _txm_module_manager_object_deallocate((VOID *) param_0);

txm_module_manager_dispatch.h:115

(VOID *) param_0

txm_module_manager_dispatch.h:318

if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(VOID *)))

txm_module_manager_dispatch.h:341

(VOID **) param_1,

txm_module_manager_dispatch.h:350

(VOID *) extra_parameters[0],

txm_module_manager_dispatch.h:389

return_value = _txm_module_manager_object_deallocate((VOID *) param_0);

txm_module_manager_dispatch.h:419

(VOID *) param_0

txm_module_manager_dispatch.h:652

return_value = _txm_module_manager_object_deallocate((VOID *) param_0);

txm_module_manager_dispatch.h:709

VOID (*events_set_notify)(TX_EVENT_FLAGS_GROUP *);

txm_module_manager_dispatch.h:922

events_set_notify = (VOID (*)(TX_EVENT_FLAGS_GROUP *)) TX_NULL;

txm_module_manager_dispatch.h:939

event_flags_ptr -> tx_event_flags_group_module_instance = (VOID *) module_instance;

txm_module_manager_dispatch.h:945

event_flags_ptr -> tx_event_flags_group_set_module_notify = (VOID (*)(TX_EVENT_FLAGS_GROUP *)) param_1;

txm_module_manager_dispatch.h:946

(VOID (*)(TX_EVENT_FLAGS_GROUP *)) events_set_notify

txm_module_manager_dispatch.h:952

return_value = _txm_module_manager_object_deallocate((VOID *) param_0);

txm_module_manager_dispatch.h:1014

(VOID *) extra_parameters[1],

txm_module_manager_dispatch.h:1281

return_value = _txm_module_manager_object_deallocate((VOID *) param_0);

txm_module_manager_dispatch.h:1311

(VOID *) param_1,

txm_module_manager_dispatch.h:1364

(VOID *) param_1,

txm_module_manager_dispatch.h:1578

(VOID *) param_1,

txm_module_manager_dispatch.h:1610

VOID (*queue_send_notify)(TX_QUEUE *);

txm_module_manager_dispatch.h:1627

queue_send_notify = (VOID (*)(TX_QUEUE *)) TX_NULL;

txm_module_manager_dispatch.h:1644

queue_ptr -> tx_queue_module_instance = (VOID *) module_instance;

txm_module_manager_dispatch.h:1650

queue_ptr -> tx_queue_send_module_notify = (VOID (*)(TX_QUEUE *)) param_1;

txm_module_manager_dispatch.h:1651

(VOID (*)(TX_QUEUE *notify_queue_ptr)) queue_send_notify

txm_module_manager_dispatch.h:1657

return_value = _txm_module_manager_object_deallocate((VOID *) param_0);

txm_module_manager_dispatch.h:1743

VOID (*semaphore_put_notify)(TX_SEMAPHORE *);

txm_module_manager_dispatch.h:1962

semaphore_put_notify = (VOID (*)(TX_SEMAPHORE *)) TX_NULL;

txm_module_manager_dispatch.h:1979

semaphore_ptr -> tx_semaphore_module_instance = (VOID *) module_instance;

txm_module_manager_dispatch.h:1985

semaphore_ptr -> tx_semaphore_put_module_notify = (VOID (*)(TX_SEMAPHORE *)) param_1;

txm_module_manager_dispatch.h:1986

(VOID (*)(TX_SEMAPHORE *notify_semaphore_ptr)) semaphore_put_notify

txm_module_manager_dispatch.h:1992

(VOID (*)(ULONG entry_input)) extra_parameters[0],

txm_module_manager_dispatch.h:2042

(VOID *) extra_parameters[2],

txm_module_manager_dispatch.h:2044

return_value = _txm_module_manager_object_deallocate((VOID *) param_0);

txm_module_manager_dispatch.h:2079

VOID (*thread_entry_exit_notify)(TX_THREAD *, UINT);

txm_module_manager_dispatch.h:2096

thread_entry_exit_notify = (VOID (*)(TX_THREAD *, UINT)) TX_NULL;

txm_module_manager_dispatch.h:2117

thread_entry_info_ptr -> txm_module_thread_entry_info_exit_notify = (VOID (*)(TX_THREAD *, UINT)) param_1;

txm_module_manager_dispatch.h:2124

(VOID (*)(TX_THREAD *notify_thread_ptr, UINT type)) thread_entry_exit_notify

txm_module_manager_dispatch.h:2130

(VOID (*)(TX_THREAD *thread_ptr)) param_0

txm_module_manager_dispatch.h:2523

VOID (*expiration_function)(ULONG);

txm_module_manager_dispatch.h:2771

expiration_function = (VOID (*)(ULONG)) TX_NULL;

txm_module_manager_dispatch.h:2790

(VOID (*)(ULONG)) expiration_function,

txm_module_manager_dispatch.h:2802

timer_ptr -> tx_timer_module_instance = (VOID *) module_instance;

txm_module_manager_dispatch.h:2820

timer_ptr -> tx_timer_module_expiration_function = (VOID (*)(ULONG)) extra_parameters[0];

txm_module_manager_dispatch.h:2821

return_value = _txm_module_manager_object_deallocate((VOID *) param_0);

txm_module_manager_dispatch.h:2872

(VOID (*)(VOID *buffer)) param_0

txm_module_manager_dispatch.h:3033

(VOID *) param_0,

txm_module_manager_dispatch.h:3069

if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_0, sizeof(VOID *)))

txm_module_manager_dispatch.h:3204

(VOID **) param_0,

txm_module_manager_dispatch.h:3209

(VOID *) param_0

txm_module_manager_dispatch.h:3262

if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_2, sizeof(VOID *)))

txm_module_manager_dispatch.h:3284

(VOID **) param_2

txm_module_manager_dispatch.h:3291

if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[1], sizeof(VOID *)))

txm_module_manager_dispatch.h:3317

(VOID **) extra_parameters[1]

txm_module_manager_dispatch.h:3325

VOID _txm_module_manager_event_flags_notify_trampoline(TX_EVENT_FLAGS_GROUP *group_ptr)

txm_module_manager_event_flags_notify_trampoline.c:71

callback_message.txm_module_callback_message_application_function = (VOID (*)(VOID)) group_ptr -> tx_event_flags_group_set_module_notify;

txm_module_manager_event_flags_notify_trampoline.c:102

VOID *start_address,

txm_module_manager_external_memory_enable.c:77

UINT _txm_module_manager_in_place_load(TXM_MODULE_INSTANCE *module_instance, CHAR *module_name, VOID *module_location)

txm_module_manager_in_place_load.c:76

UINT _txm_module_manager_initialize(VOID *module_memory_start, ULONG module_memory_size)

txm_module_manager_initialize.c:140

UINT _txm_module_manager_internal_load(TXM_MODULE_INSTANCE *module_instance, CHAR *module_name, VOID *module_location,

txm_module_manager_internal_load.c:79

ULONG code_size, VOID *code_allocation_ptr, ULONG code_allocation_size)

txm_module_manager_internal_load.c:80

status = _tx_byte_allocate(&_txm_module_manager_byte_pool, (VOID **) &memory_ptr, data_allocation_size, TX_NO_WAIT);

txm_module_manager_internal_load.c:260

module_instance -> txm_module_instance_data_allocation_ptr = (VOID *) memory_ptr;

txm_module_manager_internal_load.c:290

module_instance -> txm_module_instance_data_start = (VOID *) memory_ptr;

txm_module_manager_internal_load.c:299

module_instance -> txm_module_instance_data_end = (VOID *) (memory_ptr + (data_size - 1));

txm_module_manager_internal_load.c:302

module_instance -> txm_module_instance_code_allocation_ptr = (VOID *) code_allocation_ptr;

txm_module_manager_internal_load.c:309

module_instance -> txm_module_instance_code_start = (VOID *) module_location;

txm_module_manager_internal_load.c:315

module_instance -> txm_module_instance_code_end = (VOID *) (((CHAR *) module_location) + (code_size - 1));

txm_module_manager_internal_load.c:316

module_instance -> txm_module_instance_start_stop_stack_start_address = (VOID *) (memory_ptr);

txm_module_manager_internal_load.c:334

module_instance -> txm_module_instance_start_stop_stack_end_address = (VOID *) (memory_ptr + (start_stop_stack_size - 1));

txm_module_manager_internal_load.c:336

module_instance -> txm_module_instance_callback_stack_start_address = (VOID *) (memory_ptr);

txm_module_manager_internal_load.c:345

module_instance -> txm_module_instance_callback_stack_end_address = (VOID *) (memory_ptr + (callback_stack_size - 1));

txm_module_manager_internal_load.c:347

module_instance -> txm_module_instance_module_data_base_address = (VOID *) (memory_ptr);

txm_module_manager_internal_load.c:356

module_instance -> txm_module_instance_shell_entry_function = (VOID (*)(TX_THREAD *, TXM_MODULE_INSTANCE *)) (((CHAR *) module_instance -> txm_module_instance_code_start) +

txm_module_manager_internal_load.c:363

module_instance -> txm_module_instance_start_thread_entry = (VOID (*)(ULONG)) (((CHAR *) module_instance -> txm_module_instance_code_start) +

txm_module_manager_internal_load.c:366

module_instance -> txm_module_instance_callback_request_thread_entry = (VOID (*)(ULONG)) (((CHAR *) module_instance -> txm_module_instance_code_start) +

txm_module_manager_internal_load.c:369

module_instance -> txm_module_instance_stop_thread_entry = (VOID (*)(ULONG)) (((CHAR *) module_instance -> txm_module_instance_code_start) +

txm_module_manager_internal_load.c:377

VOID (*_txm_module_manager_fault_notify)(TX_THREAD *, TXM_MODULE_INSTANCE *);

txm_module_manager_memory_fault_handler.c:33

VOID _txm_module_manager_memory_fault_handler(VOID)

txm_module_manager_memory_fault_handler.c:82

extern VOID (*_txm_module_manager_fault_notify)(TX_THREAD *, TXM_MODULE_INSTANCE *);

txm_module_manager_memory_fault_notify.c:33

UINT _txm_module_manager_memory_fault_notify(VOID (*notify_function)(TX_THREAD *, TXM_MODULE_INSTANCE *))

txm_module_manager_memory_fault_notify.c:77

UINT _txm_module_manager_memory_load(TXM_MODULE_INSTANCE *module_instance, CHAR *module_name, VOID *module_location)

txm_module_manager_memory_load.c:77

status = _tx_byte_allocate(&_txm_module_manager_byte_pool, (VOID **) &code_memory_ptr, code_allocation_size, TX_NO_WAIT);

txm_module_manager_memory_load.c:118

status = _txm_module_manager_internal_load(module_instance, module_name, (VOID *) code_start,

txm_module_manager_memory_load.c:148

VOID _txm_module_manager_mm_register_setup(TXM_MODULE_INSTANCE *module_instance)

txm_module_manager_mm_register_setup.c:299

UINT _txm_module_manager_object_allocate(VOID **object_ptr_ptr, ULONG object_size, TXM_MODULE_INSTANCE *module_instance)

txm_module_manager_object_allocate.c:72

if (object_ptr_ptr == (VOID **) TX_NULL)

txm_module_manager_object_allocate.c:80

*((VOID **) object_ptr_ptr) = TX_NULL;

txm_module_manager_object_allocate.c:88

return_value = (ULONG) _txe_byte_allocate(&_txm_module_manager_object_pool, (VOID **) &object_ptr,

txm_module_manager_object_allocate.c:101

*((VOID **) object_ptr_ptr) = object_ptr;

txm_module_manager_object_allocate.c:142

UINT _txm_module_manager_object_deallocate(VOID *object_ptr)

txm_module_manager_object_deallocate.c:69

return_value = (ULONG) _txe_byte_release((VOID *) module_allocated_object_ptr);

txm_module_manager_object_deallocate.c:125

UINT _txm_module_manager_object_pointer_get(UINT object_type, CHAR *name, VOID **object_ptr)

txm_module_manager_object_pointer_get.c:82

UINT _txm_module_manager_object_pointer_get_extended(UINT object_type, CHAR *search_name, UINT search_name_length, VOID **object_ptr)

txm_module_manager_object_pointer_get_extended.c:99

*object_ptr = (VOID *) thread_ptr;

txm_module_manager_object_pointer_get_extended.c:159

*object_ptr = (VOID *) timer_ptr;

txm_module_manager_object_pointer_get_extended.c:190

*object_ptr = (VOID *) queue_ptr;

txm_module_manager_object_pointer_get_extended.c:221

*object_ptr = (VOID *) events_ptr;

txm_module_manager_object_pointer_get_extended.c:252

*object_ptr = (VOID *) semaphore_ptr;

txm_module_manager_object_pointer_get_extended.c:283

*object_ptr = (VOID *) mutex_ptr;

txm_module_manager_object_pointer_get_extended.c:314

*object_ptr = (VOID *) block_pool_ptr;

txm_module_manager_object_pointer_get_extended.c:362

*object_ptr = (VOID *) byte_pool_ptr;

txm_module_manager_object_pointer_get_extended.c:410

UINT _txm_module_manager_object_pool_create(VOID *object_memory, ULONG object_memory_size)

txm_module_manager_object_pool_create.c:70

VOID _txm_module_manager_queue_notify_trampoline(TX_QUEUE *queue_ptr)

txm_module_manager_queue_notify_trampoline.c:68

callback_message.txm_module_callback_message_application_function = (VOID (*)(VOID)) queue_ptr -> tx_queue_send_module_notify;

txm_module_manager_queue_notify_trampoline.c:99

VOID _txm_module_manager_semaphore_notify_trampoline(TX_SEMAPHORE *semaphore_ptr)

txm_module_manager_semaphore_notify_trampoline.c:69

callback_message.txm_module_callback_message_application_function = (VOID (*)(VOID)) semaphore_ptr -> tx_semaphore_put_module_notify;

txm_module_manager_semaphore_notify_trampoline.c:100

created_by_module = _txm_module_manager_created_object_check(module_instance, (VOID *) timer_ptr);

txm_module_manager_stop.c:342

created_by_module = _txm_module_manager_created_object_check(module_instance, (VOID *) queue_ptr);

txm_module_manager_stop.c:376

created_by_module = _txm_module_manager_created_object_check(module_instance, (VOID *) events_ptr);

txm_module_manager_stop.c:410

created_by_module = _txm_module_manager_created_object_check(module_instance, (VOID *) semaphore_ptr);

txm_module_manager_stop.c:444

created_by_module = _txm_module_manager_created_object_check(module_instance, (VOID *) mutex_ptr);

txm_module_manager_stop.c:466

created_by_module = _txm_module_manager_created_object_check(module_instance, (VOID *) block_pool_ptr);

txm_module_manager_stop.c:488

created_by_module = _txm_module_manager_created_object_check(module_instance, (VOID *) byte_pool_ptr);

txm_module_manager_stop.c:510

_tx_byte_release((VOID *) object_ptr);

txm_module_manager_stop.c:546

VOID (*shell_function)(TX_THREAD *, TXM_MODULE_INSTANCE *),

txm_module_manager_thread_create.c:97

VOID (*entry_function)(ULONG id), ULONG entry_input,

txm_module_manager_thread_create.c:98

VOID *stack_start, ULONG stack_size, UINT priority, UINT preempt_threshold,

txm_module_manager_thread_create.c:99

VOID *stack_end;

txm_module_manager_thread_create.c:119

stack_end = (VOID *) (((UCHAR *) ((VOID *) stack_start)) + (stack_size - 1));

txm_module_manager_thread_create.c:149

if ((((UCHAR *) ((VOID *) stack_start)) <= ((UCHAR *) ((VOID *) next_thread -> tx_thread_stack_end))) &&

txm_module_manager_thread_create.c:161

(((UCHAR *) ((VOID *) stack_end)) >= ((UCHAR *) ((VOID *) next_thread -> tx_thread_stack_start))))

txm_module_manager_thread_create.c:162

status = _txm_module_manager_object_allocate((VOID **) &(thread_ptr -> tx_thread_module_kernel_stack_start), TXM_MODULE_KERNEL_STACK_SIZE, module_instance);

txm_module_manager_thread_create.c:319

thread_ptr -> tx_thread_module_kernel_stack_end = (VOID *) (((ALIGN_TYPE)(thread_ptr -> tx_thread_module_kernel_stack_start) + TXM_MODULE_KERNEL_STACK_SIZE) & ~0x07);

txm_module_manager_thread_create.c:333

thread_ptr -> tx_thread_module_instance_ptr = (VOID *) module_instance;

txm_module_manager_thread_create.c:450

thread_ptr -> tx_thread_module_entry_info_ptr = (VOID *) thread_entry_info;

txm_module_manager_thread_create.c:451

thread_ptr -> tx_thread_stack_ptr = (VOID *) thread_entry_info;

txm_module_manager_thread_create.c:457

VOID _txm_module_manager_thread_notify_trampoline(TX_THREAD *thread_ptr, UINT type)

txm_module_manager_thread_notify_trampoline.c:70

callback_message.txm_module_callback_message_application_function = (VOID (*)(VOID)) thread_info -> txm_module_thread_entry_info_exit_notify;

txm_module_manager_thread_notify_trampoline.c:109

thread_ptr -> tx_thread_stack_ptr = (VOID *) thread_entry_info;

txm_module_manager_thread_reset.c:151

VOID _txm_module_manager_timer_notify_trampoline(ULONG id)

txm_module_manager_timer_notify_trampoline.c:69

callback_message.txm_module_callback_message_application_function = (VOID (*)(VOID)) timer_ptr -> tx_timer_module_expiration_function;

txm_module_manager_timer_notify_trampoline.c:110

UCHAR _txm_module_manager_created_object_check(TXM_MODULE_INSTANCE *module_instance, VOID *object_ptr)

txm_module_manager_util.c:143

VOID *txm_module_manager_memory_fault_info_code_location;

txm_module_port.h:230

#define TXM_MODULE_MANAGER_ADDITIONAL_PROTOTYPES \

txm_module_port.h:367

VOID _txm_module_manager_alignment_adjust(TXM_MODULE_PREAMBLE *module_preamble, ULONG *code_size, ULONG *code_alignment, ULONG *data_size, ULONG *data_alignment); \

txm_module_port.h:368

VOID _txm_module_manager_memory_fault_handler(VOID); \

txm_module_port.h:369

UINT _txm_module_manager_memory_fault_notify(VOID (*notify_function)(TX_THREAD *, TXM_MODULE_INSTANCE *)); \

txm_module_port.h:370

VOID macro

Syntax

Examples

References

Call Tree

Data Use

Class Tree

Override Tree

Implementations

Instances

Lifecycle