#include "tx_port.h"

Include dependency graph for tx_api.h:

Classes
struct	TX_TIMER_INTERNAL_STRUCT

struct	TX_TIMER_STRUCT

struct	TX_THREAD_SPECIFIC_STRUCT

struct	TX_THREAD_STRUCT

struct	TX_THREAD_ONCE_CONTROL

struct	TX_BLOCK_POOL_STRUCT

struct	TX_BYTE_POOL_STRUCT

struct	TX_EVENT_FLAGS_GROUP_STRUCT

struct	TX_MUTEX_STRUCT

struct	TX_QUEUE_STRUCT

struct	TX_SEMAPHORE_STRUCT

Macros
#define	__PRODUCT_THREADX__
	ThreadX Component. More...

#define	__THREADX_MAJOR_VERSION 5

#define	__THREADX_MINOR_VERSION 6

#define	TX_NO_WAIT 0

#define	TX_WAIT_FOREVER ((ULONG)0xFFFFFFFF)

#define	TX_AND 2

#define	TX_AND_CLEAR 3

#define	TX_OR 0

#define	TX_OR_CLEAR 1

#define	TX_1_ULONG 1

#define	TX_2_ULONG 2

#define	TX_4_ULONG 4

#define	TX_8_ULONG 8

#define	TX_16_ULONG 16

#define	TX_NO_TIME_SLICE 0

#define	TX_AUTO_START 1

#define	TX_DONT_START 0

#define	TX_AUTO_ACTIVATE 1

#define	TX_NO_ACTIVATE 0

#define	TX_TRUE 1

#define	TX_FALSE 0

#define	TX_NULL (void*)0

#define	TX_LOOP_FOREVER 1

#define	TX_INHERIT 1

#define	TX_NO_INHERIT 0

#define	TX_THREAD_ENTRY 0

#define	TX_THREAD_EXIT 1

#define	TX_STACK_FILL ((ULONG)0xEFEFEFEF)

#define	TX_READY 0

#define	TX_COMPLETED 1

#define	TX_TERMINATED 2

#define	TX_SUSPENDED 3

#define	TX_SLEEP 4

#define	TX_QUEUE_SUSP 5

#define	TX_SEMAPHORE_SUSP 6

#define	TX_EVENT_FLAG 7

#define	TX_BLOCK_MEMORY 8

#define	TX_BYTE_MEMORY 9

#define	TX_IO_DRIVER 10

#define	TX_FILE 11

#define	TX_TCP_IP 12

#define	TX_MUTEX_SUSP 13

#define	TX_SUCCESS 0x00

#define	TX_DELETED 0x01

#define	TX_NO_MEMORY 0x10

#define	TX_POOL_ERROR 0x02

#define	TX_PTR_ERROR 0x03

#define	TX_WAIT_ERROR 0x04

#define	TX_SIZE_ERROR 0x05

#define	TX_GROUP_ERROR 0x06

#define	TX_NO_EVENTS 0x07

#define	TX_OPTION_ERROR 0x08

#define	TX_QUEUE_ERROR 0x09

#define	TX_QUEUE_EMPTY 0x0A

#define	TX_QUEUE_FULL 0x0B

#define	TX_SEMAPHORE_ERROR 0x0C

#define	TX_NO_INSTANCE 0x0D

#define	TX_THREAD_ERROR 0x0E

#define	TX_PRIORITY_ERROR 0x0F

#define	TX_START_ERROR 0x10

#define	TX_DELETE_ERROR 0x11

#define	TX_RESUME_ERROR 0x12

#define	TX_CALLER_ERROR 0x13

#define	TX_SUSPEND_ERROR 0x14

#define	TX_TIMER_ERROR 0x15

#define	TX_TICK_ERROR 0x16

#define	TX_ACTIVATE_ERROR 0x17

#define	TX_THRESH_ERROR 0x18

#define	TX_SUSPEND_LIFTED 0x19

#define	TX_WAIT_ABORTED 0x1A

#define	TX_WAIT_ABORT_ERROR 0x1B

#define	TX_MUTEX_ERROR 0x1C

#define	TX_NOT_AVAILABLE 0x1D

#define	TX_NOT_OWNED 0x1E

#define	TX_INHERIT_ERROR 0x1F

#define	TX_NOT_DONE 0x20

#define	TX_CEILING_EXCEEDED 0x21

#define	TX_INVALID_CEILING 0x22

#define	TX_FEATURE_NOT_ENABLED 0xFF

#define	TX_MEMSET(a, b, c) (memset)(a, b, c)

#define	TX_TRACE_USER_EVENT_START 4096 /* I1, I2, I3, I4 are user defined */

#define	TX_TRACE_USER_EVENT_END 65535 /* I1, I2, I3, I4 are user defined */

#define	TX_TRACE_ALL_EVENTS 0x000007FF /* All ThreadX events */

#define	TX_TRACE_INTERNAL_EVENTS 0x00000001 /* ThreadX internal events */

#define	TX_TRACE_BLOCK_POOL_EVENTS 0x00000002 /* ThreadX Block Pool events */

#define	TX_TRACE_BYTE_POOL_EVENTS 0x00000004 /* ThreadX Byte Pool events */

#define	TX_TRACE_EVENT_FLAGS_EVENTS 0x00000008 /* ThreadX Event Flags events */

#define	TX_TRACE_INTERRUPT_CONTROL_EVENT 0x00000010 /* ThreadX Interrupt Control events */

#define	TX_TRACE_MUTEX_EVENTS 0x00000020 /* ThreadX Mutex events */

#define	TX_TRACE_QUEUE_EVENTS 0x00000040 /* ThreadX Queue events */

#define	TX_TRACE_SEMAPHORE_EVENTS 0x00000080 /* ThreadX Semaphore events */

#define	TX_TRACE_THREAD_EVENTS 0x00000100 /* ThreadX Thread events */

#define	TX_TRACE_TIME_EVENTS 0x00000200 /* ThreadX Time events */

#define	TX_TRACE_TIMER_EVENTS 0x00000400 /* ThreadX Timer events */

#define	TX_TRACE_USER_EVENTS 0x80000000 /* ThreadX User Events */

#define	TX_THREAD_ONCE_INIT_VALUE 0U

#define	TX_THREAD_ONCE_INIT

#define	tx_kernel_enter _tx_initialize_kernel_enter

#define	tx_block_allocate _txe_block_allocate

#define	tx_block_pool_create(p, n, b, s, l) _txe_block_pool_create(p, n, b, s, l, sizeof(TX_BLOCK_POOL))

#define	tx_block_pool_delete _txe_block_pool_delete

#define	tx_block_pool_info_get _txe_block_pool_info_get

#define	tx_block_pool_performance_info_get _tx_block_pool_performance_info_get

#define	tx_block_pool_performance_system_info_get _tx_block_pool_performance_system_info_get

#define	tx_block_pool_prioritize _txe_block_pool_prioritize

#define	tx_block_release _txe_block_release

#define	tx_byte_allocate _txe_byte_allocate

#define	tx_byte_pool_create(p, n, s, l) _txe_byte_pool_create(p, n, s, l, sizeof(TX_BYTE_POOL))

#define	tx_byte_pool_delete _txe_byte_pool_delete

#define	tx_byte_pool_info_get _txe_byte_pool_info_get

#define	tx_byte_pool_performance_info_get _tx_byte_pool_performance_info_get

#define	tx_byte_pool_performance_system_info_get _tx_byte_pool_performance_system_info_get

#define	tx_byte_pool_prioritize _txe_byte_pool_prioritize

#define	tx_byte_release _txe_byte_release

#define	tx_event_flags_create(g, n) _txe_event_flags_create(g, n, sizeof(TX_EVENT_FLAGS_GROUP))

#define	tx_event_flags_delete _txe_event_flags_delete

#define	tx_event_flags_get _txe_event_flags_get

#define	tx_event_flags_info_get _txe_event_flags_info_get

#define	tx_event_flags_performance_info_get _tx_event_flags_performance_info_get

#define	tx_event_flags_performance_system_info_get _tx_event_flags_performance_system_info_get

#define	tx_event_flags_set _txe_event_flags_set

#define	tx_event_flags_set_notify _txe_event_flags_set_notify

#define	tx_interrupt_control _tx_thread_interrupt_control

#define	tx_mutex_create(m, n, i) _txe_mutex_create(m, n, i, sizeof(TX_MUTEX))

#define	tx_mutex_delete _txe_mutex_delete

#define	tx_mutex_get _txe_mutex_get

#define	tx_mutex_info_get _txe_mutex_info_get

#define	tx_mutex_performance_info_get _tx_mutex_performance_info_get

#define	tx_mutex_performance_system_info_get _tx_mutex_performance_system_info_get

#define	tx_mutex_prioritize _txe_mutex_prioritize

#define	tx_mutex_put _txe_mutex_put

#define	tx_queue_create(q, n, m, s, l) _txe_queue_create(q, n, m, s, l, sizeof(TX_QUEUE))

#define	tx_queue_delete _txe_queue_delete

#define	tx_queue_flush _txe_queue_flush

#define	tx_queue_info_get _txe_queue_info_get

#define	tx_queue_performance_info_get _tx_queue_performance_info_get

#define	tx_queue_performance_system_info_get _tx_queue_performance_system_info_get

#define	tx_queue_receive _txe_queue_receive

#define	tx_queue_send _txe_queue_send

#define	tx_queue_send_notify _txe_queue_send_notify

#define	tx_queue_front_send _txe_queue_front_send

#define	tx_queue_prioritize _txe_queue_prioritize

#define	tx_semaphore_ceiling_put _txe_semaphore_ceiling_put

#define	tx_semaphore_create(s, n, i) _txe_semaphore_create(s, n, i, sizeof(TX_SEMAPHORE))

#define	tx_semaphore_delete _txe_semaphore_delete

#define	tx_semaphore_get _txe_semaphore_get

#define	tx_semaphore_info_get _txe_semaphore_info_get

#define	tx_semaphore_performance_info_get _tx_semaphore_performance_info_get

#define	tx_semaphore_performance_system_info_get _tx_semaphore_performance_system_info_get

#define	tx_semaphore_prioritize _txe_semaphore_prioritize

#define	tx_semaphore_put _txe_semaphore_put

#define	tx_semaphore_put_notify _txe_semaphore_put_notify

#define	tx_thread_create(t, n, e, i, s, l, p, r, c, a) _txe_thread_create(t, n, e, i, s, l, p, r, c, a, sizeof(TX_THREAD))

#define	tx_thread_delete _txe_thread_delete

#define	tx_thread_entry_exit_notify _txe_thread_entry_exit_notify

#define	tx_thread_identify _tx_thread_identify

#define	tx_thread_info_get _txe_thread_info_get

#define	tx_thread_performance_info_get _tx_thread_performance_info_get

#define	tx_thread_performance_system_info_get _tx_thread_performance_system_info_get

#define	tx_thread_preemption_change _txe_thread_preemption_change

#define	tx_thread_priority_change _txe_thread_priority_change

#define	tx_thread_relinquish _txe_thread_relinquish

#define	tx_thread_reset _txe_thread_reset

#define	tx_thread_resume _txe_thread_resume

#define	tx_thread_sleep _tx_thread_sleep

#define	tx_thread_stack_error_notify _tx_thread_stack_error_notify

#define	tx_thread_suspend _txe_thread_suspend

#define	tx_thread_terminate _txe_thread_terminate

#define	tx_thread_time_slice_change _txe_thread_time_slice_change

#define	tx_thread_wait_abort _txe_thread_wait_abort

#define	tx_thread_once _tx_thread_once

#define	tx_thread_getspecific _tx_thread_getspecific

#define	tx_thread_setspecific _tx_thread_setspecific

#define	tx_time_get _tx_time_get

#define	tx_time_set _tx_time_set

#define	tx_timer_activate _txe_timer_activate

#define	tx_timer_change _txe_timer_change

#define	tx_timer_create(t, n, e, i, c, r, a) _txe_timer_create(t, n, e, i, c, r, a, sizeof(TX_TIMER))

#define	tx_timer_deactivate _txe_timer_deactivate

#define	tx_timer_delete _txe_timer_delete

#define	tx_timer_info_get _txe_timer_info_get

#define	tx_timer_performance_info_get _tx_timer_performance_info_get

#define	tx_timer_performance_system_info_get _tx_timer_performance_system_info_get

#define	tx_trace_enable _tx_trace_enable

#define	tx_trace_event_filter _tx_trace_event_filter

#define	tx_trace_event_unfilter _tx_trace_event_unfilter

#define	tx_trace_disable _tx_trace_disable

#define	tx_trace_isr_enter_insert _tx_trace_isr_enter_insert

#define	tx_trace_isr_exit_insert _tx_trace_isr_exit_insert

#define	tx_trace_buffer_full_notify _tx_trace_buffer_full_notify

#define	tx_trace_user_event_insert _tx_trace_user_event_insert

#define	_tx_el_user_event_insert(a, b, c, d, e)

#define	TX_EL_INITIALIZE

#define	TX_EL_THREAD_REGISTER(a)

#define	TX_EL_THREAD_UNREGISTER(a)

#define	TX_EL_THREAD_STATUS_CHANGE_INSERT(a, b)

#define	TX_EL_BYTE_ALLOCATE_INSERT

#define	TX_EL_BYTE_POOL_CREATE_INSERT

#define	TX_EL_BYTE_POOL_DELETE_INSERT

#define	TX_EL_BYTE_RELEASE_INSERT

#define	TX_EL_BLOCK_ALLOCATE_INSERT

#define	TX_EL_BLOCK_POOL_CREATE_INSERT

#define	TX_EL_BLOCK_POOL_DELETE_INSERT

#define	TX_EL_BLOCK_RELEASE_INSERT

#define	TX_EL_EVENT_FLAGS_CREATE_INSERT

#define	TX_EL_EVENT_FLAGS_DELETE_INSERT

#define	TX_EL_EVENT_FLAGS_GET_INSERT

#define	TX_EL_EVENT_FLAGS_SET_INSERT

#define	TX_EL_INTERRUPT_CONTROL_INSERT

#define	TX_EL_QUEUE_CREATE_INSERT

#define	TX_EL_QUEUE_DELETE_INSERT

#define	TX_EL_QUEUE_FLUSH_INSERT

#define	TX_EL_QUEUE_RECEIVE_INSERT

#define	TX_EL_QUEUE_SEND_INSERT

#define	TX_EL_SEMAPHORE_CREATE_INSERT

#define	TX_EL_SEMAPHORE_DELETE_INSERT

#define	TX_EL_SEMAPHORE_GET_INSERT

#define	TX_EL_SEMAPHORE_PUT_INSERT

#define	TX_EL_THREAD_CREATE_INSERT

#define	TX_EL_THREAD_DELETE_INSERT

#define	TX_EL_THREAD_IDENTIFY_INSERT

#define	TX_EL_THREAD_PREEMPTION_CHANGE_INSERT

#define	TX_EL_THREAD_PRIORITY_CHANGE_INSERT

#define	TX_EL_THREAD_RELINQUISH_INSERT

#define	TX_EL_THREAD_RESUME_INSERT

#define	TX_EL_THREAD_SLEEP_INSERT

#define	TX_EL_THREAD_SUSPEND_INSERT

#define	TX_EL_THREAD_TERMINATE_INSERT

#define	TX_EL_THREAD_TIME_SLICE_CHANGE_INSERT

#define	TX_EL_TIME_GET_INSERT

#define	TX_EL_TIME_SET_INSERT

#define	TX_EL_TIMER_ACTIVATE_INSERT

#define	TX_EL_TIMER_CHANGE_INSERT

#define	TX_EL_TIMER_CREATE_INSERT

#define	TX_EL_TIMER_DEACTIVATE_INSERT

#define	TX_EL_TIMER_DELETE_INSERT

#define	TX_EL_BLOCK_POOL_INFO_GET_INSERT

#define	TX_EL_BLOCK_POOL_PRIORITIZE_INSERT

#define	TX_EL_BYTE_POOL_INFO_GET_INSERT

#define	TX_EL_BYTE_POOL_PRIORITIZE_INSERT

#define	TX_EL_EVENT_FLAGS_INFO_GET_INSERT

#define	TX_EL_MUTEX_CREATE_INSERT

#define	TX_EL_MUTEX_DELETE_INSERT

#define	TX_EL_MUTEX_GET_INSERT

#define	TX_EL_MUTEX_INFO_GET_INSERT

#define	TX_EL_MUTEX_PRIORITIZE_INSERT

#define	TX_EL_MUTEX_PUT_INSERT

#define	TX_EL_QUEUE_INFO_GET_INSERT

#define	TX_EL_QUEUE_FRONT_SEND_INSERT

#define	TX_EL_QUEUE_PRIORITIZE_INSERT

#define	TX_EL_SEMAPHORE_INFO_GET_INSERT

#define	TX_EL_SEMAPHORE_PRIORITIZE_INSERT

#define	TX_EL_THREAD_INFO_GET_INSERT

#define	TX_EL_THREAD_WAIT_ABORT_INSERT

#define	TX_EL_TIMER_INFO_GET_INSERT

#define	TX_EL_BLOCK_POOL_PERFORMANCE_INFO_GET_INSERT

#define	TX_EL_BLOCK_POOL_PERFORMANCE_SYSTEM_INFO_GET_INSERT

#define	TX_EL_BYTE_POOL_PERFORMANCE_INFO_GET_INSERT

#define	TX_EL_BYTE_POOL_PERFORMANCE_SYSTEM_INFO_GET_INSERT

#define	TX_EL_EVENT_FLAGS_PERFORMANCE_INFO_GET_INSERT

#define	TX_EL_EVENT_FLAGS_PERFORMANCE_SYSTEM_INFO_GET_INSERT

#define	TX_EL_EVENT_FLAGS_SET_NOTIFY_INSERT

#define	TX_EL_MUTEX_PERFORMANCE_INFO_GET_INSERT

#define	TX_EL_MUTEX_PERFORMANCE_SYSTEM_INFO_GET_INSERT

#define	TX_EL_QUEUE_PERFORMANCE_INFO_GET_INSERT

#define	TX_EL_QUEUE_PERFORMANCE_SYSTEM_INFO_GET_INSERT

#define	TX_EL_QUEUE_SEND_NOTIFY_INSERT

#define	TX_EL_SEMAPHORE_CEILING_PUT_INSERT

#define	TX_EL_SEMAPHORE_PERFORMANCE_INFO_GET_INSERT

#define	TX_EL_SEMAPHORE_PERFORMANCE_SYSTEM_INFO_GET_INSERT

#define	TX_EL_SEMAPHORE_PUT_NOTIFY_INSERT

#define	TX_EL_THREAD_ENTRY_EXIT_NOTIFY_INSERT

#define	TX_EL_THREAD_RESET_INSERT

#define	TX_EL_THREAD_PERFORMANCE_INFO_GET_INSERT

#define	TX_EL_THREAD_PERFORMANCE_SYSTEM_INFO_GET_INSERT

#define	TX_EL_THREAD_STACK_ERROR_NOTIFY_INSERT

#define	TX_EL_TIMER_PERFORMANCE_INFO_GET_INSERT

#define	TX_EL_TIMER_PERFORMANCE_SYSTEM_INFO_GET_INSERT

Typedefs
typedef struct TX_TIMER_INTERNAL_STRUCT	TX_TIMER_INTERNAL

typedef struct TX_TIMER_STRUCT	TX_TIMER

typedef struct TX_THREAD_SPECIFIC_STRUCT	TX_THREAD_SPECIFIC

typedef int	TX_THREAD_KEY

typedef struct TX_THREAD_STRUCT	TX_THREAD

typedef struct TX_BLOCK_POOL_STRUCT	TX_BLOCK_POOL

typedef struct TX_BYTE_POOL_STRUCT	TX_BYTE_POOL

typedef struct TX_EVENT_FLAGS_GROUP_STRUCT	TX_EVENT_FLAGS_GROUP

typedef struct TX_MUTEX_STRUCT	TX_MUTEX

typedef struct TX_QUEUE_STRUCT	TX_QUEUE

typedef struct TX_SEMAPHORE_STRUCT	TX_SEMAPHORE

Enumerations
enum	TX_THREAD_KEYS { TX_THREAD_SJLJ_KEY = 0, TX_THREAD_CXA_GLOBAL_KEY, TX_THREAD_MAX_KEY }

Functions
struct TX_THREAD_ONCE_CONTROL	__attribute__ ((aligned(sizeof(struct TX_THREAD_ONCE_CONTROL))))

VOID	tx_application_define (VOID *)

VOID	tx_kernel_enter (VOID)

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

UINT	_txe_block_pool_create (TX_BLOCK_POOL pool_ptr, const CHAR name_ptr, ULONG block_size, VOID *pool_start, ULONG pool_size, UINT pool_control_block_size)

UINT	tx_block_pool_delete (TX_BLOCK_POOL *pool_ptr)

UINT	tx_block_pool_info_get (TX_BLOCK_POOL pool_ptr, const CHAR name, ULONG available_blocks, ULONG total_blocks, TX_THREAD first_suspended, ULONG suspended_count, TX_BLOCK_POOL **next_pool)

UINT	tx_block_pool_performance_info_get (TX_BLOCK_POOL pool_ptr, ULONG allocates, ULONG releases, ULONG suspensions, ULONG *timeouts)

UINT	tx_block_pool_performance_system_info_get (ULONG allocates, ULONG releases, ULONG suspensions, ULONG timeouts)

UINT	tx_block_pool_prioritize (TX_BLOCK_POOL *pool_ptr)

UINT	tx_block_release (VOID *block_ptr)

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

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

UINT	tx_byte_pool_delete (TX_BYTE_POOL *pool_ptr)

UINT	tx_byte_pool_info_get (TX_BYTE_POOL pool_ptr, const CHAR name, ULONG available_bytes, ULONG fragments, TX_THREAD first_suspended, ULONG suspended_count, TX_BYTE_POOL **next_pool)

UINT	tx_byte_pool_performance_info_get (TX_BYTE_POOL pool_ptr, ULONG allocates, ULONG releases, ULONG fragments_searched, ULONG merges, ULONG splits, ULONG suspensions, ULONG timeouts)

UINT	tx_byte_pool_performance_system_info_get (ULONG allocates, ULONG releases, ULONG fragments_searched, ULONG merges, ULONG splits, ULONG suspensions, ULONG *timeouts)

UINT	tx_byte_pool_prioritize (TX_BYTE_POOL *pool_ptr)

UINT	tx_byte_release (VOID *memory_ptr)

UINT	_txe_event_flags_create (TX_EVENT_FLAGS_GROUP group_ptr, const CHAR name_ptr, UINT event_control_block_size)

UINT	tx_event_flags_delete (TX_EVENT_FLAGS_GROUP *group_ptr)

UINT	tx_event_flags_get (TX_EVENT_FLAGS_GROUP group_ptr, ULONG requested_flags, UINT get_option, ULONG actual_flags_ptr, ULONG wait_option)

UINT	tx_event_flags_info_get (TX_EVENT_FLAGS_GROUP group_ptr, const CHAR name, ULONG current_flags, TX_THREAD *first_suspended, ULONG suspended_count, TX_EVENT_FLAGS_GROUP **next_group)

UINT	tx_event_flags_performance_info_get (TX_EVENT_FLAGS_GROUP group_ptr, ULONG sets, ULONG gets, ULONG suspensions, ULONG *timeouts)

UINT	tx_event_flags_performance_system_info_get (ULONG sets, ULONG gets, ULONG suspensions, ULONG timeouts)

UINT	tx_event_flags_set (TX_EVENT_FLAGS_GROUP *group_ptr, ULONG flags_to_set, UINT set_option)

UINT	tx_event_flags_set_notify (TX_EVENT_FLAGS_GROUP group_ptr, VOID(events_set_notify)(TX_EVENT_FLAGS_GROUP *))

UINT	tx_interrupt_control (UINT new_posture)

UINT	_txe_mutex_create (TX_MUTEX mutex_ptr, const CHAR name_ptr, UINT inherit, UINT mutex_control_block_size)

UINT	tx_mutex_delete (TX_MUTEX *mutex_ptr)

UINT	tx_mutex_get (TX_MUTEX *mutex_ptr, ULONG wait_option)

UINT	tx_mutex_info_get (TX_MUTEX mutex_ptr, const CHAR name, ULONG count, TX_THREAD owner, TX_THREAD first_suspended, ULONG suspended_count, TX_MUTEX *next_mutex)

UINT	tx_mutex_performance_info_get (TX_MUTEX mutex_ptr, ULONG puts, ULONG gets, ULONG suspensions, ULONG timeouts, ULONG inversions, ULONG *inheritances)

UINT	tx_mutex_performance_system_info_get (ULONG puts, ULONG gets, ULONG suspensions, ULONG timeouts, ULONG inversions, ULONG inheritances)

UINT	tx_mutex_prioritize (TX_MUTEX *mutex_ptr)

UINT	tx_mutex_put (TX_MUTEX *mutex_ptr)

UINT	_txe_queue_create (TX_QUEUE queue_ptr, const CHAR name_ptr, UINT message_size, VOID *queue_start, ULONG queue_size, UINT queue_control_block_size)

UINT	tx_queue_delete (TX_QUEUE *queue_ptr)

UINT	tx_queue_flush (TX_QUEUE *queue_ptr)

UINT	tx_queue_info_get (TX_QUEUE queue_ptr, const CHAR name, ULONG enqueued, ULONG available_storage, TX_THREAD first_suspended, ULONG suspended_count, TX_QUEUE **next_queue)

UINT	tx_queue_performance_info_get (TX_QUEUE queue_ptr, ULONG messages_sent, ULONG messages_received, ULONG empty_suspensions, ULONG full_suspensions, ULONG full_errors, ULONG *timeouts)

UINT	tx_queue_performance_system_info_get (ULONG messages_sent, ULONG messages_received, ULONG empty_suspensions, ULONG full_suspensions, ULONG full_errors, ULONG timeouts)

UINT	tx_queue_receive (TX_QUEUE queue_ptr, VOID destination_ptr, ULONG wait_option)

UINT	tx_queue_send (TX_QUEUE queue_ptr, VOID source_ptr, ULONG wait_option)

UINT	tx_queue_send_notify (TX_QUEUE queue_ptr, VOID(queue_send_notify)(TX_QUEUE *))

UINT	tx_queue_front_send (TX_QUEUE queue_ptr, VOID source_ptr, ULONG wait_option)

UINT	tx_queue_prioritize (TX_QUEUE *queue_ptr)

UINT	tx_semaphore_ceiling_put (TX_SEMAPHORE *semaphore_ptr, ULONG ceiling)

UINT	_txe_semaphore_create (TX_SEMAPHORE semaphore_ptr, const CHAR name_ptr, ULONG initial_count, UINT semaphore_control_block_size)

UINT	tx_semaphore_delete (TX_SEMAPHORE *semaphore_ptr)

UINT	tx_semaphore_get (TX_SEMAPHORE *semaphore_ptr, ULONG wait_option)

UINT	tx_semaphore_info_get (TX_SEMAPHORE semaphore_ptr, const CHAR name, ULONG current_value, TX_THREAD *first_suspended, ULONG suspended_count, TX_SEMAPHORE **next_semaphore)

UINT	tx_semaphore_performance_info_get (TX_SEMAPHORE semaphore_ptr, ULONG puts, ULONG gets, ULONG suspensions, ULONG *timeouts)

UINT	tx_semaphore_performance_system_info_get (ULONG puts, ULONG gets, ULONG suspensions, ULONG timeouts)

UINT	tx_semaphore_prioritize (TX_SEMAPHORE *semaphore_ptr)

UINT	tx_semaphore_put (TX_SEMAPHORE *semaphore_ptr)

UINT	tx_semaphore_put_notify (TX_SEMAPHORE semaphore_ptr, VOID(semaphore_put_notify)(TX_SEMAPHORE *))

UINT	_txe_thread_create (TX_THREAD thread_ptr, const CHAR name_ptr, VOID(entry_function)(ULONG), ULONG entry_input, VOID stack_start, ULONG stack_size, UINT priority, UINT preempt_threshold, ULONG time_slice, UINT auto_start, UINT thread_control_block_size)

UINT	tx_thread_delete (TX_THREAD *thread_ptr)

UINT	tx_thread_entry_exit_notify (TX_THREAD thread_ptr, VOID(thread_entry_exit_notify)(TX_THREAD *, UINT))

TX_THREAD *	tx_thread_identify (VOID)

UINT	tx_thread_info_get (TX_THREAD thread_ptr, const CHAR name, UINT state, ULONG run_count, UINT priority, UINT preemption_threshold, ULONG time_slice, TX_THREAD next_thread, TX_THREAD next_suspended_thread)

UINT	tx_thread_performance_info_get (TX_THREAD thread_ptr, ULONG resumptions, ULONG suspensions, ULONG solicited_preemptions, ULONG interrupt_preemptions, ULONG priority_inversions, ULONG time_slices, ULONG relinquishes, ULONG timeouts, ULONG wait_aborts, TX_THREAD **last_preempted_by)

UINT	tx_thread_performance_system_info_get (ULONG resumptions, ULONG suspensions, ULONG solicited_preemptions, ULONG interrupt_preemptions, ULONG priority_inversions, ULONG time_slices, ULONG relinquishes, ULONG timeouts, ULONG wait_aborts, ULONG non_idle_returns, ULONG *idle_returns)

UINT	tx_thread_preemption_change (TX_THREAD thread_ptr, UINT new_threshold, UINT old_threshold)

UINT	tx_thread_priority_change (TX_THREAD thread_ptr, UINT new_priority, UINT old_priority)

VOID	tx_thread_relinquish (VOID)

UINT	tx_thread_reset (TX_THREAD *thread_ptr)

UINT	tx_thread_resume (TX_THREAD *thread_ptr)

UINT	tx_thread_sleep (ULONG timer_ticks)

UINT	tx_thread_stack_error_notify (VOID(stack_error_handler)(TX_THREAD ))

UINT	tx_thread_suspend (TX_THREAD *thread_ptr)

UINT	tx_thread_terminate (TX_THREAD *thread_ptr)

UINT	tx_thread_time_slice_change (TX_THREAD thread_ptr, ULONG new_time_slice, ULONG old_time_slice)

UINT	tx_thread_wait_abort (TX_THREAD *thread_ptr)

UINT	tx_thread_once (TX_THREAD_ONCE once_control, void(once_routine)(void))

VOID *	tx_thread_getspecific (TX_THREAD_KEY key)

VOID	tx_thread_setspecific (TX_THREAD_KEY key, void *data)

ULONG	tx_time_get (VOID)

VOID	tx_time_set (ULONG new_time)

UINT	tx_timer_activate (TX_TIMER *timer_ptr)

UINT	tx_timer_change (TX_TIMER *timer_ptr, ULONG initial_ticks, ULONG reschedule_ticks)

UINT	_txe_timer_create (TX_TIMER timer_ptr, const CHAR name_ptr, VOID(*expiration_function)(ULONG), ULONG expiration_input, ULONG initial_ticks, ULONG reschedule_ticks, UINT auto_activate, UINT timer_control_block_size)

UINT	tx_timer_deactivate (TX_TIMER *timer_ptr)

UINT	tx_timer_delete (TX_TIMER *timer_ptr)

UINT	tx_timer_info_get (TX_TIMER timer_ptr, const CHAR name, UINT active, ULONG remaining_ticks, ULONG reschedule_ticks, TX_TIMER **next_timer)

UINT	tx_timer_performance_info_get (TX_TIMER timer_ptr, ULONG activates, ULONG reactivates, ULONG deactivates, ULONG expirations, ULONG expiration_adjusts)

UINT	tx_timer_performance_system_info_get (ULONG activates, ULONG reactivates, ULONG deactivates, ULONG expirations, ULONG *expiration_adjusts)

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

UINT	tx_trace_event_filter (ULONG event_filter_bits)

UINT	tx_trace_event_unfilter (ULONG event_unfilter_bits)

UINT	tx_trace_disable (VOID)

VOID	tx_trace_isr_enter_insert (ULONG isr_id)

VOID	tx_trace_isr_exit_insert (ULONG isr_id)

UINT	tx_trace_buffer_full_notify (VOID(full_buffer_callback)(VOID ))

UINT	tx_trace_user_event_insert (ULONG event_id, ULONG info_field_1, ULONG info_field_2, ULONG info_field_3, ULONG info_field_4)

void	threadx_thread_destroy_extension (TX_THREAD *)

Variables
volatile int	once_value

Class Documentation

◆ TX_TIMER_STRUCT

struct TX_TIMER_STRUCT

Class Members
struct TX_TIMER_STRUCT *	tx_timer_created_next
struct TX_TIMER_STRUCT *	tx_timer_created_previous
ULONG	tx_timer_id
TX_TIMER_INTERNAL	tx_timer_internal
const CHAR *	tx_timer_name

◆ TX_THREAD_SPECIFIC_STRUCT

struct TX_THREAD_SPECIFIC_STRUCT

Class Members
void *	values[TX_THREAD_MAX_KEY]

◆ TX_THREAD_ONCE_CONTROL

struct TX_THREAD_ONCE_CONTROL

Class Members
volatile int	once_value

◆ TX_BLOCK_POOL_STRUCT

struct TX_BLOCK_POOL_STRUCT

Class Members
UINT	tx_block_pool_available
UCHAR *	tx_block_pool_available_list
UINT	tx_block_pool_block_size
struct TX_BLOCK_POOL_STRUCT *	tx_block_pool_created_next
struct TX_BLOCK_POOL_STRUCT *	tx_block_pool_created_previous
ULONG	tx_block_pool_id
const CHAR *	tx_block_pool_name
ULONG	tx_block_pool_size
UCHAR *	tx_block_pool_start
UINT	tx_block_pool_suspended_count
struct TX_THREAD_STRUCT *	tx_block_pool_suspension_list
UINT	tx_block_pool_total

◆ TX_BYTE_POOL_STRUCT

struct TX_BYTE_POOL_STRUCT

Class Members
ULONG	tx_byte_pool_available
struct TX_BYTE_POOL_STRUCT *	tx_byte_pool_created_next
struct TX_BYTE_POOL_STRUCT *	tx_byte_pool_created_previous
UINT	tx_byte_pool_fragments
ULONG	tx_byte_pool_id
UCHAR *	tx_byte_pool_list
const CHAR *	tx_byte_pool_name
struct TX_THREAD_STRUCT *	tx_byte_pool_owner
UCHAR *	tx_byte_pool_search
ULONG	tx_byte_pool_size
UCHAR *	tx_byte_pool_start
UINT	tx_byte_pool_suspended_count
struct TX_THREAD_STRUCT *	tx_byte_pool_suspension_list

◆ TX_MUTEX_STRUCT

struct TX_MUTEX_STRUCT

Class Members
struct TX_MUTEX_STRUCT *	tx_mutex_created_next
struct TX_MUTEX_STRUCT *	tx_mutex_created_previous
UINT	tx_mutex_highest_priority_waiting
ULONG	tx_mutex_id
UINT	tx_mutex_inherit
const CHAR *	tx_mutex_name
UINT	tx_mutex_original_priority
struct TX_MUTEX_STRUCT *	tx_mutex_owned_next
struct TX_MUTEX_STRUCT *	tx_mutex_owned_previous
TX_THREAD *	tx_mutex_owner
UINT	tx_mutex_ownership_count
UINT	tx_mutex_suspended_count
struct TX_THREAD_STRUCT *	tx_mutex_suspension_list

Macro Definition Documentation

◆ __PRODUCT_THREADX__

#define __PRODUCT_THREADX__

ThreadX Component.

Application Interface (API)

◆ __THREADX_MAJOR_VERSION

#define __THREADX_MAJOR_VERSION 5

◆ __THREADX_MINOR_VERSION

#define __THREADX_MINOR_VERSION 6

◆ _tx_el_user_event_insert

#define _tx_el_user_event_insert	(	a,
		b,
		c,
		d,
		e
	)

◆ TX_16_ULONG

#define TX_16_ULONG 16

◆ TX_1_ULONG

#define TX_1_ULONG 1

◆ TX_2_ULONG

#define TX_2_ULONG 2

◆ TX_4_ULONG

#define TX_4_ULONG 4

◆ TX_8_ULONG

#define TX_8_ULONG 8

◆ TX_ACTIVATE_ERROR

#define TX_ACTIVATE_ERROR 0x17

◆ TX_AND

#define TX_AND 2

◆ TX_AND_CLEAR

#define TX_AND_CLEAR 3

◆ TX_AUTO_ACTIVATE

#define TX_AUTO_ACTIVATE 1

◆ TX_AUTO_START

#define TX_AUTO_START 1

◆ tx_block_allocate

#define tx_block_allocate _txe_block_allocate

◆ TX_BLOCK_MEMORY

#define TX_BLOCK_MEMORY 8

◆ tx_block_pool_create

#define tx_block_pool_create	(	p,
		n,
		b,
		s,
		l
	)	_txe_block_pool_create(p, n, b, s, l, sizeof(TX_BLOCK_POOL))

◆ tx_block_pool_delete

#define tx_block_pool_delete _txe_block_pool_delete

◆ tx_block_pool_info_get

#define tx_block_pool_info_get _txe_block_pool_info_get

◆ tx_block_pool_performance_info_get

#define tx_block_pool_performance_info_get _tx_block_pool_performance_info_get

◆ tx_block_pool_performance_system_info_get

#define tx_block_pool_performance_system_info_get _tx_block_pool_performance_system_info_get

◆ tx_block_pool_prioritize

#define tx_block_pool_prioritize _txe_block_pool_prioritize

◆ tx_block_release

#define tx_block_release _txe_block_release

◆ tx_byte_allocate

#define tx_byte_allocate _txe_byte_allocate

◆ TX_BYTE_MEMORY

#define TX_BYTE_MEMORY 9

◆ tx_byte_pool_create

#define tx_byte_pool_create	(	p,
		n,
		s,
		l
	)	_txe_byte_pool_create(p, n, s, l, sizeof(TX_BYTE_POOL))

◆ tx_byte_pool_delete

#define tx_byte_pool_delete _txe_byte_pool_delete

◆ tx_byte_pool_info_get

#define tx_byte_pool_info_get _txe_byte_pool_info_get

◆ tx_byte_pool_performance_info_get

#define tx_byte_pool_performance_info_get _tx_byte_pool_performance_info_get

◆ tx_byte_pool_performance_system_info_get

#define tx_byte_pool_performance_system_info_get _tx_byte_pool_performance_system_info_get

◆ tx_byte_pool_prioritize

#define tx_byte_pool_prioritize _txe_byte_pool_prioritize

◆ tx_byte_release

#define tx_byte_release _txe_byte_release

◆ TX_CALLER_ERROR

#define TX_CALLER_ERROR 0x13

◆ TX_CEILING_EXCEEDED

#define TX_CEILING_EXCEEDED 0x21

◆ TX_COMPLETED

#define TX_COMPLETED 1

◆ TX_DELETE_ERROR

#define TX_DELETE_ERROR 0x11

◆ TX_DELETED

#define TX_DELETED 0x01

◆ TX_DONT_START

#define TX_DONT_START 0

◆ TX_EL_BLOCK_ALLOCATE_INSERT

#define TX_EL_BLOCK_ALLOCATE_INSERT

◆ TX_EL_BLOCK_POOL_CREATE_INSERT

#define TX_EL_BLOCK_POOL_CREATE_INSERT

◆ TX_EL_BLOCK_POOL_DELETE_INSERT

#define TX_EL_BLOCK_POOL_DELETE_INSERT

◆ TX_EL_BLOCK_POOL_INFO_GET_INSERT

#define TX_EL_BLOCK_POOL_INFO_GET_INSERT

◆ TX_EL_BLOCK_POOL_PERFORMANCE_INFO_GET_INSERT

#define TX_EL_BLOCK_POOL_PERFORMANCE_INFO_GET_INSERT

◆ TX_EL_BLOCK_POOL_PERFORMANCE_SYSTEM_INFO_GET_INSERT

#define TX_EL_BLOCK_POOL_PERFORMANCE_SYSTEM_INFO_GET_INSERT

◆ TX_EL_BLOCK_POOL_PRIORITIZE_INSERT

#define TX_EL_BLOCK_POOL_PRIORITIZE_INSERT

◆ TX_EL_BLOCK_RELEASE_INSERT

#define TX_EL_BLOCK_RELEASE_INSERT

◆ TX_EL_BYTE_ALLOCATE_INSERT

#define TX_EL_BYTE_ALLOCATE_INSERT

◆ TX_EL_BYTE_POOL_CREATE_INSERT

#define TX_EL_BYTE_POOL_CREATE_INSERT

◆ TX_EL_BYTE_POOL_DELETE_INSERT

#define TX_EL_BYTE_POOL_DELETE_INSERT

◆ TX_EL_BYTE_POOL_INFO_GET_INSERT

#define TX_EL_BYTE_POOL_INFO_GET_INSERT

◆ TX_EL_BYTE_POOL_PERFORMANCE_INFO_GET_INSERT

#define TX_EL_BYTE_POOL_PERFORMANCE_INFO_GET_INSERT

◆ TX_EL_BYTE_POOL_PERFORMANCE_SYSTEM_INFO_GET_INSERT

#define TX_EL_BYTE_POOL_PERFORMANCE_SYSTEM_INFO_GET_INSERT

◆ TX_EL_BYTE_POOL_PRIORITIZE_INSERT

#define TX_EL_BYTE_POOL_PRIORITIZE_INSERT

◆ TX_EL_BYTE_RELEASE_INSERT

#define TX_EL_BYTE_RELEASE_INSERT

◆ TX_EL_EVENT_FLAGS_CREATE_INSERT

#define TX_EL_EVENT_FLAGS_CREATE_INSERT

◆ TX_EL_EVENT_FLAGS_DELETE_INSERT

#define TX_EL_EVENT_FLAGS_DELETE_INSERT

◆ TX_EL_EVENT_FLAGS_GET_INSERT

#define TX_EL_EVENT_FLAGS_GET_INSERT

◆ TX_EL_EVENT_FLAGS_INFO_GET_INSERT

#define TX_EL_EVENT_FLAGS_INFO_GET_INSERT

◆ TX_EL_EVENT_FLAGS_PERFORMANCE_INFO_GET_INSERT

#define TX_EL_EVENT_FLAGS_PERFORMANCE_INFO_GET_INSERT

◆ TX_EL_EVENT_FLAGS_PERFORMANCE_SYSTEM_INFO_GET_INSERT

#define TX_EL_EVENT_FLAGS_PERFORMANCE_SYSTEM_INFO_GET_INSERT

◆ TX_EL_EVENT_FLAGS_SET_INSERT

#define TX_EL_EVENT_FLAGS_SET_INSERT

◆ TX_EL_EVENT_FLAGS_SET_NOTIFY_INSERT

#define TX_EL_EVENT_FLAGS_SET_NOTIFY_INSERT

◆ TX_EL_INITIALIZE

#define TX_EL_INITIALIZE

◆ TX_EL_INTERRUPT_CONTROL_INSERT

#define TX_EL_INTERRUPT_CONTROL_INSERT

◆ TX_EL_MUTEX_CREATE_INSERT

#define TX_EL_MUTEX_CREATE_INSERT

◆ TX_EL_MUTEX_DELETE_INSERT

#define TX_EL_MUTEX_DELETE_INSERT

◆ TX_EL_MUTEX_GET_INSERT

#define TX_EL_MUTEX_GET_INSERT

◆ TX_EL_MUTEX_INFO_GET_INSERT

#define TX_EL_MUTEX_INFO_GET_INSERT

◆ TX_EL_MUTEX_PERFORMANCE_INFO_GET_INSERT

#define TX_EL_MUTEX_PERFORMANCE_INFO_GET_INSERT

◆ TX_EL_MUTEX_PERFORMANCE_SYSTEM_INFO_GET_INSERT

#define TX_EL_MUTEX_PERFORMANCE_SYSTEM_INFO_GET_INSERT

◆ TX_EL_MUTEX_PRIORITIZE_INSERT

#define TX_EL_MUTEX_PRIORITIZE_INSERT

◆ TX_EL_MUTEX_PUT_INSERT

#define TX_EL_MUTEX_PUT_INSERT

◆ TX_EL_QUEUE_CREATE_INSERT

#define TX_EL_QUEUE_CREATE_INSERT

◆ TX_EL_QUEUE_DELETE_INSERT

#define TX_EL_QUEUE_DELETE_INSERT

◆ TX_EL_QUEUE_FLUSH_INSERT

#define TX_EL_QUEUE_FLUSH_INSERT

◆ TX_EL_QUEUE_FRONT_SEND_INSERT

#define TX_EL_QUEUE_FRONT_SEND_INSERT

◆ TX_EL_QUEUE_INFO_GET_INSERT

#define TX_EL_QUEUE_INFO_GET_INSERT

◆ TX_EL_QUEUE_PERFORMANCE_INFO_GET_INSERT

#define TX_EL_QUEUE_PERFORMANCE_INFO_GET_INSERT

◆ TX_EL_QUEUE_PERFORMANCE_SYSTEM_INFO_GET_INSERT

#define TX_EL_QUEUE_PERFORMANCE_SYSTEM_INFO_GET_INSERT

◆ TX_EL_QUEUE_PRIORITIZE_INSERT

#define TX_EL_QUEUE_PRIORITIZE_INSERT

◆ TX_EL_QUEUE_RECEIVE_INSERT

#define TX_EL_QUEUE_RECEIVE_INSERT

◆ TX_EL_QUEUE_SEND_INSERT

#define TX_EL_QUEUE_SEND_INSERT

◆ TX_EL_QUEUE_SEND_NOTIFY_INSERT

#define TX_EL_QUEUE_SEND_NOTIFY_INSERT

◆ TX_EL_SEMAPHORE_CEILING_PUT_INSERT

#define TX_EL_SEMAPHORE_CEILING_PUT_INSERT

◆ TX_EL_SEMAPHORE_CREATE_INSERT

#define TX_EL_SEMAPHORE_CREATE_INSERT

◆ TX_EL_SEMAPHORE_DELETE_INSERT

#define TX_EL_SEMAPHORE_DELETE_INSERT

◆ TX_EL_SEMAPHORE_GET_INSERT

#define TX_EL_SEMAPHORE_GET_INSERT

◆ TX_EL_SEMAPHORE_INFO_GET_INSERT

#define TX_EL_SEMAPHORE_INFO_GET_INSERT

◆ TX_EL_SEMAPHORE_PERFORMANCE_INFO_GET_INSERT

#define TX_EL_SEMAPHORE_PERFORMANCE_INFO_GET_INSERT

◆ TX_EL_SEMAPHORE_PERFORMANCE_SYSTEM_INFO_GET_INSERT

#define TX_EL_SEMAPHORE_PERFORMANCE_SYSTEM_INFO_GET_INSERT

◆ TX_EL_SEMAPHORE_PRIORITIZE_INSERT

#define TX_EL_SEMAPHORE_PRIORITIZE_INSERT

◆ TX_EL_SEMAPHORE_PUT_INSERT

#define TX_EL_SEMAPHORE_PUT_INSERT

◆ TX_EL_SEMAPHORE_PUT_NOTIFY_INSERT

#define TX_EL_SEMAPHORE_PUT_NOTIFY_INSERT

◆ TX_EL_THREAD_CREATE_INSERT

#define TX_EL_THREAD_CREATE_INSERT

◆ TX_EL_THREAD_DELETE_INSERT

#define TX_EL_THREAD_DELETE_INSERT

◆ TX_EL_THREAD_ENTRY_EXIT_NOTIFY_INSERT

#define TX_EL_THREAD_ENTRY_EXIT_NOTIFY_INSERT

◆ TX_EL_THREAD_IDENTIFY_INSERT

#define TX_EL_THREAD_IDENTIFY_INSERT

◆ TX_EL_THREAD_INFO_GET_INSERT

#define TX_EL_THREAD_INFO_GET_INSERT

◆ TX_EL_THREAD_PERFORMANCE_INFO_GET_INSERT

#define TX_EL_THREAD_PERFORMANCE_INFO_GET_INSERT

◆ TX_EL_THREAD_PERFORMANCE_SYSTEM_INFO_GET_INSERT

#define TX_EL_THREAD_PERFORMANCE_SYSTEM_INFO_GET_INSERT

◆ TX_EL_THREAD_PREEMPTION_CHANGE_INSERT

#define TX_EL_THREAD_PREEMPTION_CHANGE_INSERT

◆ TX_EL_THREAD_PRIORITY_CHANGE_INSERT

#define TX_EL_THREAD_PRIORITY_CHANGE_INSERT

◆ TX_EL_THREAD_REGISTER

#define TX_EL_THREAD_REGISTER ( a )

◆ TX_EL_THREAD_RELINQUISH_INSERT

#define TX_EL_THREAD_RELINQUISH_INSERT

◆ TX_EL_THREAD_RESET_INSERT

#define TX_EL_THREAD_RESET_INSERT

◆ TX_EL_THREAD_RESUME_INSERT

#define TX_EL_THREAD_RESUME_INSERT

◆ TX_EL_THREAD_SLEEP_INSERT

#define TX_EL_THREAD_SLEEP_INSERT

◆ TX_EL_THREAD_STACK_ERROR_NOTIFY_INSERT

#define TX_EL_THREAD_STACK_ERROR_NOTIFY_INSERT

◆ TX_EL_THREAD_STATUS_CHANGE_INSERT

#define TX_EL_THREAD_STATUS_CHANGE_INSERT	(	a,
		b
	)

◆ TX_EL_THREAD_SUSPEND_INSERT

#define TX_EL_THREAD_SUSPEND_INSERT

◆ TX_EL_THREAD_TERMINATE_INSERT

#define TX_EL_THREAD_TERMINATE_INSERT

◆ TX_EL_THREAD_TIME_SLICE_CHANGE_INSERT

#define TX_EL_THREAD_TIME_SLICE_CHANGE_INSERT

◆ TX_EL_THREAD_UNREGISTER

#define TX_EL_THREAD_UNREGISTER ( a )

◆ TX_EL_THREAD_WAIT_ABORT_INSERT

#define TX_EL_THREAD_WAIT_ABORT_INSERT

◆ TX_EL_TIME_GET_INSERT

#define TX_EL_TIME_GET_INSERT

◆ TX_EL_TIME_SET_INSERT

#define TX_EL_TIME_SET_INSERT

◆ TX_EL_TIMER_ACTIVATE_INSERT

#define TX_EL_TIMER_ACTIVATE_INSERT

◆ TX_EL_TIMER_CHANGE_INSERT

#define TX_EL_TIMER_CHANGE_INSERT

◆ TX_EL_TIMER_CREATE_INSERT

#define TX_EL_TIMER_CREATE_INSERT

◆ TX_EL_TIMER_DEACTIVATE_INSERT

#define TX_EL_TIMER_DEACTIVATE_INSERT

◆ TX_EL_TIMER_DELETE_INSERT

#define TX_EL_TIMER_DELETE_INSERT

◆ TX_EL_TIMER_INFO_GET_INSERT

#define TX_EL_TIMER_INFO_GET_INSERT

◆ TX_EL_TIMER_PERFORMANCE_INFO_GET_INSERT

#define TX_EL_TIMER_PERFORMANCE_INFO_GET_INSERT

◆ TX_EL_TIMER_PERFORMANCE_SYSTEM_INFO_GET_INSERT

#define TX_EL_TIMER_PERFORMANCE_SYSTEM_INFO_GET_INSERT

◆ TX_EVENT_FLAG

#define TX_EVENT_FLAG 7

◆ tx_event_flags_create

#define tx_event_flags_create	(	g,
		n
	)	_txe_event_flags_create(g, n, sizeof(TX_EVENT_FLAGS_GROUP))

◆ tx_event_flags_delete

#define tx_event_flags_delete _txe_event_flags_delete

◆ tx_event_flags_get

#define tx_event_flags_get _txe_event_flags_get

◆ tx_event_flags_info_get

#define tx_event_flags_info_get _txe_event_flags_info_get

◆ tx_event_flags_performance_info_get

#define tx_event_flags_performance_info_get _tx_event_flags_performance_info_get

◆ tx_event_flags_performance_system_info_get

#define tx_event_flags_performance_system_info_get _tx_event_flags_performance_system_info_get

◆ tx_event_flags_set

#define tx_event_flags_set _txe_event_flags_set

◆ tx_event_flags_set_notify

#define tx_event_flags_set_notify _txe_event_flags_set_notify

◆ TX_FALSE

#define TX_FALSE 0

◆ TX_FEATURE_NOT_ENABLED

#define TX_FEATURE_NOT_ENABLED 0xFF

◆ TX_FILE

#define TX_FILE 11

◆ TX_GROUP_ERROR

#define TX_GROUP_ERROR 0x06

◆ TX_INHERIT

#define TX_INHERIT 1

◆ TX_INHERIT_ERROR

#define TX_INHERIT_ERROR 0x1F

◆ tx_interrupt_control

#define tx_interrupt_control _tx_thread_interrupt_control

◆ TX_INVALID_CEILING

#define TX_INVALID_CEILING 0x22

◆ TX_IO_DRIVER

#define TX_IO_DRIVER 10

◆ tx_kernel_enter

#define tx_kernel_enter _tx_initialize_kernel_enter

◆ TX_LOOP_FOREVER

#define TX_LOOP_FOREVER 1

◆ TX_MEMSET

#define TX_MEMSET	(	a,
		b,
		c
	)	(memset)(a, b, c)

◆ tx_mutex_create

#define tx_mutex_create	(	m,
		n,
		i
	)	_txe_mutex_create(m, n, i, sizeof(TX_MUTEX))

◆ tx_mutex_delete

#define tx_mutex_delete _txe_mutex_delete

◆ TX_MUTEX_ERROR

#define TX_MUTEX_ERROR 0x1C

◆ tx_mutex_get

#define tx_mutex_get _txe_mutex_get

◆ tx_mutex_info_get

#define tx_mutex_info_get _txe_mutex_info_get

◆ tx_mutex_performance_info_get

#define tx_mutex_performance_info_get _tx_mutex_performance_info_get

◆ tx_mutex_performance_system_info_get

#define tx_mutex_performance_system_info_get _tx_mutex_performance_system_info_get

◆ tx_mutex_prioritize

#define tx_mutex_prioritize _txe_mutex_prioritize

◆ tx_mutex_put

#define tx_mutex_put _txe_mutex_put

◆ TX_MUTEX_SUSP

#define TX_MUTEX_SUSP 13

◆ TX_NO_ACTIVATE

#define TX_NO_ACTIVATE 0

◆ TX_NO_EVENTS

#define TX_NO_EVENTS 0x07

◆ TX_NO_INHERIT

#define TX_NO_INHERIT 0

◆ TX_NO_INSTANCE

#define TX_NO_INSTANCE 0x0D

◆ TX_NO_MEMORY

#define TX_NO_MEMORY 0x10

◆ TX_NO_TIME_SLICE

#define TX_NO_TIME_SLICE 0

◆ TX_NO_WAIT

#define TX_NO_WAIT 0

◆ TX_NOT_AVAILABLE

#define TX_NOT_AVAILABLE 0x1D

◆ TX_NOT_DONE

#define TX_NOT_DONE 0x20

◆ TX_NOT_OWNED

#define TX_NOT_OWNED 0x1E

◆ TX_NULL

#define TX_NULL (void*)0

◆ TX_OPTION_ERROR

#define TX_OPTION_ERROR 0x08

◆ TX_OR

#define TX_OR 0

◆ TX_OR_CLEAR

#define TX_OR_CLEAR 1

◆ TX_POOL_ERROR

#define TX_POOL_ERROR 0x02

◆ TX_PRIORITY_ERROR

#define TX_PRIORITY_ERROR 0x0F

◆ TX_PTR_ERROR

#define TX_PTR_ERROR 0x03

◆ tx_queue_create

#define tx_queue_create	(	q,
		n,
		m,
		s,
		l
	)	_txe_queue_create(q, n, m, s, l, sizeof(TX_QUEUE))

◆ tx_queue_delete

#define tx_queue_delete _txe_queue_delete

◆ TX_QUEUE_EMPTY

#define TX_QUEUE_EMPTY 0x0A

◆ TX_QUEUE_ERROR

#define TX_QUEUE_ERROR 0x09

◆ tx_queue_flush

#define tx_queue_flush _txe_queue_flush

◆ tx_queue_front_send

#define tx_queue_front_send _txe_queue_front_send

◆ TX_QUEUE_FULL

#define TX_QUEUE_FULL 0x0B

◆ tx_queue_info_get

#define tx_queue_info_get _txe_queue_info_get

◆ tx_queue_performance_info_get

#define tx_queue_performance_info_get _tx_queue_performance_info_get

◆ tx_queue_performance_system_info_get

#define tx_queue_performance_system_info_get _tx_queue_performance_system_info_get

◆ tx_queue_prioritize

#define tx_queue_prioritize _txe_queue_prioritize

◆ tx_queue_receive

#define tx_queue_receive _txe_queue_receive

◆ tx_queue_send

#define tx_queue_send _txe_queue_send

◆ tx_queue_send_notify

#define tx_queue_send_notify _txe_queue_send_notify

◆ TX_QUEUE_SUSP

#define TX_QUEUE_SUSP 5

◆ TX_READY

#define TX_READY 0

◆ TX_RESUME_ERROR

#define TX_RESUME_ERROR 0x12

◆ tx_semaphore_ceiling_put

#define tx_semaphore_ceiling_put _txe_semaphore_ceiling_put

◆ tx_semaphore_create

#define tx_semaphore_create	(	s,
		n,
		i
	)	_txe_semaphore_create(s, n, i, sizeof(TX_SEMAPHORE))

◆ tx_semaphore_delete

#define tx_semaphore_delete _txe_semaphore_delete

◆ TX_SEMAPHORE_ERROR

#define TX_SEMAPHORE_ERROR 0x0C

◆ tx_semaphore_get

#define tx_semaphore_get _txe_semaphore_get

◆ tx_semaphore_info_get

#define tx_semaphore_info_get _txe_semaphore_info_get

◆ tx_semaphore_performance_info_get

#define tx_semaphore_performance_info_get _tx_semaphore_performance_info_get

◆ tx_semaphore_performance_system_info_get

#define tx_semaphore_performance_system_info_get _tx_semaphore_performance_system_info_get

◆ tx_semaphore_prioritize

#define tx_semaphore_prioritize _txe_semaphore_prioritize

◆ tx_semaphore_put

#define tx_semaphore_put _txe_semaphore_put

◆ tx_semaphore_put_notify

#define tx_semaphore_put_notify _txe_semaphore_put_notify

◆ TX_SEMAPHORE_SUSP

#define TX_SEMAPHORE_SUSP 6

◆ TX_SIZE_ERROR

#define TX_SIZE_ERROR 0x05

◆ TX_SLEEP

#define TX_SLEEP 4

◆ TX_STACK_FILL

#define TX_STACK_FILL ((ULONG)0xEFEFEFEF)

◆ TX_START_ERROR

#define TX_START_ERROR 0x10

◆ TX_SUCCESS

#define TX_SUCCESS 0x00

◆ TX_SUSPEND_ERROR

#define TX_SUSPEND_ERROR 0x14

◆ TX_SUSPEND_LIFTED

#define TX_SUSPEND_LIFTED 0x19

◆ TX_SUSPENDED

#define TX_SUSPENDED 3

◆ TX_TCP_IP

#define TX_TCP_IP 12

◆ TX_TERMINATED

#define TX_TERMINATED 2

◆ tx_thread_create

#define tx_thread_create	(	t,
		n,
		e,
		i,
		s,
		l,
		p,
		r,
		c,
		a
	)	_txe_thread_create(t, n, e, i, s, l, p, r, c, a, sizeof(TX_THREAD))

◆ tx_thread_delete

#define tx_thread_delete _txe_thread_delete

◆ TX_THREAD_ENTRY

#define TX_THREAD_ENTRY 0

◆ tx_thread_entry_exit_notify

#define tx_thread_entry_exit_notify _txe_thread_entry_exit_notify

◆ TX_THREAD_ERROR

#define TX_THREAD_ERROR 0x0E

◆ TX_THREAD_EXIT

#define TX_THREAD_EXIT 1

◆ tx_thread_getspecific

#define tx_thread_getspecific _tx_thread_getspecific

◆ tx_thread_identify

#define tx_thread_identify _tx_thread_identify

◆ tx_thread_info_get

#define tx_thread_info_get _txe_thread_info_get

◆ tx_thread_once

#define tx_thread_once _tx_thread_once

◆ TX_THREAD_ONCE_INIT

#define TX_THREAD_ONCE_INIT

Value:

{                             \
        TX_THREAD_ONCE_INIT_VALUE \
    }

◆ TX_THREAD_ONCE_INIT_VALUE

#define TX_THREAD_ONCE_INIT_VALUE 0U

◆ tx_thread_performance_info_get

#define tx_thread_performance_info_get _tx_thread_performance_info_get

◆ tx_thread_performance_system_info_get

#define tx_thread_performance_system_info_get _tx_thread_performance_system_info_get

◆ tx_thread_preemption_change

#define tx_thread_preemption_change _txe_thread_preemption_change

◆ tx_thread_priority_change

#define tx_thread_priority_change _txe_thread_priority_change

◆ tx_thread_relinquish

#define tx_thread_relinquish _txe_thread_relinquish

◆ tx_thread_reset

#define tx_thread_reset _txe_thread_reset

◆ tx_thread_resume

#define tx_thread_resume _txe_thread_resume

◆ tx_thread_setspecific

#define tx_thread_setspecific _tx_thread_setspecific

◆ tx_thread_sleep

#define tx_thread_sleep _tx_thread_sleep

◆ tx_thread_stack_error_notify

#define tx_thread_stack_error_notify _tx_thread_stack_error_notify

◆ tx_thread_suspend

#define tx_thread_suspend _txe_thread_suspend

◆ tx_thread_terminate

#define tx_thread_terminate _txe_thread_terminate

◆ tx_thread_time_slice_change

#define tx_thread_time_slice_change _txe_thread_time_slice_change

◆ tx_thread_wait_abort

#define tx_thread_wait_abort _txe_thread_wait_abort

◆ TX_THRESH_ERROR

#define TX_THRESH_ERROR 0x18

◆ TX_TICK_ERROR

#define TX_TICK_ERROR 0x16

◆ tx_time_get

#define tx_time_get _tx_time_get

◆ tx_time_set

#define tx_time_set _tx_time_set

◆ tx_timer_activate

#define tx_timer_activate _txe_timer_activate

◆ tx_timer_change

#define tx_timer_change _txe_timer_change

◆ tx_timer_create

#define tx_timer_create	(	t,
		n,
		e,
		i,
		c,
		r,
		a
	)	_txe_timer_create(t, n, e, i, c, r, a, sizeof(TX_TIMER))

◆ tx_timer_deactivate

#define tx_timer_deactivate _txe_timer_deactivate

◆ tx_timer_delete

#define tx_timer_delete _txe_timer_delete

◆ TX_TIMER_ERROR

#define TX_TIMER_ERROR 0x15

◆ tx_timer_info_get

#define tx_timer_info_get _txe_timer_info_get

◆ tx_timer_performance_info_get

#define tx_timer_performance_info_get _tx_timer_performance_info_get

◆ tx_timer_performance_system_info_get

#define tx_timer_performance_system_info_get _tx_timer_performance_system_info_get

◆ TX_TRACE_ALL_EVENTS

#define TX_TRACE_ALL_EVENTS 0x000007FF /* All ThreadX events */

◆ TX_TRACE_BLOCK_POOL_EVENTS

#define TX_TRACE_BLOCK_POOL_EVENTS 0x00000002 /* ThreadX Block Pool events */

◆ tx_trace_buffer_full_notify

#define tx_trace_buffer_full_notify _tx_trace_buffer_full_notify

◆ TX_TRACE_BYTE_POOL_EVENTS

#define TX_TRACE_BYTE_POOL_EVENTS 0x00000004 /* ThreadX Byte Pool events */

◆ tx_trace_disable

#define tx_trace_disable _tx_trace_disable

◆ tx_trace_enable

#define tx_trace_enable _tx_trace_enable

◆ tx_trace_event_filter

#define tx_trace_event_filter _tx_trace_event_filter

◆ TX_TRACE_EVENT_FLAGS_EVENTS

#define TX_TRACE_EVENT_FLAGS_EVENTS 0x00000008 /* ThreadX Event Flags events */

◆ tx_trace_event_unfilter

#define tx_trace_event_unfilter _tx_trace_event_unfilter

◆ TX_TRACE_INTERNAL_EVENTS

#define TX_TRACE_INTERNAL_EVENTS 0x00000001 /* ThreadX internal events */

◆ TX_TRACE_INTERRUPT_CONTROL_EVENT

#define TX_TRACE_INTERRUPT_CONTROL_EVENT 0x00000010 /* ThreadX Interrupt Control events */

◆ tx_trace_isr_enter_insert

#define tx_trace_isr_enter_insert _tx_trace_isr_enter_insert

◆ tx_trace_isr_exit_insert

#define tx_trace_isr_exit_insert _tx_trace_isr_exit_insert

◆ TX_TRACE_MUTEX_EVENTS

#define TX_TRACE_MUTEX_EVENTS 0x00000020 /* ThreadX Mutex events */

◆ TX_TRACE_QUEUE_EVENTS

#define TX_TRACE_QUEUE_EVENTS 0x00000040 /* ThreadX Queue events */

◆ TX_TRACE_SEMAPHORE_EVENTS

#define TX_TRACE_SEMAPHORE_EVENTS 0x00000080 /* ThreadX Semaphore events */

◆ TX_TRACE_THREAD_EVENTS

#define TX_TRACE_THREAD_EVENTS 0x00000100 /* ThreadX Thread events */

◆ TX_TRACE_TIME_EVENTS

#define TX_TRACE_TIME_EVENTS 0x00000200 /* ThreadX Time events */

◆ TX_TRACE_TIMER_EVENTS

#define TX_TRACE_TIMER_EVENTS 0x00000400 /* ThreadX Timer events */

◆ TX_TRACE_USER_EVENT_END

#define TX_TRACE_USER_EVENT_END 65535 /* I1, I2, I3, I4 are user defined */

◆ tx_trace_user_event_insert

#define tx_trace_user_event_insert _tx_trace_user_event_insert

◆ TX_TRACE_USER_EVENT_START

#define TX_TRACE_USER_EVENT_START 4096 /* I1, I2, I3, I4 are user defined */

◆ TX_TRACE_USER_EVENTS

#define TX_TRACE_USER_EVENTS 0x80000000 /* ThreadX User Events */

◆ TX_TRUE

#define TX_TRUE 1

◆ TX_WAIT_ABORT_ERROR

#define TX_WAIT_ABORT_ERROR 0x1B

◆ TX_WAIT_ABORTED

#define TX_WAIT_ABORTED 0x1A

◆ TX_WAIT_ERROR

#define TX_WAIT_ERROR 0x04

◆ TX_WAIT_FOREVER

#define TX_WAIT_FOREVER ((ULONG)0xFFFFFFFF)

Typedef Documentation

◆ TX_BLOCK_POOL

typedef struct TX_BLOCK_POOL_STRUCT TX_BLOCK_POOL

◆ TX_BYTE_POOL

typedef struct TX_BYTE_POOL_STRUCT TX_BYTE_POOL

◆ TX_EVENT_FLAGS_GROUP

typedef struct TX_EVENT_FLAGS_GROUP_STRUCT TX_EVENT_FLAGS_GROUP

◆ TX_MUTEX

typedef struct TX_MUTEX_STRUCT TX_MUTEX

◆ TX_QUEUE

typedef struct TX_QUEUE_STRUCT TX_QUEUE

◆ TX_SEMAPHORE

typedef struct TX_SEMAPHORE_STRUCT TX_SEMAPHORE

◆ TX_THREAD

typedef struct TX_THREAD_STRUCT TX_THREAD

◆ TX_THREAD_KEY

typedef int TX_THREAD_KEY

◆ TX_THREAD_SPECIFIC

typedef struct TX_THREAD_SPECIFIC_STRUCT TX_THREAD_SPECIFIC

◆ TX_TIMER

typedef struct TX_TIMER_STRUCT TX_TIMER

◆ TX_TIMER_INTERNAL

typedef struct TX_TIMER_INTERNAL_STRUCT TX_TIMER_INTERNAL

Enumeration Type Documentation

◆ TX_THREAD_KEYS

enum TX_THREAD_KEYS

Enumerator
TX_THREAD_SJLJ_KEY
TX_THREAD_CXA_GLOBAL_KEY
TX_THREAD_MAX_KEY

Function Documentation

◆ attribute()

struct TX_THREAD_ONCE_CONTROL __attribute__ ( (aligned(sizeof(struct TX_THREAD_ONCE_CONTROL))) )

◆ _txe_block_pool_create()

UINT _txe_block_pool_create	(	TX_BLOCK_POOL *	pool_ptr,
		const CHAR *	name_ptr,
		ULONG	block_size,
		VOID *	pool_start,
		ULONG	pool_size,
		UINT	pool_control_block_size
	)

◆ _txe_byte_pool_create()

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

◆ _txe_event_flags_create()

UINT _txe_event_flags_create	(	TX_EVENT_FLAGS_GROUP *	group_ptr,
		const CHAR *	name_ptr,
		UINT	event_control_block_size
	)

◆ _txe_mutex_create()

UINT _txe_mutex_create	(	TX_MUTEX *	mutex_ptr,
		const CHAR *	name_ptr,
		UINT	inherit,
		UINT	mutex_control_block_size
	)

◆ _txe_queue_create()

UINT _txe_queue_create	(	TX_QUEUE *	queue_ptr,
		const CHAR *	name_ptr,
		UINT	message_size,
		VOID *	queue_start,
		ULONG	queue_size,
		UINT	queue_control_block_size
	)

◆ _txe_semaphore_create()

UINT _txe_semaphore_create	(	TX_SEMAPHORE *	semaphore_ptr,
		const CHAR *	name_ptr,
		ULONG	initial_count,
		UINT	semaphore_control_block_size
	)

◆ _txe_thread_create()

UINT _txe_thread_create	(	TX_THREAD *	thread_ptr,
		const CHAR *	name_ptr,
		VOID(*)(ULONG)	entry_function,
		ULONG	entry_input,
		VOID *	stack_start,
		ULONG	stack_size,
		UINT	priority,
		UINT	preempt_threshold,
		ULONG	time_slice,
		UINT	auto_start,
		UINT	thread_control_block_size
	)

◆ _txe_timer_create()

UINT _txe_timer_create	(	TX_TIMER *	timer_ptr,
		const CHAR *	name_ptr,
		VOID(*)(ULONG)	expiration_function,
		ULONG	expiration_input,
		ULONG	initial_ticks,
		ULONG	reschedule_ticks,
		UINT	auto_activate,
		UINT	timer_control_block_size
	)

◆ threadx_thread_destroy_extension()

void threadx_thread_destroy_extension ( TX_THREAD * )

◆ tx_application_define()

VOID tx_application_define ( VOID * )

◆ tx_block_allocate()

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

◆ tx_block_pool_delete()

UINT tx_block_pool_delete ( TX_BLOCK_POOL * pool_ptr )

◆ tx_block_pool_info_get()

UINT tx_block_pool_info_get	(	TX_BLOCK_POOL *	pool_ptr,
		const CHAR **	name,
		ULONG *	available_blocks,
		ULONG *	total_blocks,
		TX_THREAD **	first_suspended,
		ULONG *	suspended_count,
		TX_BLOCK_POOL **	next_pool
	)

◆ tx_block_pool_performance_info_get()

UINT tx_block_pool_performance_info_get	(	TX_BLOCK_POOL *	pool_ptr,
		ULONG *	allocates,
		ULONG *	releases,
		ULONG *	suspensions,
		ULONG *	timeouts
	)

◆ tx_block_pool_performance_system_info_get()

UINT tx_block_pool_performance_system_info_get	(	ULONG *	allocates,
		ULONG *	releases,
		ULONG *	suspensions,
		ULONG *	timeouts
	)

◆ tx_block_pool_prioritize()

UINT tx_block_pool_prioritize ( TX_BLOCK_POOL * pool_ptr )

◆ tx_block_release()

UINT tx_block_release ( VOID * block_ptr )

◆ tx_byte_allocate()

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

Referenced by malloc().

◆ tx_byte_pool_delete()

UINT tx_byte_pool_delete ( TX_BYTE_POOL * pool_ptr )

◆ tx_byte_pool_info_get()

UINT tx_byte_pool_info_get	(	TX_BYTE_POOL *	pool_ptr,
		const CHAR **	name,
		ULONG *	available_bytes,
		ULONG *	fragments,
		TX_THREAD **	first_suspended,
		ULONG *	suspended_count,
		TX_BYTE_POOL **	next_pool
	)

◆ tx_byte_pool_performance_info_get()

UINT tx_byte_pool_performance_info_get	(	TX_BYTE_POOL *	pool_ptr,
		ULONG *	allocates,
		ULONG *	releases,
		ULONG *	fragments_searched,
		ULONG *	merges,
		ULONG *	splits,
		ULONG *	suspensions,
		ULONG *	timeouts
	)

◆ tx_byte_pool_performance_system_info_get()

UINT tx_byte_pool_performance_system_info_get	(	ULONG *	allocates,
		ULONG *	releases,
		ULONG *	fragments_searched,
		ULONG *	merges,
		ULONG *	splits,
		ULONG *	suspensions,
		ULONG *	timeouts
	)

◆ tx_byte_pool_prioritize()

UINT tx_byte_pool_prioritize ( TX_BYTE_POOL * pool_ptr )

◆ tx_byte_release()

UINT tx_byte_release ( VOID * memory_ptr )

Referenced by free().

◆ tx_event_flags_delete()

UINT tx_event_flags_delete ( TX_EVENT_FLAGS_GROUP * group_ptr )

◆ tx_event_flags_get()

UINT tx_event_flags_get	(	TX_EVENT_FLAGS_GROUP *	group_ptr,
		ULONG	requested_flags,
		UINT	get_option,
		ULONG *	actual_flags_ptr,
		ULONG	wait_option
	)

◆ tx_event_flags_info_get()

UINT tx_event_flags_info_get	(	TX_EVENT_FLAGS_GROUP *	group_ptr,
		const CHAR **	name,
		ULONG *	current_flags,
		TX_THREAD **	first_suspended,
		ULONG *	suspended_count,
		TX_EVENT_FLAGS_GROUP **	next_group
	)

◆ tx_event_flags_performance_info_get()

UINT tx_event_flags_performance_info_get	(	TX_EVENT_FLAGS_GROUP *	group_ptr,
		ULONG *	sets,
		ULONG *	gets,
		ULONG *	suspensions,
		ULONG *	timeouts
	)

◆ tx_event_flags_performance_system_info_get()

UINT tx_event_flags_performance_system_info_get	(	ULONG *	sets,
		ULONG *	gets,
		ULONG *	suspensions,
		ULONG *	timeouts
	)

◆ tx_event_flags_set()

UINT tx_event_flags_set	(	TX_EVENT_FLAGS_GROUP *	group_ptr,
		ULONG	flags_to_set,
		UINT	set_option
	)

◆ tx_event_flags_set_notify()

UINT tx_event_flags_set_notify	(	TX_EVENT_FLAGS_GROUP *	group_ptr,
		VOID()(TX_EVENT_FLAGS_GROUP )	events_set_notify
	)

◆ tx_interrupt_control()

UINT tx_interrupt_control ( UINT new_posture )

◆ tx_kernel_enter()

VOID tx_kernel_enter ( VOID )

◆ tx_mutex_delete()

UINT tx_mutex_delete ( TX_MUTEX * mutex_ptr )

◆ tx_mutex_get()

UINT tx_mutex_get	(	TX_MUTEX *	mutex_ptr,
		ULONG	wait_option
	)

◆ tx_mutex_info_get()

UINT tx_mutex_info_get	(	TX_MUTEX *	mutex_ptr,
		const CHAR **	name,
		ULONG *	count,
		TX_THREAD **	owner,
		TX_THREAD **	first_suspended,
		ULONG *	suspended_count,
		TX_MUTEX **	next_mutex
	)

◆ tx_mutex_performance_info_get()

UINT tx_mutex_performance_info_get	(	TX_MUTEX *	mutex_ptr,
		ULONG *	puts,
		ULONG *	gets,
		ULONG *	suspensions,
		ULONG *	timeouts,
		ULONG *	inversions,
		ULONG *	inheritances
	)

◆ tx_mutex_performance_system_info_get()

UINT tx_mutex_performance_system_info_get	(	ULONG *	puts,
		ULONG *	gets,
		ULONG *	suspensions,
		ULONG *	timeouts,
		ULONG *	inversions,
		ULONG *	inheritances
	)

◆ tx_mutex_prioritize()

UINT tx_mutex_prioritize ( TX_MUTEX * mutex_ptr )

◆ tx_mutex_put()

UINT tx_mutex_put ( TX_MUTEX * mutex_ptr )

◆ tx_queue_delete()

UINT tx_queue_delete ( TX_QUEUE * queue_ptr )

◆ tx_queue_flush()

UINT tx_queue_flush ( TX_QUEUE * queue_ptr )

◆ tx_queue_front_send()

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

◆ tx_queue_info_get()

UINT tx_queue_info_get	(	TX_QUEUE *	queue_ptr,
		const CHAR **	name,
		ULONG *	enqueued,
		ULONG *	available_storage,
		TX_THREAD **	first_suspended,
		ULONG *	suspended_count,
		TX_QUEUE **	next_queue
	)

◆ tx_queue_performance_info_get()

UINT tx_queue_performance_info_get	(	TX_QUEUE *	queue_ptr,
		ULONG *	messages_sent,
		ULONG *	messages_received,
		ULONG *	empty_suspensions,
		ULONG *	full_suspensions,
		ULONG *	full_errors,
		ULONG *	timeouts
	)

◆ tx_queue_performance_system_info_get()

UINT tx_queue_performance_system_info_get	(	ULONG *	messages_sent,
		ULONG *	messages_received,
		ULONG *	empty_suspensions,
		ULONG *	full_suspensions,
		ULONG *	full_errors,
		ULONG *	timeouts
	)

◆ tx_queue_prioritize()

UINT tx_queue_prioritize ( TX_QUEUE * queue_ptr )

◆ tx_queue_receive()

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

◆ tx_queue_send()

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

◆ tx_queue_send_notify()

UINT tx_queue_send_notify	(	TX_QUEUE *	queue_ptr,
		VOID()(TX_QUEUE )	queue_send_notify
	)

◆ tx_semaphore_ceiling_put()

UINT tx_semaphore_ceiling_put	(	TX_SEMAPHORE *	semaphore_ptr,
		ULONG	ceiling
	)

◆ tx_semaphore_delete()

UINT tx_semaphore_delete ( TX_SEMAPHORE * semaphore_ptr )

◆ tx_semaphore_get()

UINT tx_semaphore_get	(	TX_SEMAPHORE *	semaphore_ptr,
		ULONG	wait_option
	)

◆ tx_semaphore_info_get()

UINT tx_semaphore_info_get	(	TX_SEMAPHORE *	semaphore_ptr,
		const CHAR **	name,
		ULONG *	current_value,
		TX_THREAD **	first_suspended,
		ULONG *	suspended_count,
		TX_SEMAPHORE **	next_semaphore
	)

◆ tx_semaphore_performance_info_get()

UINT tx_semaphore_performance_info_get	(	TX_SEMAPHORE *	semaphore_ptr,
		ULONG *	puts,
		ULONG *	gets,
		ULONG *	suspensions,
		ULONG *	timeouts
	)

◆ tx_semaphore_performance_system_info_get()

UINT tx_semaphore_performance_system_info_get	(	ULONG *	puts,
		ULONG *	gets,
		ULONG *	suspensions,
		ULONG *	timeouts
	)

◆ tx_semaphore_prioritize()

UINT tx_semaphore_prioritize ( TX_SEMAPHORE * semaphore_ptr )

◆ tx_semaphore_put()

UINT tx_semaphore_put ( TX_SEMAPHORE * semaphore_ptr )

◆ tx_semaphore_put_notify()

UINT tx_semaphore_put_notify	(	TX_SEMAPHORE *	semaphore_ptr,
		VOID()(TX_SEMAPHORE )	semaphore_put_notify
	)

◆ tx_thread_delete()

UINT tx_thread_delete ( TX_THREAD * thread_ptr )

◆ tx_thread_entry_exit_notify()

UINT tx_thread_entry_exit_notify	(	TX_THREAD *	thread_ptr,
		VOID()(TX_THREAD , UINT)	thread_entry_exit_notify
	)

◆ tx_thread_getspecific()

VOID* tx_thread_getspecific ( TX_THREAD_KEY key )

◆ tx_thread_identify()

TX_THREAD* tx_thread_identify ( VOID )

◆ tx_thread_info_get()

UINT tx_thread_info_get	(	TX_THREAD *	thread_ptr,
		const CHAR **	name,
		UINT *	state,
		ULONG *	run_count,
		UINT *	priority,
		UINT *	preemption_threshold,
		ULONG *	time_slice,
		TX_THREAD **	next_thread,
		TX_THREAD **	next_suspended_thread
	)

◆ tx_thread_once()

UINT tx_thread_once	(	TX_THREAD_ONCE *	once_control,
		void(*)(void)	once_routine
	)

◆ tx_thread_performance_info_get()

UINT tx_thread_performance_info_get	(	TX_THREAD *	thread_ptr,
		ULONG *	resumptions,
		ULONG *	suspensions,
		ULONG *	solicited_preemptions,
		ULONG *	interrupt_preemptions,
		ULONG *	priority_inversions,
		ULONG *	time_slices,
		ULONG *	relinquishes,
		ULONG *	timeouts,
		ULONG *	wait_aborts,
		TX_THREAD **	last_preempted_by
	)

◆ tx_thread_performance_system_info_get()

UINT tx_thread_performance_system_info_get	(	ULONG *	resumptions,
		ULONG *	suspensions,
		ULONG *	solicited_preemptions,
		ULONG *	interrupt_preemptions,
		ULONG *	priority_inversions,
		ULONG *	time_slices,
		ULONG *	relinquishes,
		ULONG *	timeouts,
		ULONG *	wait_aborts,
		ULONG *	non_idle_returns,
		ULONG *	idle_returns
	)

◆ tx_thread_preemption_change()

UINT tx_thread_preemption_change	(	TX_THREAD *	thread_ptr,
		UINT	new_threshold,
		UINT *	old_threshold
	)

◆ tx_thread_priority_change()

UINT tx_thread_priority_change	(	TX_THREAD *	thread_ptr,
		UINT	new_priority,
		UINT *	old_priority
	)

◆ tx_thread_relinquish()

VOID tx_thread_relinquish ( VOID )

◆ tx_thread_reset()

UINT tx_thread_reset ( TX_THREAD * thread_ptr )

◆ tx_thread_resume()

UINT tx_thread_resume ( TX_THREAD * thread_ptr )

◆ tx_thread_setspecific()

VOID tx_thread_setspecific	(	TX_THREAD_KEY	key,
		void *	data
	)

◆ tx_thread_sleep()

UINT tx_thread_sleep ( ULONG timer_ticks )

Referenced by malloc().

◆ tx_thread_stack_error_notify()

UINT tx_thread_stack_error_notify ( VOID(*)(TX_THREAD *) stack_error_handler )

◆ tx_thread_suspend()

UINT tx_thread_suspend ( TX_THREAD * thread_ptr )

◆ tx_thread_terminate()

UINT tx_thread_terminate ( TX_THREAD * thread_ptr )

◆ tx_thread_time_slice_change()

UINT tx_thread_time_slice_change	(	TX_THREAD *	thread_ptr,
		ULONG	new_time_slice,
		ULONG *	old_time_slice
	)

◆ tx_thread_wait_abort()

UINT tx_thread_wait_abort ( TX_THREAD * thread_ptr )

◆ tx_time_get()

ULONG tx_time_get ( VOID )

◆ tx_time_set()

VOID tx_time_set ( ULONG new_time )

◆ tx_timer_activate()

UINT tx_timer_activate ( TX_TIMER * timer_ptr )

◆ tx_timer_change()

UINT tx_timer_change	(	TX_TIMER *	timer_ptr,
		ULONG	initial_ticks,
		ULONG	reschedule_ticks
	)

◆ tx_timer_deactivate()

UINT tx_timer_deactivate ( TX_TIMER * timer_ptr )

◆ tx_timer_delete()

UINT tx_timer_delete ( TX_TIMER * timer_ptr )

◆ tx_timer_info_get()

UINT tx_timer_info_get	(	TX_TIMER *	timer_ptr,
		const CHAR **	name,
		UINT *	active,
		ULONG *	remaining_ticks,
		ULONG *	reschedule_ticks,
		TX_TIMER **	next_timer
	)

◆ tx_timer_performance_info_get()

UINT tx_timer_performance_info_get	(	TX_TIMER *	timer_ptr,
		ULONG *	activates,
		ULONG *	reactivates,
		ULONG *	deactivates,
		ULONG *	expirations,
		ULONG *	expiration_adjusts
	)

◆ tx_timer_performance_system_info_get()

UINT tx_timer_performance_system_info_get	(	ULONG *	activates,
		ULONG *	reactivates,
		ULONG *	deactivates,
		ULONG *	expirations,
		ULONG *	expiration_adjusts
	)

◆ tx_trace_buffer_full_notify()

UINT tx_trace_buffer_full_notify ( VOID(*)(VOID *) full_buffer_callback )

◆ tx_trace_disable()

UINT tx_trace_disable ( VOID )

◆ tx_trace_enable()

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

◆ tx_trace_event_filter()

UINT tx_trace_event_filter ( ULONG event_filter_bits )

◆ tx_trace_event_unfilter()

UINT tx_trace_event_unfilter ( ULONG event_unfilter_bits )

◆ tx_trace_isr_enter_insert()

VOID tx_trace_isr_enter_insert ( ULONG isr_id )

◆ tx_trace_isr_exit_insert()

VOID tx_trace_isr_exit_insert ( ULONG isr_id )

◆ tx_trace_user_event_insert()

UINT tx_trace_user_event_insert	(	ULONG	event_id,
		ULONG	info_field_1,
		ULONG	info_field_2,
		ULONG	info_field_3,
		ULONG	info_field_4
	)

Variable Documentation

◆ once_value

volatile int once_value

Classes

Macros

Typedefs

Enumerations

Functions

Variables