UINT

UINT tx_thread_priority; /* Priority of thread (0-1023) */

tx_api.h:397

TX_THREAD_STRUCT::tx_thread_priority

UINT tx_thread_state; /* Thread's execution state */

tx_api.h:398

TX_THREAD_STRUCT::tx_thread_state

UINT tx_thread_delayed_suspend; /* Delayed suspend flag */

tx_api.h:399

TX_THREAD_STRUCT::tx_thread_delayed_suspend

UINT tx_thread_suspending; /* Thread suspending flag */

tx_api.h:400

TX_THREAD_STRUCT::tx_thread_suspending

UINT tx_thread_preempt_threshold; /* Preemption threshold */

tx_api.h:401

TX_THREAD_STRUCT::tx_thread_preempt_threshold

UINT tx_thread_suspend_option;

tx_api.h:432

TX_THREAD_STRUCT::tx_thread_suspend_option

UINT tx_thread_suspend_status;

tx_api.h:433

TX_THREAD_STRUCT::tx_thread_suspend_status

UINT tx_thread_user_priority;

tx_api.h:457

TX_THREAD_STRUCT::tx_thread_user_priority

UINT tx_thread_user_preempt_threshold;

tx_api.h:458

TX_THREAD_STRUCT::tx_thread_user_preempt_threshold

UINT tx_thread_inherit_priority;

tx_api.h:459

TX_THREAD_STRUCT::tx_thread_inherit_priority

UINT tx_thread_owned_mutex_count;

tx_api.h:462

TX_THREAD_STRUCT::tx_thread_owned_mutex_count

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

tx_api.h:511

UINT tx_block_pool_available;

tx_api.h:554

TX_BLOCK_POOL_STRUCT::tx_block_pool_available

UINT tx_block_pool_total;

tx_api.h:557

TX_BLOCK_POOL_STRUCT::tx_block_pool_total

UINT tx_block_pool_block_size;

tx_api.h:569

TX_BLOCK_POOL_STRUCT::tx_block_pool_block_size

UINT tx_block_pool_suspended_count;

tx_api.h:575

TX_BLOCK_POOL_STRUCT::tx_block_pool_suspended_count

UINT tx_byte_pool_fragments;

tx_api.h:635

TX_BYTE_POOL_STRUCT

TX_BYTE_POOL_STRUCT::tx_byte_pool_fragments

UINT tx_byte_pool_suspended_count;

tx_api.h:660

TX_BYTE_POOL_STRUCT

TX_BYTE_POOL_STRUCT::tx_byte_pool_suspended_count

UINT tx_event_flags_group_reset_search;

tx_api.h:716

TX_EVENT_FLAGS_GROUP_STRUCT

TX_EVENT_FLAGS_GROUP_STRUCT::tx_event_flags_group_reset_search

UINT tx_event_flags_group_suspended_count;

tx_api.h:722

TX_EVENT_FLAGS_GROUP_STRUCT

TX_EVENT_FLAGS_GROUP_STRUCT::tx_event_flags_group_suspended_count

UINT tx_mutex_ownership_count;

tx_api.h:797

TX_MUTEX_STRUCT::tx_mutex_ownership_count

UINT tx_mutex_inherit;

tx_api.h:805

TX_MUTEX_STRUCT::tx_mutex_inherit

UINT tx_mutex_original_priority;

tx_api.h:808

TX_MUTEX_STRUCT::tx_mutex_original_priority

UINT tx_mutex_suspended_count;

tx_api.h:814

TX_MUTEX_STRUCT::tx_mutex_suspended_count

UINT tx_mutex_highest_priority_waiting;

tx_api.h:823

TX_MUTEX_STRUCT::tx_mutex_highest_priority_waiting

UINT tx_queue_message_size;

tx_api.h:870

TX_QUEUE_STRUCT::tx_queue_message_size

UINT tx_queue_capacity;

tx_api.h:873

TX_QUEUE_STRUCT::tx_queue_capacity

UINT tx_queue_enqueued;

tx_api.h:877

TX_QUEUE_STRUCT::tx_queue_enqueued

UINT tx_queue_available_storage;

tx_api.h:878

TX_QUEUE_STRUCT::tx_queue_available_storage

UINT tx_queue_suspended_count;

tx_api.h:894

TX_QUEUE_STRUCT::tx_queue_suspended_count

UINT tx_semaphore_suspended_count;

tx_api.h:956

TX_SEMAPHORE_STRUCT

TX_SEMAPHORE_STRUCT::tx_semaphore_suspended_count

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

tx_api.h:1372

UINT _tx_block_pool_create(TX_BLOCK_POOL *pool_ptr, CHAR *name_ptr, ULONG block_size,

tx_api.h:1373

UINT _tx_block_pool_delete(TX_BLOCK_POOL *pool_ptr);

tx_api.h:1375

UINT _tx_block_pool_info_get(TX_BLOCK_POOL *pool_ptr, CHAR **name, ULONG *available_blocks,

tx_api.h:1376

UINT _tx_block_pool_performance_info_get(TX_BLOCK_POOL *pool_ptr, ULONG *allocates, ULONG *releases,

tx_api.h:1379

UINT _tx_block_pool_performance_system_info_get(ULONG *allocates, ULONG *releases,

tx_api.h:1381

UINT _tx_block_pool_prioritize(TX_BLOCK_POOL *pool_ptr);

tx_api.h:1383

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

UINT _txe_block_pool_create(TX_BLOCK_POOL *pool_ptr, CHAR *name_ptr, ULONG block_size,

tx_api.h:1391

VOID *pool_start, ULONG pool_size, UINT pool_control_block_size);

tx_api.h:1392

_txe_block_pool_create()::pool_control_block_size

UINT _txe_block_pool_delete(TX_BLOCK_POOL *pool_ptr);

tx_api.h:1393

UINT _txe_block_pool_info_get(TX_BLOCK_POOL *pool_ptr, CHAR **name, ULONG *available_blocks,

tx_api.h:1394

UINT _txe_block_pool_prioritize(TX_BLOCK_POOL *pool_ptr);

tx_api.h:1397

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_pool_delete(TX_BYTE_POOL *pool_ptr);

tx_api.h:1418

UINT _tx_byte_pool_info_get(TX_BYTE_POOL *pool_ptr, CHAR **name, ULONG *available_bytes,

tx_api.h:1419

UINT _tx_byte_pool_performance_info_get(TX_BYTE_POOL *pool_ptr, ULONG *allocates, ULONG *releases,

tx_api.h:1422

UINT _tx_byte_pool_performance_system_info_get(ULONG *allocates, ULONG *releases,

tx_api.h:1424

UINT _tx_byte_pool_prioritize(TX_BYTE_POOL *pool_ptr);

tx_api.h:1426

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

ULONG pool_size, UINT pool_control_block_size);

tx_api.h:1436

_txe_byte_pool_create()::pool_control_block_size

UINT _txe_byte_pool_delete(TX_BYTE_POOL *pool_ptr);

tx_api.h:1437

UINT _txe_byte_pool_info_get(TX_BYTE_POOL *pool_ptr, CHAR **name, ULONG *available_bytes,

tx_api.h:1438

UINT _txe_byte_pool_prioritize(TX_BYTE_POOL *pool_ptr);

tx_api.h:1441

UINT _txe_byte_release(VOID *memory_ptr);

tx_api.h:1442

UINT _tx_event_flags_create(TX_EVENT_FLAGS_GROUP *group_ptr, CHAR *name_ptr);

tx_api.h:1459

UINT _tx_event_flags_delete(TX_EVENT_FLAGS_GROUP *group_ptr);

tx_api.h:1460

UINT _tx_event_flags_get(TX_EVENT_FLAGS_GROUP *group_ptr, ULONG requested_flags,

tx_api.h:1461

UINT get_option, ULONG *actual_flags_ptr, ULONG wait_option);

tx_api.h:1462

_tx_event_flags_get()::get_option

UINT _tx_event_flags_info_get(TX_EVENT_FLAGS_GROUP *group_ptr, CHAR **name, ULONG *current_flags,

tx_api.h:1463

UINT _tx_event_flags_performance_info_get(TX_EVENT_FLAGS_GROUP *group_ptr, ULONG *sets, ULONG *gets,

tx_api.h:1466

UINT _tx_event_flags_performance_system_info_get(ULONG *sets, ULONG *gets,

tx_api.h:1468

UINT _tx_event_flags_set(TX_EVENT_FLAGS_GROUP *group_ptr, ULONG flags_to_set,

tx_api.h:1470

UINT set_option);

tx_api.h:1471

_tx_event_flags_set()::set_option

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_create(TX_EVENT_FLAGS_GROUP *group_ptr, CHAR *name_ptr, UINT event_control_block_size);

tx_api.h:1478

UINT _txe_event_flags_delete(TX_EVENT_FLAGS_GROUP *group_ptr);

tx_api.h:1479

UINT _txe_event_flags_get(TX_EVENT_FLAGS_GROUP *group_ptr, ULONG requested_flags,

tx_api.h:1480

UINT get_option, ULONG *actual_flags_ptr, ULONG wait_option);

tx_api.h:1481

_txe_event_flags_get()::get_option

UINT _txe_event_flags_info_get(TX_EVENT_FLAGS_GROUP *group_ptr, CHAR **name, ULONG *current_flags,

tx_api.h:1482

UINT _txe_event_flags_set(TX_EVENT_FLAGS_GROUP *group_ptr, ULONG flags_to_set,

tx_api.h:1485

UINT set_option);

tx_api.h:1486

_txe_event_flags_set()::set_option

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

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

tx_api.h:1509

UINT _tx_mutex_delete(TX_MUTEX *mutex_ptr);

tx_api.h:1510

UINT _tx_mutex_get(TX_MUTEX *mutex_ptr, ULONG wait_option);

tx_api.h:1511

UINT _tx_mutex_info_get(TX_MUTEX *mutex_ptr, CHAR **name, ULONG *count, TX_THREAD **owner,

tx_api.h:1512

UINT _tx_mutex_performance_info_get(TX_MUTEX *mutex_ptr, ULONG *puts, ULONG *gets,

tx_api.h:1515

UINT _tx_mutex_performance_system_info_get(ULONG *puts, ULONG *gets, ULONG *suspensions, ULONG *timeouts,

tx_api.h:1517

UINT _tx_mutex_prioritize(TX_MUTEX *mutex_ptr);

tx_api.h:1519

UINT _tx_mutex_put(TX_MUTEX *mutex_ptr);

tx_api.h:1520

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

tx_api.h:1526

UINT _txe_mutex_delete(TX_MUTEX *mutex_ptr);

tx_api.h:1527

UINT _txe_mutex_get(TX_MUTEX *mutex_ptr, ULONG wait_option);

tx_api.h:1528

UINT _txe_mutex_info_get(TX_MUTEX *mutex_ptr, CHAR **name, ULONG *count, TX_THREAD **owner,

tx_api.h:1529

UINT _txe_mutex_prioritize(TX_MUTEX *mutex_ptr);

tx_api.h:1532

UINT _txe_mutex_put(TX_MUTEX *mutex_ptr);

tx_api.h:1533

UINT _tx_queue_create(TX_QUEUE *queue_ptr, CHAR *name_ptr, UINT message_size,

tx_api.h:1548

UINT _tx_queue_delete(TX_QUEUE *queue_ptr);

tx_api.h:1550

UINT _tx_queue_flush(TX_QUEUE *queue_ptr);

tx_api.h:1551

UINT _tx_queue_info_get(TX_QUEUE *queue_ptr, CHAR **name, ULONG *enqueued, ULONG *available_storage,

tx_api.h:1552

UINT _tx_queue_performance_info_get(TX_QUEUE *queue_ptr, ULONG *messages_sent, ULONG *messages_received,

tx_api.h:1554

UINT _tx_queue_performance_system_info_get(ULONG *messages_sent, ULONG *messages_received,

tx_api.h:1556

UINT _tx_queue_prioritize(TX_QUEUE *queue_ptr);

tx_api.h:1558

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

UINT _txe_queue_create(TX_QUEUE *queue_ptr, CHAR *name_ptr, UINT message_size,

tx_api.h:1568

VOID *queue_start, ULONG queue_size, UINT queue_control_block_size);

tx_api.h:1569

_txe_queue_create()::queue_control_block_size

UINT _txe_queue_delete(TX_QUEUE *queue_ptr);

tx_api.h:1570

UINT _txe_queue_flush(TX_QUEUE *queue_ptr);

tx_api.h:1571

_txe_queue_flush()

UINT _txe_queue_info_get(TX_QUEUE *queue_ptr, CHAR **name, ULONG *enqueued, ULONG *available_storage,

tx_api.h:1572

UINT _txe_queue_prioritize(TX_QUEUE *queue_ptr);

tx_api.h:1574

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_ceiling_put(TX_SEMAPHORE *semaphore_ptr, ULONG ceiling);

tx_api.h:1596

UINT _tx_semaphore_create(TX_SEMAPHORE *semaphore_ptr, CHAR *name_ptr, ULONG initial_count);

tx_api.h:1597

UINT _tx_semaphore_delete(TX_SEMAPHORE *semaphore_ptr);

tx_api.h:1598

UINT _tx_semaphore_get(TX_SEMAPHORE *semaphore_ptr, ULONG wait_option);

tx_api.h:1599

UINT _tx_semaphore_info_get(TX_SEMAPHORE *semaphore_ptr, CHAR **name, ULONG *current_value,

tx_api.h:1600

UINT _tx_semaphore_performance_info_get(TX_SEMAPHORE *semaphore_ptr, ULONG *puts, ULONG *gets,

tx_api.h:1603

UINT _tx_semaphore_performance_system_info_get(ULONG *puts, ULONG *gets, ULONG *suspensions, ULONG *timeouts);

tx_api.h:1605

UINT _tx_semaphore_prioritize(TX_SEMAPHORE *semaphore_ptr);

tx_api.h:1606

UINT _tx_semaphore_put(TX_SEMAPHORE *semaphore_ptr);

tx_api.h:1607

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_ceiling_put(TX_SEMAPHORE *semaphore_ptr, ULONG ceiling);

tx_api.h:1614

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

tx_api.h:1615

UINT _txe_semaphore_delete(TX_SEMAPHORE *semaphore_ptr);

tx_api.h:1616

UINT _txe_semaphore_get(TX_SEMAPHORE *semaphore_ptr, ULONG wait_option);

tx_api.h:1617

UINT _txe_semaphore_info_get(TX_SEMAPHORE *semaphore_ptr, CHAR **name, ULONG *current_value,

tx_api.h:1618

UINT _txe_semaphore_prioritize(TX_SEMAPHORE *semaphore_ptr);

tx_api.h:1621

UINT _txe_semaphore_put(TX_SEMAPHORE *semaphore_ptr);

tx_api.h:1622

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

tx_api.h:1623

UINT _tx_thread_create(TX_THREAD *thread_ptr, CHAR *name_ptr,

tx_api.h:1642

UINT priority, UINT preempt_threshold,

tx_api.h:1645

_tx_thread_create()::priority

ULONG time_slice, UINT auto_start);

tx_api.h:1646

_tx_thread_create()::auto_start

UINT _tx_thread_delete(TX_THREAD *thread_ptr);

tx_api.h:1647

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

UINT _tx_thread_info_get(TX_THREAD *thread_ptr, CHAR **name, UINT *state, ULONG *run_count,

tx_api.h:1650

UINT *priority, UINT *preemption_threshold, ULONG *time_slice,

tx_api.h:1651

_tx_thread_info_get()::priority

UINT _tx_thread_interrupt_control(UINT new_posture);

tx_api.h:1653

_tx_thread_interrupt_control()

UINT _tx_thread_performance_info_get(TX_THREAD *thread_ptr, ULONG *resumptions, ULONG *suspensions,

tx_api.h:1654

UINT _tx_thread_performance_system_info_get(ULONG *resumptions, ULONG *suspensions,

tx_api.h:1657

UINT _tx_thread_preemption_change(TX_THREAD *thread_ptr, UINT new_threshold,

tx_api.h:1661

UINT *old_threshold);

tx_api.h:1662

_tx_thread_preemption_change()::old_threshold

UINT _tx_thread_priority_change(TX_THREAD *thread_ptr, UINT new_priority,

tx_api.h:1663

UINT *old_priority);

tx_api.h:1664

_tx_thread_priority_change()::old_priority

UINT _tx_thread_reset(TX_THREAD *thread_ptr);

tx_api.h:1666

UINT _tx_thread_resume(TX_THREAD *thread_ptr);

tx_api.h:1667

UINT _tx_thread_sleep(ULONG timer_ticks);

tx_api.h:1668

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

tx_api.h:1669

UINT _tx_thread_suspend(TX_THREAD *thread_ptr);

tx_api.h:1670

UINT _tx_thread_terminate(TX_THREAD *thread_ptr);

tx_api.h:1671

UINT _tx_thread_time_slice_change(TX_THREAD *thread_ptr, ULONG new_time_slice, ULONG *old_time_slice);

tx_api.h:1672

UINT _tx_thread_wait_abort(TX_THREAD *thread_ptr);

tx_api.h:1673

UINT _txe_thread_create(TX_THREAD *thread_ptr, CHAR *name_ptr,

tx_api.h:1679

UINT priority, UINT preempt_threshold,

tx_api.h:1682

_txe_thread_create()::priority

ULONG time_slice, UINT auto_start, UINT thread_control_block_size);

tx_api.h:1683

_txe_thread_create()::auto_start

UINT _txe_thread_delete(TX_THREAD *thread_ptr);

tx_api.h:1684

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

UINT _txe_thread_info_get(TX_THREAD *thread_ptr, CHAR **name, UINT *state, ULONG *run_count,

tx_api.h:1686

UINT *priority, UINT *preemption_threshold, ULONG *time_slice,

tx_api.h:1687

_txe_thread_info_get()::priority

UINT _txe_thread_preemption_change(TX_THREAD *thread_ptr, UINT new_threshold,

tx_api.h:1689

UINT *old_threshold);

tx_api.h:1690

_txe_thread_preemption_change()::old_threshold

UINT _txe_thread_priority_change(TX_THREAD *thread_ptr, UINT new_priority,

tx_api.h:1691

UINT *old_priority);

tx_api.h:1692

_txe_thread_priority_change()::old_priority

UINT _txe_thread_reset(TX_THREAD *thread_ptr);

tx_api.h:1694

UINT _txe_thread_resume(TX_THREAD *thread_ptr);

tx_api.h:1695

UINT _txe_thread_suspend(TX_THREAD *thread_ptr);

tx_api.h:1696

UINT _txe_thread_terminate(TX_THREAD *thread_ptr);

tx_api.h:1697

UINT _txe_thread_time_slice_change(TX_THREAD *thread_ptr, ULONG new_time_slice, ULONG *old_time_slice);

tx_api.h:1698

UINT _txe_thread_wait_abort(TX_THREAD *thread_ptr);

tx_api.h:1699

UINT _tx_timer_activate(TX_TIMER *timer_ptr);

tx_api.h:1726

UINT _tx_timer_change(TX_TIMER *timer_ptr, ULONG initial_ticks, ULONG reschedule_ticks);

tx_api.h:1727

UINT _tx_timer_create(TX_TIMER *timer_ptr, CHAR *name_ptr,

tx_api.h:1728

ULONG initial_ticks, ULONG reschedule_ticks, UINT auto_activate);

tx_api.h:1730

_tx_timer_create()::auto_activate

UINT _tx_timer_deactivate(TX_TIMER *timer_ptr);

tx_api.h:1731

UINT _tx_timer_delete(TX_TIMER *timer_ptr);

tx_api.h:1732

UINT _tx_timer_info_get(TX_TIMER *timer_ptr, CHAR **name, UINT *active, ULONG *remaining_ticks,

tx_api.h:1733

UINT _tx_timer_performance_info_get(TX_TIMER *timer_ptr, ULONG *activates, ULONG *reactivates,

tx_api.h:1735

UINT _tx_timer_performance_system_info_get(ULONG *activates, ULONG *reactivates,

tx_api.h:1737

UINT _txe_timer_activate(TX_TIMER *timer_ptr);

tx_api.h:1747

UINT _txe_timer_change(TX_TIMER *timer_ptr, ULONG initial_ticks, ULONG reschedule_ticks);

tx_api.h:1748

UINT _txe_timer_create(TX_TIMER *timer_ptr, CHAR *name_ptr,

tx_api.h:1749

ULONG initial_ticks, ULONG reschedule_ticks, UINT auto_activate, UINT timer_control_block_size);

tx_api.h:1751

_txe_timer_create()::auto_activate

UINT _txe_timer_deactivate(TX_TIMER *timer_ptr);

tx_api.h:1752

UINT _txe_timer_delete(TX_TIMER *timer_ptr);

tx_api.h:1753

UINT _txe_timer_info_get(TX_TIMER *timer_ptr, CHAR **name, UINT *active, ULONG *remaining_ticks,

tx_api.h:1754

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

tx_api.h:1771

UINT _tx_trace_event_filter(ULONG event_filter_bits);

tx_api.h:1772

UINT _tx_trace_event_unfilter(ULONG event_unfilter_bits);

tx_api.h:1773

UINT _tx_trace_disable(VOID);

tx_api.h:1774

_tx_trace_disable()

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

tx_api.h:1777

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);

tx_api.h:1778

_tx_trace_interrupt_control()

UINT _tx_trace_interrupt_control(UINT new_posture);

tx_api.h:1779

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

tx_block_allocate.c:80

tx_block_allocate.c:83

UINT status;

tx_block_allocate.c:85

UINT suspended_count;

tx_block_allocate.c:91

if (pool_ptr -> tx_block_pool_available != ((UINT) 0))

tx_block_allocate.c:152

temp_ptr = TX_UCHAR_POINTER_ADD(work_ptr, (sizeof(UCHAR *)));

tx_block_allocate.c:162

status = TX_SUCCESS;

tx_block_allocate.c:202

if (_tx_thread_preempt_disable != ((UINT) 0))

tx_block_allocate.c:219

status = TX_NO_MEMORY;

tx_block_allocate.c:223

if (suspended_count == TX_NO_SUSPENSIONS)

tx_block_allocate.c:269

thread_ptr -> tx_thread_state = TX_BLOCK_MEMORY;

tx_block_allocate.c:291

thread_ptr -> tx_thread_suspending = TX_TRUE;

tx_block_allocate.c:303

status = TX_NO_MEMORY;

tx_block_allocate.c:364

tx_block_pool_cleanup.c:82

tx_block_pool_cleanup.c:86

UINT suspended_count;

tx_block_pool_cleanup.c:116

if (pool_ptr -> tx_block_pool_suspended_count != TX_NO_SUSPENSIONS)

tx_block_pool_cleanup.c:138

if (suspended_count == TX_NO_SUSPENSIONS)

tx_block_pool_cleanup.c:168

if (thread_ptr -> tx_thread_state == TX_BLOCK_MEMORY)

tx_block_pool_cleanup.c:184

thread_ptr -> tx_thread_suspend_status = TX_NO_MEMORY;

tx_block_pool_create.c:77

UINT _tx_block_pool_create(TX_BLOCK_POOL *pool_ptr, CHAR *name_ptr, ULONG block_size,

tx_block_pool_create.c:81

tx_block_pool_create.c:83

UINT blocks;

tx_block_pool_create.c:84

UINT status;

tx_block_pool_create.c:108

pool_ptr -> tx_block_pool_block_size = (UINT) block_size;

tx_block_pool_create.c:114

blocks = ((UINT) 0);

tx_block_pool_create.c:116

next_block_ptr = TX_UCHAR_POINTER_ADD(block_ptr, (block_size + (sizeof(UCHAR *))));

tx_block_pool_create.c:117

while(blocks < (UINT) total_blocks)

tx_block_pool_create.c:131

next_block_ptr = TX_UCHAR_POINTER_ADD(block_ptr, (block_size + (sizeof(UCHAR *))));

tx_block_pool_create.c:139

if (blocks != ((UINT) 0))

tx_block_pool_create.c:143

block_ptr = TX_UCHAR_POINTER_SUB(block_ptr,(block_size + (sizeof(UCHAR *))));

tx_block_pool_create.c:203

status = TX_SUCCESS;

tx_block_pool_create.c:209

status = TX_SIZE_ERROR;

tx_block_pool_delete.c:77

UINT _tx_block_pool_delete(TX_BLOCK_POOL *pool_ptr)

tx_block_pool_delete.c:80

tx_block_pool_delete.c:84

UINT suspended_count;

tx_block_pool_delete.c:142

pool_ptr -> tx_block_pool_suspended_count = TX_NO_SUSPENSIONS;

tx_block_pool_delete.c:149

while (suspended_count != TX_NO_SUSPENSIONS)

tx_block_pool_delete.c:163

thread_ptr -> tx_thread_suspend_status = TX_DELETED;

tx_block_pool_delete.c:207

return(TX_SUCCESS);

tx_block_pool_info_get.c:80

UINT _tx_block_pool_info_get(TX_BLOCK_POOL *pool_ptr, CHAR **name, ULONG *available_blocks,

tx_block_pool_info_get.c:85

tx_block_pool_info_get.c:146

return(TX_SUCCESS);

tx_block_pool_performance_info_get.c:83

UINT _tx_block_pool_performance_info_get(TX_BLOCK_POOL *pool_ptr, ULONG *allocates, ULONG *releases,

tx_block_pool_performance_info_get.c:158

UINT status;

tx_block_pool_performance_info_get.c:166

status = TX_FEATURE_NOT_ENABLED;

tx_block_pool_performance_info_get.c:172

status = TX_FEATURE_NOT_ENABLED;

tx_block_pool_performance_info_get.c:178

status = TX_FEATURE_NOT_ENABLED;

tx_block_pool_performance_info_get.c:184

status = TX_FEATURE_NOT_ENABLED;

tx_block_pool_performance_info_get.c:190

status = TX_FEATURE_NOT_ENABLED;

tx_block_pool_performance_info_get.c:196

status = TX_FEATURE_NOT_ENABLED;

tx_block_pool_performance_system_info_get.c:80

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

tx_block_pool_performance_system_info_get.c:136

UINT status;

tx_block_pool_performance_system_info_get.c:144

status = TX_FEATURE_NOT_ENABLED;

tx_block_pool_performance_system_info_get.c:150

status = TX_FEATURE_NOT_ENABLED;

tx_block_pool_performance_system_info_get.c:156

status = TX_FEATURE_NOT_ENABLED;

tx_block_pool_performance_system_info_get.c:162

status = TX_FEATURE_NOT_ENABLED;

tx_block_pool_performance_system_info_get.c:168

status = TX_FEATURE_NOT_ENABLED;

tx_block_pool_prioritize.c:75

UINT _tx_block_pool_prioritize(TX_BLOCK_POOL *pool_ptr)

tx_block_pool_prioritize.c:78

tx_block_pool_prioritize.c:83

UINT suspended_count;

tx_block_pool_prioritize.c:86

UINT list_changed;

tx_block_pool_prioritize.c:102

if (suspended_count < ((UINT) 2))

tx_block_pool_prioritize.c:110

else if (suspended_count == ((UINT) 2))

tx_block_pool_prioritize.c:144

list_changed = TX_FALSE;

tx_block_pool_prioritize.c:172

list_changed = TX_TRUE;

tx_block_pool_prioritize.c:182

list_changed = TX_TRUE;

tx_block_pool_prioritize.c:187

if (list_changed == TX_FALSE)

tx_block_pool_prioritize.c:207

list_changed = TX_FALSE;

tx_block_pool_prioritize.c:249

return(TX_SUCCESS);

UINT _tx_block_release(VOID *block_ptr)

tx_block_release.c:75

tx_block_release.c:78

UINT suspended_count;

tx_block_release.c:85

work_ptr = TX_UCHAR_POINTER_SUB(work_ptr, (sizeof(UCHAR *)));

tx_block_release.c:96

if (suspended_count == TX_NO_SUSPENSIONS)

tx_block_release.c:129

thread_ptr -> tx_thread_suspend_status = TX_SUCCESS;

tx_block_release.c:164

return(TX_SUCCESS);

tx_block_release.c:204

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

tx_byte_allocate.c:82

tx_byte_allocate.c:85

UINT status;

tx_byte_allocate.c:87

UINT suspended_count;

tx_byte_allocate.c:90

UINT finished;

tx_byte_allocate.c:93

finished = TX_FALSE;

tx_byte_allocate.c:159

finished = TX_TRUE;

tx_byte_allocate.c:186

finished = TX_TRUE;

tx_byte_allocate.c:196

} while (finished == TX_FALSE);

tx_byte_allocate.c:200

status = TX_SUCCESS;

tx_byte_allocate.c:247

if (_tx_thread_preempt_disable != ((UINT) 0))

tx_byte_allocate.c:259

status = TX_NO_MEMORY;

tx_byte_allocate.c:263

if (suspended_count == TX_NO_SUSPENSIONS)

tx_byte_allocate.c:309

thread_ptr -> tx_thread_state = TX_BYTE_MEMORY;

tx_byte_allocate.c:331

thread_ptr -> tx_thread_suspending = TX_TRUE;

tx_byte_allocate.c:343

status = TX_NO_MEMORY;

tx_byte_allocate.c:404

tx_byte_pool_cleanup.c:82

tx_byte_pool_cleanup.c:86

UINT suspended_count;

tx_byte_pool_cleanup.c:116

if (pool_ptr -> tx_byte_pool_suspended_count != TX_NO_SUSPENSIONS)

tx_byte_pool_cleanup.c:136

if (suspended_count == TX_NO_SUSPENSIONS)

tx_byte_pool_cleanup.c:166

if (thread_ptr -> tx_thread_state == TX_BYTE_MEMORY)

tx_byte_pool_cleanup.c:182

thread_ptr -> tx_thread_suspend_status = TX_NO_MEMORY;

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

tx_byte_pool_create.c:79

tx_byte_pool_create.c:112

pool_ptr -> tx_byte_pool_fragments = ((UINT) 2);

tx_byte_pool_create.c:120

block_ptr = TX_UCHAR_POINTER_ADD(block_ptr, pool_size);

tx_byte_pool_create.c:123

block_ptr = TX_UCHAR_POINTER_SUB(block_ptr, (sizeof(ALIGN_TYPE)));

tx_byte_pool_create.c:130

block_ptr = TX_UCHAR_POINTER_SUB(block_ptr, (sizeof(UCHAR *)));

tx_byte_pool_create.c:139

block_ptr = TX_UCHAR_POINTER_ADD(block_ptr, (sizeof(UCHAR *)));

tx_byte_pool_create.c:197

return(TX_SUCCESS);

UINT _tx_byte_pool_delete(TX_BYTE_POOL *pool_ptr)

tx_byte_pool_delete.c:81

tx_byte_pool_delete.c:84

UINT suspended_count;

tx_byte_pool_delete.c:88

tx_byte_pool_delete.c:146

pool_ptr -> tx_byte_pool_suspended_count = TX_NO_SUSPENSIONS;

tx_byte_pool_delete.c:153

while (suspended_count != TX_NO_SUSPENSIONS)

tx_byte_pool_delete.c:167

thread_ptr -> tx_thread_suspend_status = TX_DELETED;

tx_byte_pool_delete.c:211

return(TX_SUCCESS);

tx_byte_pool_info_get.c:80

UINT _tx_byte_pool_info_get(TX_BYTE_POOL *pool_ptr, CHAR **name, ULONG *available_bytes,

tx_byte_pool_info_get.c:85

tx_byte_pool_info_get.c:146

return(TX_SUCCESS);

tx_byte_pool_performance_info_get.c:91

UINT _tx_byte_pool_performance_info_get(TX_BYTE_POOL *pool_ptr, ULONG *allocates, ULONG *releases,

tx_byte_pool_performance_info_get.c:192

UINT status;

tx_byte_pool_performance_info_get.c:200

status = TX_FEATURE_NOT_ENABLED;

tx_byte_pool_performance_info_get.c:206

status = TX_FEATURE_NOT_ENABLED;

tx_byte_pool_performance_info_get.c:212

status = TX_FEATURE_NOT_ENABLED;

tx_byte_pool_performance_info_get.c:218

status = TX_FEATURE_NOT_ENABLED;

tx_byte_pool_performance_info_get.c:224

status = TX_FEATURE_NOT_ENABLED;

tx_byte_pool_performance_info_get.c:230

status = TX_FEATURE_NOT_ENABLED;

tx_byte_pool_performance_info_get.c:236

status = TX_FEATURE_NOT_ENABLED;

tx_byte_pool_performance_info_get.c:242

status = TX_FEATURE_NOT_ENABLED;

tx_byte_pool_performance_info_get.c:248

status = TX_FEATURE_NOT_ENABLED;

tx_byte_pool_performance_system_info_get.c:88

UINT _tx_byte_pool_performance_system_info_get(ULONG *allocates, ULONG *releases,

tx_byte_pool_performance_system_info_get.c:166

UINT status;

tx_byte_pool_performance_system_info_get.c:174

status = TX_FEATURE_NOT_ENABLED;

tx_byte_pool_performance_system_info_get.c:180

status = TX_FEATURE_NOT_ENABLED;

tx_byte_pool_performance_system_info_get.c:186

status = TX_FEATURE_NOT_ENABLED;

tx_byte_pool_performance_system_info_get.c:192

status = TX_FEATURE_NOT_ENABLED;

tx_byte_pool_performance_system_info_get.c:198

status = TX_FEATURE_NOT_ENABLED;

tx_byte_pool_performance_system_info_get.c:204

status = TX_FEATURE_NOT_ENABLED;

tx_byte_pool_performance_system_info_get.c:210

status = TX_FEATURE_NOT_ENABLED;

tx_byte_pool_performance_system_info_get.c:216

status = TX_FEATURE_NOT_ENABLED;

tx_byte_pool_prioritize.c:75

UINT _tx_byte_pool_prioritize(TX_BYTE_POOL *pool_ptr)

tx_byte_pool_prioritize.c:78

tx_byte_pool_prioritize.c:83

UINT suspended_count;

tx_byte_pool_prioritize.c:86

UINT list_changed;

tx_byte_pool_prioritize.c:102

if (suspended_count < ((UINT) 2))

tx_byte_pool_prioritize.c:110

else if (suspended_count == ((UINT) 2))

tx_byte_pool_prioritize.c:144

list_changed = TX_FALSE;

tx_byte_pool_prioritize.c:172

list_changed = TX_TRUE;

tx_byte_pool_prioritize.c:182

list_changed = TX_TRUE;

tx_byte_pool_prioritize.c:187

if (list_changed == TX_FALSE)

tx_byte_pool_prioritize.c:207

list_changed = TX_FALSE;

tx_byte_pool_prioritize.c:249

return(TX_SUCCESS);

tx_byte_pool_search.c:90

UINT examine_blocks;

tx_byte_pool_search.c:97

UINT first_free_block_found = TX_FALSE;

tx_byte_pool_search.c:98

tx_byte_pool_search.c:131

examine_blocks = pool_ptr -> tx_byte_pool_fragments + ((UINT) 1);

tx_byte_pool_search.c:147

work_ptr = TX_UCHAR_POINTER_ADD(current_ptr, (sizeof(UCHAR *)));

tx_byte_pool_search.c:153

if (first_free_block_found == TX_FALSE)

tx_byte_pool_search.c:160

first_free_block_found = TX_TRUE;

tx_byte_pool_search.c:188

work_ptr = TX_UCHAR_POINTER_ADD(next_ptr, (sizeof(UCHAR *)));

tx_byte_pool_search.c:226

if (examine_blocks != ((UINT) 0))

tx_byte_pool_search.c:251

if (examine_blocks != ((UINT) 0))

tx_byte_pool_search.c:270

examine_blocks = pool_ptr -> tx_byte_pool_fragments + ((UINT) 1);

tx_byte_pool_search.c:275

} while(examine_blocks != ((UINT) 0));

tx_byte_pool_search.c:287

next_ptr = TX_UCHAR_POINTER_ADD(current_ptr, (memory_size + ((sizeof(UCHAR *)) + (sizeof(ALIGN_TYPE)))));

tx_byte_pool_search.c:293

work_ptr = TX_UCHAR_POINTER_ADD(next_ptr, (sizeof(UCHAR *)));

tx_byte_pool_search.c:317

work_ptr = TX_UCHAR_POINTER_ADD(current_ptr, (sizeof(UCHAR *)));

tx_byte_pool_search.c:338

current_ptr = TX_UCHAR_POINTER_ADD(current_ptr, (((sizeof(UCHAR *)) + (sizeof(ALIGN_TYPE)))));

UINT _tx_byte_release(VOID *memory_ptr)

tx_byte_release.c:77

UINT status;

UINT suspended_count;

tx_byte_release.c:89

status = TX_SUCCESS;

tx_byte_release.c:100

work_ptr = TX_UCHAR_POINTER_SUB(work_ptr, ((sizeof(UCHAR *)) + (sizeof(ALIGN_TYPE))));

tx_byte_release.c:114

temp_ptr = TX_UCHAR_POINTER_ADD(work_ptr, (sizeof(UCHAR *)));

tx_byte_release.c:117

temp_ptr = TX_UCHAR_POINTER_ADD(work_ptr, (sizeof(UCHAR *)));

tx_byte_release.c:123

status = TX_PTR_ERROR;

tx_byte_release.c:132

status = TX_PTR_ERROR;

tx_byte_release.c:142

status = TX_PTR_ERROR;

tx_byte_release.c:153

status = TX_PTR_ERROR;

tx_byte_release.c:160

temp_ptr = TX_UCHAR_POINTER_ADD(work_ptr, (sizeof(UCHAR *)));

tx_byte_release.c:197

if (pool_ptr -> tx_byte_pool_suspended_count != TX_NO_SUSPENSIONS)

tx_byte_release.c:216

while (pool_ptr -> tx_byte_pool_suspended_count != TX_NO_SUSPENSIONS)

tx_byte_release.c:221

if (suspended_count == TX_NO_SUSPENSIONS)

tx_byte_release.c:270

susp_thread_ptr -> tx_thread_suspend_status = TX_SUCCESS;

tx_byte_release.c:307

work_ptr = TX_UCHAR_POINTER_SUB(work_ptr, (((sizeof(UCHAR *)) + (sizeof(ALIGN_TYPE)))));

tx_byte_release.c:340

temp_ptr = TX_UCHAR_POINTER_ADD(work_ptr, (sizeof(UCHAR *)));

tx_byte_release.c:341

tx_event_flags_cleanup.c:82

tx_event_flags_cleanup.c:86

UINT suspended_count;

tx_event_flags_cleanup.c:117

if (group_ptr -> tx_event_flags_group_suspended_count != TX_NO_SUSPENSIONS)

tx_event_flags_cleanup.c:152

if (suspended_count == TX_NO_SUSPENSIONS)

tx_event_flags_cleanup.c:184

group_ptr -> tx_event_flags_group_reset_search = TX_TRUE;

tx_event_flags_cleanup.c:189

if (thread_ptr -> tx_thread_state == TX_EVENT_FLAG)

tx_event_flags_cleanup.c:205

thread_ptr -> tx_thread_suspend_status = TX_NO_EVENTS;

tx_event_flags_create.c:75

UINT _tx_event_flags_create(TX_EVENT_FLAGS_GROUP *group_ptr, CHAR *name_ptr)

tx_event_flags_create.c:78

tx_event_flags_create.c:141

return(TX_SUCCESS);

tx_event_flags_delete.c:77

UINT _tx_event_flags_delete(TX_EVENT_FLAGS_GROUP *group_ptr)

tx_event_flags_delete.c:80

tx_event_flags_delete.c:84

UINT suspended_count;

tx_event_flags_delete.c:142

group_ptr -> tx_event_flags_group_suspended_count = TX_NO_SUSPENSIONS;

tx_event_flags_delete.c:149

while (suspended_count != TX_NO_SUSPENSIONS)

tx_event_flags_delete.c:163

thread_ptr -> tx_thread_suspend_status = TX_DELETED;

tx_event_flags_delete.c:207

return(TX_SUCCESS);

UINT _tx_event_flags_get(TX_EVENT_FLAGS_GROUP *group_ptr, ULONG requested_flags,

tx_event_flags_get.c:81

UINT get_option, ULONG *actual_flags_ptr, ULONG wait_option)

tx_event_flags_get.c:82

_tx_event_flags_get()::get_option

tx_event_flags_get.c:85

UINT status;

tx_event_flags_get.c:87

UINT and_request;

tx_event_flags_get.c:88

UINT clear_request;

tx_event_flags_get.c:89

UINT suspended_count;

tx_event_flags_get.c:95

UINT interrupted_set_request;

tx_event_flags_get.c:100

and_request = (get_option & TX_AND);

tx_event_flags_get.c:126

if (and_request == TX_AND)

tx_event_flags_get.c:191

clear_request = (get_option & TX_EVENT_FLAGS_CLEAR_MASK);

tx_event_flags_get.c:225

if (clear_request == TX_TRUE)

tx_event_flags_get.c:228

interrupted_set_request = TX_FALSE;

tx_event_flags_get.c:232

if (group_ptr -> tx_event_flags_group_suspended_count != TX_NO_SUSPENSIONS)

tx_event_flags_get.c:236

interrupted_set_request = TX_TRUE;

tx_event_flags_get.c:243

if (interrupted_set_request == TX_TRUE)

tx_event_flags_get.c:248

status = TX_SUCCESS;

tx_event_flags_get.c:268

if (_tx_thread_preempt_disable != ((UINT) 0))

tx_event_flags_get.c:280

status = TX_NO_EVENTS;

tx_event_flags_get.c:284

if (suspended_count == TX_NO_SUSPENSIONS)

tx_event_flags_get.c:330

thread_ptr -> tx_thread_state = TX_EVENT_FLAG;

tx_event_flags_get.c:355

thread_ptr -> tx_thread_suspending = TX_TRUE;

tx_event_flags_get.c:367

status = TX_NO_EVENTS;

tx_event_flags_get.c:393

tx_event_flags_info_get.c:82

UINT _tx_event_flags_info_get(TX_EVENT_FLAGS_GROUP *group_ptr, CHAR **name, ULONG *current_flags,

tx_event_flags_info_get.c:87

tx_event_flags_info_get.c:143

return(TX_SUCCESS);

tx_event_flags_performance_info_get.c:84

UINT _tx_event_flags_performance_info_get(TX_EVENT_FLAGS_GROUP *group_ptr, ULONG *sets, ULONG *gets,

tx_event_flags_performance_info_get.c:159

UINT status;

tx_event_flags_performance_info_get.c:167

status = TX_FEATURE_NOT_ENABLED;

tx_event_flags_performance_info_get.c:173

status = TX_FEATURE_NOT_ENABLED;

tx_event_flags_performance_info_get.c:179

status = TX_FEATURE_NOT_ENABLED;

tx_event_flags_performance_info_get.c:185

status = TX_FEATURE_NOT_ENABLED;

tx_event_flags_performance_info_get.c:191

status = TX_FEATURE_NOT_ENABLED;

tx_event_flags_performance_info_get.c:197

status = TX_FEATURE_NOT_ENABLED;

tx_event_flags_performance_system_info_get.c:81

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

tx_event_flags_performance_system_info_get.c:137

UINT status;

tx_event_flags_performance_system_info_get.c:145

status = TX_FEATURE_NOT_ENABLED;

tx_event_flags_performance_system_info_get.c:151

status = TX_FEATURE_NOT_ENABLED;

tx_event_flags_performance_system_info_get.c:157

status = TX_FEATURE_NOT_ENABLED;

tx_event_flags_performance_system_info_get.c:163

status = TX_FEATURE_NOT_ENABLED;

tx_event_flags_performance_system_info_get.c:169

status = TX_FEATURE_NOT_ENABLED;

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

tx_event_flags_set.c:80

tx_event_flags_set.c:83

UINT suspended_count;

tx_event_flags_set.c:92

UINT and_request;

tx_event_flags_set.c:97

UINT get_option;

tx_event_flags_set.c:98

UINT clear_request;

tx_event_flags_set.c:99

UINT preempt_check;

tx_event_flags_set.c:100

UINT interrupted_set_request;

tx_event_flags_set.c:102

if ((set_option & TX_EVENT_FLAGS_AND_MASK) == TX_AND)

tx_event_flags_set.c:128

interrupted_set_request = TX_FALSE;

tx_event_flags_set.c:134

if (group_ptr -> tx_event_flags_group_suspended_count != TX_NO_SUSPENSIONS)

tx_event_flags_set.c:138

interrupted_set_request = TX_TRUE;

tx_event_flags_set.c:145

if (interrupted_set_request == TX_TRUE)

tx_event_flags_set.c:150

preempt_check = TX_FALSE;

tx_event_flags_set.c:204

if (suspended_count == ((UINT) 1))

tx_event_flags_set.c:215

and_request = (get_option & TX_AND);

tx_event_flags_set.c:234

if (and_request == TX_AND)

tx_event_flags_set.c:237

preempt_check = TX_TRUE;

tx_event_flags_set.c:268

clear_request = (get_option & TX_EVENT_FLAGS_CLEAR_MASK);

tx_event_flags_set.c:275

if (clear_request == TX_TRUE)

tx_event_flags_set.c:278

group_ptr -> tx_event_flags_group_suspended_count = TX_NO_SUSPENSIONS;

tx_event_flags_set.c:287

thread_ptr -> tx_thread_suspend_status = TX_SUCCESS;

tx_event_flags_set.c:293

if (group_ptr -> tx_event_flags_group_reset_search != TX_FALSE)

tx_event_flags_set.c:353

group_ptr -> tx_event_flags_group_reset_search = TX_FALSE;

tx_event_flags_set.c:357

and_request = (get_option & TX_AND);

tx_event_flags_set.c:380

if (and_request == TX_AND)

tx_event_flags_set.c:383

if (thread_ptr -> tx_thread_state != TX_EVENT_FLAG)

tx_event_flags_set.c:409

preempt_check = TX_TRUE;

tx_event_flags_set.c:423

if (thread_ptr -> tx_thread_state == TX_EVENT_FLAG)

tx_event_flags_set.c:427

clear_request = (get_option & TX_EVENT_FLAGS_CLEAR_MASK);

tx_event_flags_set.c:435

if (clear_request == TX_TRUE)

tx_event_flags_set.c:438

thread_ptr -> tx_thread_suspend_status = TX_SUCCESS;

tx_event_flags_set.c:451

} while (suspended_count != TX_NO_SUSPENSIONS);

tx_event_flags_set.c:519

if (group_ptr -> tx_event_flags_group_suspended_count != TX_NO_SUSPENSIONS)

tx_event_flags_set.c:587

group_ptr -> tx_event_flags_group_reset_search = TX_TRUE;

tx_event_flags_set.c:592

if (preempt_check == TX_TRUE)

tx_event_flags_set.c:611

return(TX_SUCCESS);

tx_event_flags_set.c:620

tx_event_flags_set_notify.c:75

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:84

return(TX_FEATURE_NOT_ENABLED);

tx_event_flags_set_notify.c:87

tx_event_flags_set_notify.c:106

return(TX_SUCCESS);

static UINT txfr_idle_stack[configMINIMAL_STACK_SIZE];

tx_freertos.c:49

txfr_idle_stack

static UINT txfr_heap_initialized;

tx_freertos.c:63

txfr_heap_initialized

UINT ret;

tx_freertos.c:72

txfr_malloc()

if(ret != TX_SUCCESS) {

UINT ret;

if(ret != TX_SUCCESS) {

tx_freertos.c:92

txfr_free()

UINT ret;

tx_freertos.c:104

tx_freertos.c:105

if(ret != TX_SUCCESS) {

tx_freertos.c:110

if(ret != TX_SUCCESS) {

tx_freertos.c:129

if(ret != TX_SUCCESS) {

tx_freertos.c:134

UINT tx_freertos_init(void)

UINT ret;

if(ret != TX_SUCCESS) {

tx_freertos.c:189

if(ret != TX_SUCCESS) {

tx_freertos.c:198

txfr_idle_stack, sizeof(txfr_idle_stack), TX_MAX_PRIORITIES - 1u, TX_MAX_PRIORITIES - 1u, 0u, TX_AUTO_START);

tx_freertos.c:203

if(ret != TX_SUCCESS) {

return TX_SUCCESS;

tx_freertos.c:285

vTaskSuspendAll()

UINT prio;

UINT ret;

tx_freertos.c:318

if(ret != TX_SUCCESS) {

tx_freertos.c:337

puxStackBuffer, ulStackDepth, prio, prio, 0u, TX_DONT_START);

tx_freertos.c:345

if(ret != TX_SUCCESS) {

tx_freertos.c:346

if(ret != TX_SUCCESS) {

UINT ret;

UINT prio;

tx_freertos.c:378

if(ret != TX_SUCCESS) {

tx_freertos.c:410

p_stack, usStackDepth, prio, prio, 0u, TX_DONT_START);

tx_freertos.c:420

if(ret != TX_SUCCESS) {

tx_freertos.c:421

if(ret != TX_SUCCESS) {

tx_freertos.c:432

tx_freertos.c:447

uxTaskGetNumberOfTasks()

UINT ret;

tx_freertos.c:459

vTaskDelete()

tx_freertos.c:462

vTaskDelete()

if(ret != TX_SUCCESS) {

tx_freertos.c:480

vTaskDelete()

if(ret != TX_SUCCESS) {

UINT ret;

if(ret != TX_SUCCESS) {

UINT ret;

if(ret != TX_SUCCESS) {

UINT ret;

if(ret != TX_SUCCESS) {

UINT priority;

UINT ret;

if(ret != TX_SUCCESS) {

UINT priority;

UINT old_priority;

UINT ret;

if(ret != TX_SUCCESS) {

UINT ret;

if(ret != TX_SUCCESS) {

UINT thread_state;

case TX_READY:

case TX_COMPLETED:

case TX_TERMINATED:

case TX_SUSPENDED:

case TX_SLEEP:

case TX_QUEUE_SUSP:

case TX_SEMAPHORE_SUSP:

case TX_EVENT_FLAG:

case TX_BLOCK_MEMORY:

case TX_BYTE_MEMORY:

case TX_IO_DRIVER:

case TX_FILE:

case TX_TCP_IP:

case TX_MUTEX_SUSP:

UINT ret;

UINT timeout;

timeout = (UINT)xTicksToWait;

pend = TX_FALSE;

tx_freertos.c:760

ulTaskNotifyTake()

if(ret == TX_SUCCESS) {

pend = TX_TRUE;

if(pend == TX_TRUE) {

tx_freertos.c:782

ulTaskNotifyTake()

if(ret != TX_SUCCESS) {

tx_freertos.c:785

ulTaskNotifyTake()

UINT ret;

UINT timeout;

timeout = (UINT)xTicksToWait;

pend = TX_FALSE;

if(ret == TX_SUCCESS) {

pend = TX_TRUE;

if(pend == TX_TRUE) {

tx_freertos.c:837

xTaskNotifyWait()

if(ret != TX_SUCCESS) {

tx_freertos.c:840

xTaskNotifyWait()

UINT ret;

tx_freertos.c:878

tx_freertos.c:880

waiting = TX_FALSE;

tx_freertos.c:893

notified = TX_FALSE;

tx_freertos.c:894

waiting = TX_TRUE;

tx_freertos.c:898

if(ret != TX_SUCCESS) {

tx_freertos.c:908

notified = TX_TRUE;

tx_freertos.c:915

if(notified == TX_TRUE) {

tx_freertos.c:935

if(waiting == TX_TRUE) {

tx_freertos.c:948

if(xTaskToNotify->clear_on_pend == TX_TRUE) {

tx_freertos.c:951

UINT ret;

tx_freertos.c:983

xTaskNotifyStateClear()

tx_freertos.c:986

xTaskNotifyStateClear()

if(ret != TX_SUCCESS) {

tx_freertos.c:1005

xTaskNotifyStateClear()

xSemaphoreCreateCounting()

tx_freertos.c:1023

ulTaskNotifyValueClear()

UINT ret;

tx_freertos.c:1049

if(ret != TX_SUCCESS) {

tx_freertos.c:1071

xSemaphoreCreateCounting()

UINT ret;

tx_freertos.c:1083

xSemaphoreCreateCountingStatic()

if(ret != TX_SUCCESS) {

tx_freertos.c:1101

xSemaphoreCreateCountingStatic()

UINT ret;

tx_freertos.c:1126

xSemaphoreCreateMutex()

ret = tx_mutex_create(&p_sem->mutex, "", TX_NO_INHERIT);

tx_freertos.c:1144

xSemaphoreCreateMutex()

if(ret != TX_SUCCESS) {

tx_freertos.c:1145

xSemaphoreCreateMutex()

UINT ret;

tx_freertos.c:1156

xSemaphoreCreateMutexStatic()

ret = tx_mutex_create(&pxMutexBuffer->mutex, "", TX_NO_INHERIT);

tx_freertos.c:1165

xSemaphoreCreateMutexStatic()

if(ret != TX_SUCCESS) {

tx_freertos.c:1166

xSemaphoreCreateMutexStatic()

UINT ret;

tx_freertos.c:1177

xSemaphoreCreateRecursiveMutex()

ret = tx_mutex_create(&p_sem->mutex, "", TX_INHERIT);

tx_freertos.c:1195

xSemaphoreCreateRecursiveMutex()

if(ret != TX_SUCCESS) {

tx_freertos.c:1196

xSemaphoreCreateRecursiveMutex()

UINT ret;

tx_freertos.c:1207

xSemaphoreCreateRecursiveMutexStatic()

ret = tx_mutex_create(&pxMutexBuffer->mutex, "", TX_INHERIT);

tx_freertos.c:1222

xSemaphoreCreateRecursiveMutexStatic()

if(ret != TX_SUCCESS) {

tx_freertos.c:1223

xSemaphoreCreateRecursiveMutexStatic()

UINT ret;

tx_freertos.c:1232

vSemaphoreDelete()

if(ret != TX_SUCCESS) {

UINT timeout;

UINT ret;

timeout = (UINT)xTicksToWait;

tx_freertos.c:1263

xSemaphoreTake()

if(ret != TX_SUCCESS) {

tx_freertos.c:1271

xSemaphoreTake()

if(ret != TX_SUCCESS) {

tx_freertos.c:1276

xSemaphoreTake()

UINT ret;

tx_freertos.c:1287

xSemaphoreTakeFromISR()

if(ret != TX_SUCCESS) {

tx_freertos.c:1295

xSemaphoreTakeFromISR()

UINT timeout;

tx_freertos.c:1306

UINT ret;

tx_freertos.c:1307

timeout = (UINT)xTicksToWait;

tx_freertos.c:1314

if(ret != TX_SUCCESS) {

tx_freertos.c:1319

if(ret != TX_SUCCESS) {

tx_freertos.c:1324

UINT ret;

if(ret != TX_SUCCESS) {

tx_freertos.c:1342

xSemaphoreGive()

if(ret != TX_SUCCESS) {

tx_freertos.c:1360

xSemaphoreGive()

if((ret != TX_SUCCESS) && (ret != TX_QUEUE_FULL)) {

tx_freertos.c:1369

xSemaphoreGive()

UINT ret;

tx_freertos.c:1404

uxSemaphoreGetCount()

if(ret != TX_SUCCESS) {

tx_freertos.c:1410

uxSemaphoreGetCount()

UINT ret;

tx_freertos.c:1448

xQueueCreateStatic()

if(ret != TX_SUCCESS) {

tx_freertos.c:1473

xQueueCreateStatic()

if(ret != TX_SUCCESS) {

UINT ret;

if(ret != TX_SUCCESS) {

tx_freertos.c:1527

xQueueCreate()

if(ret != TX_SUCCESS) {

UINT ret;

if(ret != TX_SUCCESS) {

tx_freertos.c:1546

vQueueDelete()

if(ret != TX_SUCCESS) {

tx_freertos.c:1551

vQueueDelete()

UINT timeout;

UINT ret;

timeout = (UINT)xTicksToWait;

tx_freertos.c:1575

if(ret != TX_SUCCESS) {

tx_freertos.c:1580

if(ret != TX_SUCCESS) {

tx_freertos.c:1596

if((ret != TX_SUCCESS) && (ret != TX_QUEUE_FULL)) {

tx_freertos.c:1604

UINT timeout;

UINT ret;

timeout = (UINT)xTicksToWait;

tx_freertos.c:1660

if(ret != TX_SUCCESS) {

tx_freertos.c:1670

if(ret != TX_SUCCESS) {

tx_freertos.c:1688

if((ret != TX_SUCCESS) && (ret != TX_QUEUE_FULL)) {

tx_freertos.c:1700

UINT timeout;

UINT ret;

timeout = (UINT)xTicksToWait;

tx_freertos.c:1741

xQueueReceive()

if(ret != TX_SUCCESS) {

tx_freertos.c:1746

xQueueReceive()

if(ret != TX_SUCCESS) {

tx_freertos.c:1762

xQueueReceive()

xQueueIsQueueEmptyFromISR()

UINT timeout;

UINT ret;

timeout = (UINT)xTicksToWait;

tx_freertos.c:1798

xQueuePeek()

if(ret != TX_SUCCESS) {

tx_freertos.c:1803

xQueuePeek()

if(ret != TX_SUCCESS) {

tx_freertos.c:1815

xQueuePeek()

UINT ret;

tx_freertos.c:1838

uxQueueMessagesWaiting()

if(ret != TX_SUCCESS) {

tx_freertos.c:1843

uxQueueMessagesWaiting()

UINT ret;

tx_freertos.c:1861

uxQueueSpacesAvailable()

if(ret != TX_SUCCESS) {

tx_freertos.c:1866

uxQueueSpacesAvailable()

UINT ret;

tx_freertos.c:1877

if(ret != TX_SUCCESS) {

tx_freertos.c:1882

xQueueIsQueueEmptyFromISR()

UINT ret;

tx_freertos.c:1897

xQueueIsQueueFullFromISR()

if(ret != TX_SUCCESS) {

tx_freertos.c:1902

xQueueIsQueueFullFromISR()

UINT ret;

UINT write_post;

if(ret != TX_SUCCESS) {

tx_freertos.c:1946

xQueueReset()

xEventGroupCreateStatic()

UINT ret;

UINT read_post;

if(ret != TX_SUCCESS) {

UINT ret;

if(ret != TX_SUCCESS) {

tx_freertos.c:2038

xEventGroupCreate()

UINT ret;

tx_freertos.c:2048

if(ret != TX_SUCCESS) {

tx_freertos.c:2062

xEventGroupCreateStatic()

UINT ret;

tx_freertos.c:2071

vEventGroupDelete()

if(ret != TX_SUCCESS) {

tx_freertos.c:2076

vEventGroupDelete()

UINT timeout;

tx_freertos.c:2093

UINT ret;

tx_freertos.c:2094

UINT get_option;

tx_freertos.c:2095

timeout = (UINT)xTicksToWait;

tx_freertos.c:2102

get_option = TX_OR;

tx_freertos.c:2107

get_option = TX_OR_CLEAR;

tx_freertos.c:2109

get_option = TX_AND;

tx_freertos.c:2113

get_option = TX_AND_CLEAR;

tx_freertos.c:2115

if(ret != TX_SUCCESS) {

tx_freertos.c:2120

UINT ret;

tx_freertos.c:2130

ret = tx_event_flags_set(&xEventGroup->event, uxBitsToSet, TX_OR);

tx_freertos.c:2135

if(ret != TX_SUCCESS) {

tx_freertos.c:2136

if(ret != TX_SUCCESS) {

tx_freertos.c:2142

UINT ret;

tx_freertos.c:2162

tx_freertos.c:2165

if(ret != TX_SUCCESS) {

tx_freertos.c:2172

ret = tx_event_flags_set(&xEventGroup->event, ~bits, TX_AND);

tx_freertos.c:2179

if(ret != TX_SUCCESS) {

tx_freertos.c:2180

UINT ret;

tx_freertos.c:2201

xEventGroupGetBits()

if(ret != TX_SUCCESS) {

UINT ret;

ret = tx_timer_create(&p_timer->timer, (char *)pcTimerName, txfr_timer_callback_wrapper, (ULONG)p_timer, xTimerPeriod, resch_ticks, TX_NO_ACTIVATE);

tx_freertos.c:2276

xTimerCreate()

if(ret != TX_SUCCESS) {

UINT ret;

ret = tx_timer_create(&pxTimerBuffer->timer, (char *)pcTimerName, txfr_timer_callback_wrapper, (ULONG)pxTimerBuffer, xTimerPeriod, resch_ticks, TX_NO_ACTIVATE);

tx_freertos.c:2317

xTimerCreateStatic()

if(ret != TX_SUCCESS) {

UINT ret;

if(ret != TX_SUCCESS) {

tx_freertos.c:2333

xTimerDelete()

UINT ret;

tx_freertos.c:2348

UINT is_active;

tx_freertos.c:2349

if(ret != TX_SUCCESS) {

tx_freertos.c:2354

if(is_active == TX_TRUE) {

tx_freertos.c:2358

UINT ret;

tx_freertos.c:2369

xTimerStart()

if(ret != TX_SUCCESS) {

UINT ret;

if(ret != TX_SUCCESS) {

UINT ret;

tx_freertos.c:2403

xTimerChangePeriod()

if(ret != TX_SUCCESS) {

tx_freertos.c:2411

xTimerChangePeriod()

if(ret != TX_SUCCESS) {

tx_freertos.c:2421

xTimerChangePeriod()

if(ret != TX_SUCCESS) {

UINT ret;

tx_freertos.c:2442

if(ret != TX_SUCCESS) {

tx_freertos.c:2449

if(ret != TX_SUCCESS) {

tx_freertos.c:2459

if(ret != TX_SUCCESS) {

tx_freertos.c:2465

tx_freertos.c:2516

pvTimerGetTimerID()

tx_freertos.c:2530

vTimerSetTimerID()

UINT ret;

tx_freertos.c:2544

tx_freertos.c:2545

if(ret != TX_SUCCESS) {

tx_freertos.c:2553

if(ret != TX_SUCCESS) {

tx_freertos.c:2565

if(ret != TX_SUCCESS) {

tx_freertos.c:2571

tx_freertos.c:2592

xTimerGetPeriod()

tx_freertos.c:2609

xTimerGetExpiryTime()

UINT ret;

tx_freertos.c:2612

xTimerGetExpiryTime()

if(ret != TX_SUCCESS) {

tx_freertos.c:2619

xTimerGetExpiryTime()

tx_freertos.c:2634

uxTimerGetReloadMode()

UINT ret;

tx_freertos.c:2658

xQueueCreateSet()

ret = tx_queue_create(&p_set->queue, "", sizeof(void *) / sizeof(UINT), p_mem, queue_size);

tx_freertos.c:2680

xQueueCreateSet()

if(ret != TX_SUCCESS) {

tx_freertos.c:2681

xQueueCreateSet()

tx_freertos.c:2695

xQueueAddToSet()

tx_freertos.c:2736

xQueueRemoveFromSet()

UINT ret;

tx_freertos.c:2779

UINT timeout;

tx_freertos.c:2780

timeout = (UINT)xTicksToWait;

tx_freertos.c:2787

if(ret != TX_SUCCESS) {

tx_freertos.c:2791

UINT tx_low_power_entered;

tx_low_power.c:36

tx_low_power_entered

tx_low_power.c:88

tx_low_power_enter()

tx_low_power_entered = TX_TRUE;

tx_low_power.c:149

tx_low_power_enter()

tx_low_power_entered = TX_FALSE;

tx_low_power.c:219

tx_low_power_exit()

UINT i;

for (i = (UINT)0; i < TX_TIMER_ENTRIES; i++)

return(TX_TRUE);

return(TX_FALSE);

UINT i;

VOID _tx_mutex_priority_change(TX_THREAD *thread_ptr, UINT new_priority);

tx_mutex.h:94

_tx_mutex_priority_change()::new_priority

tx_mutex_cleanup.c:82

UINT suspended_count;

tx_mutex_cleanup.c:86

if (mutex_ptr -> tx_mutex_suspended_count != TX_NO_SUSPENSIONS)

tx_mutex_cleanup.c:116

if (suspended_count == TX_NO_SUSPENSIONS)

tx_mutex_cleanup.c:138

if (thread_ptr -> tx_thread_state == TX_MUTEX_SUSP)

tx_mutex_cleanup.c:168

thread_ptr -> tx_thread_suspend_status = TX_NOT_AVAILABLE;

tx_mutex_cleanup.c:184

_tx_mutex_thread_release()

tx_mutex_cleanup.c:262

mutex_ptr -> tx_mutex_ownership_count = ((UINT) 1);

tx_mutex_cleanup.c:288

_tx_mutex_thread_release()

UINT _tx_mutex_create(TX_MUTEX *mutex_ptr, CHAR *name_ptr, UINT inherit)

tx_mutex_create.c:76

tx_mutex_create.c:79

return(TX_SUCCESS);

tx_mutex_create.c:146

UINT _tx_mutex_delete(TX_MUTEX *mutex_ptr)

tx_mutex_delete.c:78

tx_mutex_delete.c:81

UINT suspended_count;

tx_mutex_delete.c:86

mutex_ptr -> tx_mutex_suspended_count = TX_NO_SUSPENSIONS;

tx_mutex_delete.c:146

mutex_ptr -> tx_mutex_ownership_count = ((UINT) 1);

tx_mutex_delete.c:161

thread_ptr -> tx_thread_suspend_status = TX_DELETED;

tx_mutex_delete.c:199

return(TX_SUCCESS);

tx_mutex_delete.c:243

UINT _tx_mutex_get(TX_MUTEX *mutex_ptr, ULONG wait_option)

tx_mutex_get.c:77

UINT status;

if (mutex_ptr -> tx_mutex_ownership_count == ((UINT) 0))

tx_mutex_get.c:113

mutex_ptr -> tx_mutex_ownership_count = ((UINT) 1);

tx_mutex_get.c:117

tx_mutex_get.c:127

mutex_ptr -> tx_mutex_highest_priority_waiting = ((UINT) TX_MAX_PRIORITIES);

status = TX_SUCCESS;

status = TX_SUCCESS;

if (_tx_thread_preempt_disable != ((UINT) 0))

tx_mutex_get.c:199

status = TX_NOT_AVAILABLE;

tx_mutex_get.c:206

if (mutex_ptr -> tx_mutex_suspended_count == TX_NO_SUSPENSIONS)

tx_mutex_get.c:262

thread_ptr -> tx_thread_state = TX_MUTEX_SUSP;

tx_mutex_get.c:287

thread_ptr -> tx_thread_suspending = TX_TRUE;

tx_mutex_get.c:339

tx_mutex_get.c:352

status = TX_NOT_AVAILABLE;

tx_mutex_get.c:404

UINT _tx_mutex_info_get(TX_MUTEX *mutex_ptr, CHAR **name, ULONG *count, TX_THREAD **owner,

tx_mutex_info_get.c:81

tx_mutex_info_get.c:86

return(TX_SUCCESS);

tx_mutex_info_get.c:147

tx_mutex_performance_info_get.c:86

UINT _tx_mutex_performance_info_get(TX_MUTEX *mutex_ptr, ULONG *puts, ULONG *gets,

tx_mutex_performance_info_get.c:175

UINT status;

tx_mutex_performance_info_get.c:183

status = TX_FEATURE_NOT_ENABLED;

tx_mutex_performance_info_get.c:189

status = TX_FEATURE_NOT_ENABLED;

tx_mutex_performance_info_get.c:195

status = TX_FEATURE_NOT_ENABLED;

tx_mutex_performance_info_get.c:201

status = TX_FEATURE_NOT_ENABLED;

tx_mutex_performance_info_get.c:207

status = TX_FEATURE_NOT_ENABLED;

tx_mutex_performance_info_get.c:213

status = TX_FEATURE_NOT_ENABLED;

tx_mutex_performance_info_get.c:219

status = TX_FEATURE_NOT_ENABLED;

tx_mutex_performance_info_get.c:225

status = TX_FEATURE_NOT_ENABLED;

tx_mutex_performance_system_info_get.c:85

UINT _tx_mutex_performance_system_info_get(ULONG *puts, ULONG *gets, ULONG *suspensions,

tx_mutex_performance_system_info_get.c:156

UINT status;

tx_mutex_performance_system_info_get.c:164

status = TX_FEATURE_NOT_ENABLED;

tx_mutex_performance_system_info_get.c:170

status = TX_FEATURE_NOT_ENABLED;

tx_mutex_performance_system_info_get.c:176

status = TX_FEATURE_NOT_ENABLED;

tx_mutex_performance_system_info_get.c:182

status = TX_FEATURE_NOT_ENABLED;

tx_mutex_performance_system_info_get.c:188

status = TX_FEATURE_NOT_ENABLED;

tx_mutex_performance_system_info_get.c:194

status = TX_FEATURE_NOT_ENABLED;

tx_mutex_performance_system_info_get.c:200

status = TX_FEATURE_NOT_ENABLED;

UINT _tx_mutex_prioritize(TX_MUTEX *mutex_ptr)

tx_mutex_prioritize.c:75

tx_mutex_prioritize.c:78

UINT suspended_count;

tx_mutex_prioritize.c:83

UINT list_changed;

tx_mutex_prioritize.c:86

tx_mutex_prioritize.c:105

if (suspended_count < ((UINT) 2))

tx_mutex_prioritize.c:113

else if (suspended_count == ((UINT) 2))

tx_mutex_prioritize.c:147

list_changed = TX_FALSE;

tx_mutex_prioritize.c:175

list_changed = TX_TRUE;

tx_mutex_prioritize.c:185

list_changed = TX_TRUE;

tx_mutex_prioritize.c:190

if (list_changed == TX_FALSE)

tx_mutex_prioritize.c:210

list_changed = TX_FALSE;

tx_mutex_prioritize.c:264

return(TX_SUCCESS);

tx_mutex_priority_change.c:87

VOID _tx_mutex_priority_change(TX_THREAD *thread_ptr, UINT new_priority)

_tx_mutex_priority_change()::new_priority

tx_mutex_priority_change.c:92

tx_mutex_priority_change.c:97

UINT original_priority;

tx_mutex_priority_change.c:114

if (thread_ptr -> tx_thread_state != TX_READY)

tx_mutex_priority_change.c:187

_tx_thread_preempt_disable = _tx_thread_preempt_disable + ((UINT) 2);

tx_mutex_priority_change.c:190

thread_ptr -> tx_thread_state = TX_PRIORITY_CHANGE;

tx_mutex_priority_change.c:193

tx_mutex_priority_change.c:252

UINT _tx_mutex_put(TX_MUTEX *mutex_ptr)

tx_mutex_put.c:80

UINT old_priority;

UINT status;

UINT owned_count;

UINT suspended_count;

tx_mutex_put.c:92

UINT inheritance_priority;

tx_mutex_put.c:97

status = TX_NOT_DONE;

tx_mutex_put.c:101

if (mutex_ptr -> tx_mutex_ownership_count != ((UINT) 0))

tx_mutex_put.c:122

if (_tx_thread_preempt_disable == ((UINT) 0))

tx_mutex_put.c:138

status = TX_NOT_OWNED;

tx_mutex_put.c:147

if (status == TX_NOT_DONE)

tx_mutex_put.c:152

if (mutex_ptr -> tx_mutex_ownership_count != ((UINT) 0))

status = TX_SUCCESS;

status = TX_SUCCESS;

if (thread_ptr -> tx_thread_owned_mutex_count == ((UINT) 0))

tx_mutex_put.c:192

if (mutex_ptr -> tx_mutex_inherit == TX_FALSE)

status = TX_SUCCESS;

if (status == TX_NOT_DONE)

tx_mutex_put.c:238

tx_mutex_put.c:246

inheritance_priority = ((UINT) TX_MAX_PRIORITIES);

tx_mutex_put.c:259

if (next_mutex -> tx_mutex_inherit == TX_TRUE)

tx_mutex_put.c:268

if (mutex_ptr -> tx_mutex_suspended_count > ((UINT) 1))

tx_mutex_put.c:316

tx_mutex_put.c:320

mutex_ptr -> tx_mutex_highest_priority_waiting = (UINT) TX_MAX_PRIORITIES;

status = TX_SUCCESS;

tx_mutex_put.c:422

mutex_ptr -> tx_mutex_highest_priority_waiting = (UINT) TX_MAX_PRIORITIES;

tx_mutex_put.c:432

if (owned_count == ((UINT) 0))

tx_mutex_put.c:439

thread_ptr -> tx_thread_owned_mutex_count = owned_count + ((UINT) 1);

tx_mutex_put.c:466

mutex_ptr -> tx_mutex_ownership_count = (UINT) 1;

tx_mutex_put.c:469

if (suspended_count == TX_NO_SUSPENSIONS)

tx_mutex_put.c:481

thread_ptr -> tx_thread_suspend_status = TX_SUCCESS;

tx_mutex_put.c:510

tx_mutex_put.c:578

if (mutex_ptr -> tx_mutex_suspended_count != TX_NO_SUSPENSIONS)

status = TX_SUCCESS;

status = TX_NOT_OWNED;

tx_mutex_put.c:650

tx_queue_cleanup.c:82

UINT suspended_count;

tx_queue_cleanup.c:86

if (queue_ptr -> tx_queue_suspended_count != TX_NO_SUSPENSIONS)

tx_queue_cleanup.c:116

if (suspended_count == TX_NO_SUSPENSIONS)

tx_queue_cleanup.c:138

if (thread_ptr -> tx_thread_state == TX_QUEUE_SUSP)

tx_queue_cleanup.c:168

if (queue_ptr -> tx_queue_enqueued != TX_NO_MESSAGES)

tx_queue_cleanup.c:184

thread_ptr -> tx_thread_suspend_status = TX_QUEUE_FULL;

tx_queue_cleanup.c:188

thread_ptr -> tx_thread_suspend_status = TX_QUEUE_EMPTY;

tx_queue_cleanup.c:194

UINT _tx_queue_create(TX_QUEUE *queue_ptr, CHAR *name_ptr, UINT message_size,

tx_queue_create.c:77

UINT capacity;

UINT used_words;

capacity = (UINT) (queue_size / ((ULONG) (((ULONG) message_size) * (sizeof(ULONG)))));

tx_queue_create.c:100

queue_ptr -> tx_queue_end = TX_ULONG_POINTER_ADD(queue_ptr -> tx_queue_start, used_words);

tx_queue_create.c:107

queue_ptr -> tx_queue_available_storage = (UINT) capacity;

tx_queue_create.c:116

queue_ptr -> tx_queue_capacity = (UINT) capacity;

tx_queue_create.c:117

return(TX_SUCCESS);

tx_queue_create.c:170

UINT _tx_queue_delete(TX_QUEUE *queue_ptr)

tx_queue_delete.c:76

tx_queue_delete.c:79

UINT suspended_count;

tx_queue_delete.c:83

queue_ptr -> tx_queue_suspended_count = TX_NO_SUSPENSIONS;

tx_queue_delete.c:141

while (suspended_count != TX_NO_SUSPENSIONS)

tx_queue_delete.c:148

thread_ptr -> tx_thread_suspend_status = TX_DELETED;

tx_queue_delete.c:162

return(TX_SUCCESS);

tx_queue_delete.c:206

UINT _tx_queue_flush(TX_QUEUE *queue_ptr)

tx_queue_flush.c:77

tx_queue_flush.c:80

UINT suspended_count;

tx_queue_flush.c:83

suspended_count = TX_NO_SUSPENSIONS;

tx_queue_flush.c:88

if (queue_ptr -> tx_queue_enqueued != TX_NO_MESSAGES)

tx_queue_flush.c:101

queue_ptr -> tx_queue_enqueued = TX_NO_MESSAGES;

tx_queue_flush.c:107

if (queue_ptr -> tx_queue_suspended_count != TX_NO_SUSPENSIONS)

tx_queue_flush.c:113

queue_ptr -> tx_queue_suspended_count = TX_NO_SUSPENSIONS;

tx_queue_flush.c:125

if (suspended_count != TX_NO_SUSPENSIONS)

tx_queue_flush.c:137

thread_ptr -> tx_thread_suspend_status = TX_SUCCESS;

return(TX_SUCCESS);

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

tx_queue_front_send.c:80

tx_queue_front_send.c:83

UINT size;

tx_queue_front_send.c:88

UINT suspended_count;

tx_queue_front_send.c:89

UINT status;

tx_queue_front_send.c:92

status = TX_SUCCESS;

tx_queue_front_send.c:99

tx_queue_front_send.c:123

if (queue_ptr -> tx_queue_available_storage != ((UINT) 0))

tx_queue_front_send.c:128

if (suspended_count == TX_NO_SUSPENSIONS)

tx_queue_front_send.c:143

queue_ptr -> tx_queue_read = TX_ULONG_POINTER_SUB(queue_ptr -> tx_queue_end, queue_ptr -> tx_queue_message_size);

tx_queue_front_send.c:149

queue_ptr -> tx_queue_read = TX_ULONG_POINTER_SUB(queue_ptr -> tx_queue_read, queue_ptr -> tx_queue_message_size);

tx_queue_front_send.c:167

TX_QUEUE_MESSAGE_COPY(source, destination, size)

tx_queue_front_send.c:198

if (suspended_count == TX_NO_SUSPENSIONS)

tx_queue_front_send.c:246

TX_QUEUE_MESSAGE_COPY(source, destination, size)

tx_queue_front_send.c:249

thread_ptr -> tx_thread_suspend_status = TX_SUCCESS;

tx_queue_front_send.c:288

if (_tx_thread_preempt_disable != ((UINT) 0))

tx_queue_front_send.c:295

status = TX_QUEUE_FULL;

tx_queue_front_send.c:316

thread_ptr -> tx_thread_suspend_option = TX_TRUE;

tx_queue_front_send.c:327

if (suspended_count == TX_NO_SUSPENSIONS)

tx_queue_front_send.c:354

queue_ptr -> tx_queue_suspended_count = suspended_count + ((UINT) 1);

tx_queue_front_send.c:357

thread_ptr -> tx_thread_state = TX_QUEUE_SUSP;

tx_queue_front_send.c:375

thread_ptr -> tx_thread_suspending = TX_TRUE;

tx_queue_front_send.c:393

if (thread_ptr -> tx_thread_suspend_status == TX_SUCCESS)

tx_queue_front_send.c:417

status = TX_QUEUE_FULL;

UINT _tx_queue_info_get(TX_QUEUE *queue_ptr, CHAR **name, ULONG *enqueued, ULONG *available_storage,

tx_queue_info_get.c:80

tx_queue_info_get.c:84

return(TX_SUCCESS);

tx_queue_info_get.c:145

tx_queue_performance_info_get.c:85

UINT _tx_queue_performance_info_get(TX_QUEUE *queue_ptr, ULONG *messages_sent, ULONG *messages_received,

tx_queue_performance_info_get.c:174

UINT status;

tx_queue_performance_info_get.c:182

status = TX_FEATURE_NOT_ENABLED;

tx_queue_performance_info_get.c:188

status = TX_FEATURE_NOT_ENABLED;

tx_queue_performance_info_get.c:194

status = TX_FEATURE_NOT_ENABLED;

tx_queue_performance_info_get.c:200

status = TX_FEATURE_NOT_ENABLED;

tx_queue_performance_info_get.c:206

status = TX_FEATURE_NOT_ENABLED;

tx_queue_performance_info_get.c:212

status = TX_FEATURE_NOT_ENABLED;

tx_queue_performance_info_get.c:218

status = TX_FEATURE_NOT_ENABLED;

tx_queue_performance_info_get.c:224

status = TX_FEATURE_NOT_ENABLED;

tx_queue_performance_system_info_get.c:85

UINT _tx_queue_performance_system_info_get(ULONG *messages_sent, ULONG *messages_received,

tx_queue_performance_system_info_get.c:156

UINT status;

tx_queue_performance_system_info_get.c:164

status = TX_FEATURE_NOT_ENABLED;

tx_queue_performance_system_info_get.c:170

status = TX_FEATURE_NOT_ENABLED;

tx_queue_performance_system_info_get.c:176

status = TX_FEATURE_NOT_ENABLED;

tx_queue_performance_system_info_get.c:182

status = TX_FEATURE_NOT_ENABLED;

tx_queue_performance_system_info_get.c:188

status = TX_FEATURE_NOT_ENABLED;

tx_queue_performance_system_info_get.c:194

status = TX_FEATURE_NOT_ENABLED;

tx_queue_performance_system_info_get.c:200

status = TX_FEATURE_NOT_ENABLED;

UINT _tx_queue_prioritize(TX_QUEUE *queue_ptr)

tx_queue_prioritize.c:75

tx_queue_prioritize.c:78

UINT suspended_count;

tx_queue_prioritize.c:83

UINT list_changed;

tx_queue_prioritize.c:86

tx_queue_prioritize.c:102

if (suspended_count < ((UINT) 2))

tx_queue_prioritize.c:110

else if (suspended_count == ((UINT) 2))

tx_queue_prioritize.c:144

list_changed = TX_FALSE;

tx_queue_prioritize.c:172

list_changed = TX_TRUE;

tx_queue_prioritize.c:182

list_changed = TX_TRUE;

tx_queue_prioritize.c:187

if (list_changed == TX_FALSE)

tx_queue_prioritize.c:207

list_changed = TX_FALSE;

tx_queue_prioritize.c:249

return(TX_SUCCESS);

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

tx_queue_receive.c:82

tx_queue_receive.c:85

UINT size;

tx_queue_receive.c:90

UINT suspended_count;

tx_queue_receive.c:91

UINT status;

tx_queue_receive.c:94

status = TX_SUCCESS;

tx_queue_receive.c:98

if (queue_ptr -> tx_queue_enqueued != TX_NO_MESSAGES)

tx_queue_receive.c:123

if (suspended_count == TX_NO_SUSPENSIONS)

tx_queue_receive.c:127

TX_QUEUE_MESSAGE_COPY(source, destination, size)

tx_queue_receive.c:139

if (thread_ptr -> tx_thread_suspend_option == TX_TRUE)

tx_queue_receive.c:172

TX_QUEUE_MESSAGE_COPY(source, destination, size)

tx_queue_receive.c:186

if (suspended_count == TX_NO_SUSPENSIONS)

tx_queue_receive.c:191

thread_ptr -> tx_thread_suspend_status = TX_SUCCESS;

tx_queue_receive.c:223

TX_QUEUE_MESSAGE_COPY(source, destination, size)

tx_queue_receive.c:258

TX_QUEUE_MESSAGE_COPY(source, destination, size)

tx_queue_receive.c:296

if (suspended_count == TX_NO_SUSPENSIONS)

tx_queue_receive.c:315

thread_ptr -> tx_thread_suspend_status = TX_SUCCESS;

tx_queue_receive.c:347

if (_tx_thread_preempt_disable != ((UINT) 0))

tx_queue_receive.c:376

status = TX_QUEUE_EMPTY;

tx_queue_receive.c:383

thread_ptr -> tx_thread_suspend_option = TX_FALSE;

tx_queue_receive.c:409

if (suspended_count == TX_NO_SUSPENSIONS)

tx_queue_receive.c:419

queue_ptr -> tx_queue_suspended_count = suspended_count + ((UINT) 1);

tx_queue_receive.c:441

thread_ptr -> tx_thread_state = TX_QUEUE_SUSP;

tx_queue_receive.c:444

thread_ptr -> tx_thread_suspending = TX_TRUE;

tx_queue_receive.c:456

status = TX_QUEUE_EMPTY;

tx_queue_receive.c:482

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

tx_queue_send.c:80

UINT size;

UINT suspended_count;

UINT status;

status = TX_SUCCESS;

if (queue_ptr -> tx_queue_available_storage != TX_NO_MESSAGES)

tx_queue_send.c:123

if (suspended_count == TX_NO_SUSPENSIONS)

tx_queue_send.c:129

TX_QUEUE_MESSAGE_COPY(source, destination, size)

tx_queue_send.c:147

if (suspended_count == TX_NO_SUSPENSIONS)

tx_queue_send.c:194

TX_QUEUE_MESSAGE_COPY(source, destination, size)

tx_queue_send.c:235

thread_ptr -> tx_thread_suspend_status = TX_SUCCESS;

tx_queue_send.c:238

if (_tx_thread_preempt_disable != ((UINT) 0))

tx_queue_send.c:283

status = TX_QUEUE_FULL;

tx_queue_send.c:290

thread_ptr -> tx_thread_suspend_option = TX_FALSE;

tx_queue_send.c:316

if (suspended_count == TX_NO_SUSPENSIONS)

tx_queue_send.c:326

queue_ptr -> tx_queue_suspended_count = suspended_count + ((UINT) 1);

tx_queue_send.c:348

thread_ptr -> tx_thread_state = TX_QUEUE_SUSP;

tx_queue_send.c:351

thread_ptr -> tx_thread_suspending = TX_TRUE;

tx_queue_send.c:369

if (thread_ptr -> tx_thread_suspend_status == TX_SUCCESS)

tx_queue_send.c:387

status = TX_QUEUE_FULL;

tx_queue_send.c:422

tx_queue_send_notify.c:75

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

tx_queue_send_notify.c:84

return(TX_FEATURE_NOT_ENABLED);

tx_queue_send_notify.c:87

tx_queue_send_notify.c:106

return(TX_SUCCESS);

tx_semaphore_ceiling_put.c:77

UINT _tx_semaphore_ceiling_put(TX_SEMAPHORE *semaphore_ptr, ULONG ceiling)

tx_semaphore_ceiling_put.c:80

tx_semaphore_ceiling_put.c:87

UINT suspended_count;

tx_semaphore_ceiling_put.c:90

UINT status;

tx_semaphore_ceiling_put.c:94

status = TX_SUCCESS;

tx_semaphore_ceiling_put.c:118

if (suspended_count == TX_NO_SUSPENSIONS)

tx_semaphore_ceiling_put.c:129

status = TX_CEILING_EXCEEDED;

tx_semaphore_ceiling_put.c:158

status = TX_SUCCESS;

tx_semaphore_ceiling_put.c:171

if (suspended_count == TX_NO_SUSPENSIONS)

tx_semaphore_ceiling_put.c:203

thread_ptr -> tx_thread_suspend_status = TX_SUCCESS;

tx_semaphore_cleanup.c:82

tx_semaphore_cleanup.c:86

UINT suspended_count;

tx_semaphore_cleanup.c:117

if (semaphore_ptr -> tx_semaphore_suspended_count != TX_NO_SUSPENSIONS)

tx_semaphore_cleanup.c:139

if (suspended_count == TX_NO_SUSPENSIONS)

tx_semaphore_cleanup.c:169

if (thread_ptr -> tx_thread_state == TX_SEMAPHORE_SUSP)

tx_semaphore_cleanup.c:185

thread_ptr -> tx_thread_suspend_status = TX_NO_INSTANCE;

UINT _tx_semaphore_create(TX_SEMAPHORE *semaphore_ptr, CHAR *name_ptr, ULONG initial_count)

tx_semaphore_create.c:75

tx_semaphore_create.c:78

tx_semaphore_create.c:142

return(TX_SUCCESS);

UINT _tx_semaphore_delete(TX_SEMAPHORE *semaphore_ptr)

tx_semaphore_delete.c:77

tx_semaphore_delete.c:80

UINT suspended_count;

tx_semaphore_delete.c:84

tx_semaphore_delete.c:142

semaphore_ptr -> tx_semaphore_suspended_count = TX_NO_SUSPENSIONS;

tx_semaphore_delete.c:149

while (suspended_count != TX_NO_SUSPENSIONS)

tx_semaphore_delete.c:163

thread_ptr -> tx_thread_suspend_status = TX_DELETED;

tx_semaphore_delete.c:207

return(TX_SUCCESS);

UINT _tx_semaphore_get(TX_SEMAPHORE *semaphore_ptr, ULONG wait_option)

tx_semaphore_get.c:76

tx_semaphore_get.c:79

UINT status;

tx_semaphore_get.c:84

status = TX_SUCCESS;

tx_semaphore_get.c:88

if (_tx_thread_preempt_disable != ((UINT) 0))

tx_semaphore_get.c:124

status = TX_NO_INSTANCE;

tx_semaphore_get.c:131

if (semaphore_ptr -> tx_semaphore_suspended_count == TX_NO_SUSPENSIONS)

tx_semaphore_get.c:165

thread_ptr -> tx_thread_state = TX_SEMAPHORE_SUSP;

tx_semaphore_get.c:190

thread_ptr -> tx_thread_suspending = TX_TRUE;

tx_semaphore_get.c:202

status = TX_NO_INSTANCE;

tx_semaphore_get.c:228

tx_semaphore_info_get.c:80

UINT _tx_semaphore_info_get(TX_SEMAPHORE *semaphore_ptr, CHAR **name, ULONG *current_value,

tx_semaphore_info_get.c:85

tx_semaphore_info_get.c:139

return(TX_SUCCESS);

tx_semaphore_performance_info_get.c:83

UINT _tx_semaphore_performance_info_get(TX_SEMAPHORE *semaphore_ptr, ULONG *puts, ULONG *gets,

tx_semaphore_performance_info_get.c:158

UINT status;

tx_semaphore_performance_info_get.c:166

status = TX_FEATURE_NOT_ENABLED;

tx_semaphore_performance_info_get.c:172

status = TX_FEATURE_NOT_ENABLED;

tx_semaphore_performance_info_get.c:178

status = TX_FEATURE_NOT_ENABLED;

tx_semaphore_performance_info_get.c:184

status = TX_FEATURE_NOT_ENABLED;

tx_semaphore_performance_info_get.c:190

status = TX_FEATURE_NOT_ENABLED;

tx_semaphore_performance_info_get.c:196

status = TX_FEATURE_NOT_ENABLED;

tx_semaphore_performance_system_info_get.c:81

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

tx_semaphore_performance_system_info_get.c:137

UINT status;

tx_semaphore_performance_system_info_get.c:145

status = TX_FEATURE_NOT_ENABLED;

tx_semaphore_performance_system_info_get.c:151

status = TX_FEATURE_NOT_ENABLED;

tx_semaphore_performance_system_info_get.c:157

status = TX_FEATURE_NOT_ENABLED;

tx_semaphore_performance_system_info_get.c:163

status = TX_FEATURE_NOT_ENABLED;

tx_semaphore_performance_system_info_get.c:169

status = TX_FEATURE_NOT_ENABLED;

tx_semaphore_prioritize.c:75

UINT _tx_semaphore_prioritize(TX_SEMAPHORE *semaphore_ptr)

tx_semaphore_prioritize.c:78

tx_semaphore_prioritize.c:83

UINT suspended_count;

tx_semaphore_prioritize.c:86

UINT list_changed;

tx_semaphore_prioritize.c:102

if (suspended_count < ((UINT) 2))

tx_semaphore_prioritize.c:110

else if (suspended_count == ((UINT) 2))

tx_semaphore_prioritize.c:144

list_changed = TX_FALSE;

tx_semaphore_prioritize.c:172

list_changed = TX_TRUE;

tx_semaphore_prioritize.c:182

list_changed = TX_TRUE;

tx_semaphore_prioritize.c:187

if (list_changed == TX_FALSE)

tx_semaphore_prioritize.c:209

list_changed = TX_FALSE;

tx_semaphore_prioritize.c:251

return(TX_SUCCESS);

UINT _tx_semaphore_put(TX_SEMAPHORE *semaphore_ptr)

tx_semaphore_put.c:75

tx_semaphore_put.c:78

UINT suspended_count;

tx_semaphore_put.c:85

if (suspended_count == TX_NO_SUSPENSIONS)

tx_semaphore_put.c:112

if (suspended_count == TX_NO_SUSPENSIONS)

tx_semaphore_put.c:150

thread_ptr -> tx_thread_suspend_status = TX_SUCCESS;

tx_semaphore_put.c:188

return(TX_SUCCESS);

tx_semaphore_put.c:222

tx_semaphore_put_notify.c:75

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

tx_semaphore_put_notify.c:84

return(TX_FEATURE_NOT_ENABLED);

tx_semaphore_put_notify.c:87

tx_semaphore_put_notify.c:106

return(TX_SUCCESS);

_tx_thread_highest_priority

THREAD_DECLARE UINT _tx_thread_highest_priority;

tx_thread.h:384

THREAD_DECLARE volatile UINT _tx_thread_preempt_disable;

tx_thread.h:399

_tx_thread_preempt_disable

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

_tx_thread_create()::priority

ULONG time_slice, UINT auto_start)

tx_thread_create.c:95

_tx_thread_create()::auto_start

tx_thread_create.c:98

UINT saved_threshold = ((UINT) 0);

tx_thread_create.c:103

thread_ptr -> tx_thread_inherit_priority = ((UINT) TX_MAX_PRIORITIES);

tx_thread_create.c:166

temp_ptr = (TX_UCHAR_POINTER_ADD(temp_ptr, (stack_size - ((ULONG) 1))));

tx_thread_create.c:170

thread_ptr -> tx_thread_preempt_threshold = ((UINT) 0);

tx_thread_create.c:186

thread_ptr -> tx_thread_user_preempt_threshold = ((UINT) 0);

tx_thread_create.c:187

tx_thread_create.c:199

if (auto_start == TX_AUTO_START)

tx_thread_create.c:273

return(TX_SUCCESS);

tx_thread_create.c:374

UINT _tx_thread_delete(TX_THREAD *thread_ptr)

tx_thread_delete.c:74

tx_thread_delete.c:77

UINT status;

tx_thread_delete.c:81

status = TX_SUCCESS;

tx_thread_delete.c:85

if (thread_ptr -> tx_thread_state != TX_COMPLETED)

tx_thread_delete.c:91

if (thread_ptr -> tx_thread_state != TX_TERMINATED)

tx_thread_delete.c:95

status = TX_DELETE_ERROR;

tx_thread_delete.c:102

if (status == TX_SUCCESS)

tx_thread_delete.c:107

tx_thread_entry_exit_notify.c:77

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:86

return(TX_FEATURE_NOT_ENABLED);

tx_thread_entry_exit_notify.c:89

tx_thread_entry_exit_notify.c:108

return(TX_SUCCESS);

tx_thread_identify.c:81

_tx_thread_identify()

UINT _tx_thread_info_get(TX_THREAD *thread_ptr, CHAR **name, UINT *state, ULONG *run_count,

tx_thread_info_get.c:83

UINT *priority, UINT *preemption_threshold, ULONG *time_slice,

tx_thread_info_get.c:84

_tx_thread_info_get()::priority

tx_thread_info_get.c:88

return(TX_SUCCESS);

tx_thread_info_get.c:163

tx_thread_initialize.c:118

UINT _tx_thread_highest_priority;

_tx_thread_highest_priority

volatile UINT _tx_thread_preempt_disable;

tx_thread_initialize.c:133

_tx_thread_preempt_disable

_tx_thread_highest_priority = ((UINT) TX_MAX_PRIORITIES);

tx_thread_initialize.c:346

_tx_thread_initialize()

_tx_thread_preempt_disable = ((UINT) 0);

tx_thread_initialize.c:360

_tx_thread_initialize()

UINT _tx_thread_performance_info_get(TX_THREAD *thread_ptr, ULONG *resumptions, ULONG *suspensions,

tx_thread_performance_info_get.c:100

tx_thread_performance_info_get.c:218

UINT status;

tx_thread_performance_info_get.c:226

status = TX_FEATURE_NOT_ENABLED;

tx_thread_performance_info_get.c:232

status = TX_FEATURE_NOT_ENABLED;

tx_thread_performance_info_get.c:238

status = TX_FEATURE_NOT_ENABLED;

tx_thread_performance_info_get.c:244

status = TX_FEATURE_NOT_ENABLED;

tx_thread_performance_info_get.c:250

status = TX_FEATURE_NOT_ENABLED;

tx_thread_performance_info_get.c:256

status = TX_FEATURE_NOT_ENABLED;

tx_thread_performance_info_get.c:262

status = TX_FEATURE_NOT_ENABLED;

tx_thread_performance_info_get.c:268

status = TX_FEATURE_NOT_ENABLED;

tx_thread_performance_info_get.c:274

status = TX_FEATURE_NOT_ENABLED;

tx_thread_performance_info_get.c:280

status = TX_FEATURE_NOT_ENABLED;

tx_thread_performance_info_get.c:286

status = TX_FEATURE_NOT_ENABLED;

tx_thread_performance_info_get.c:292

status = TX_FEATURE_NOT_ENABLED;

tx_thread_performance_system_info_get.c:100

UINT _tx_thread_performance_system_info_get(ULONG *resumptions, ULONG *suspensions,

tx_thread_performance_system_info_get.c:208

UINT status;

tx_thread_performance_system_info_get.c:216

status = TX_FEATURE_NOT_ENABLED;

tx_thread_performance_system_info_get.c:222

status = TX_FEATURE_NOT_ENABLED;

tx_thread_performance_system_info_get.c:228

status = TX_FEATURE_NOT_ENABLED;

tx_thread_performance_system_info_get.c:234

status = TX_FEATURE_NOT_ENABLED;

tx_thread_performance_system_info_get.c:240

status = TX_FEATURE_NOT_ENABLED;

tx_thread_performance_system_info_get.c:246

status = TX_FEATURE_NOT_ENABLED;

tx_thread_performance_system_info_get.c:252

status = TX_FEATURE_NOT_ENABLED;

tx_thread_performance_system_info_get.c:258

status = TX_FEATURE_NOT_ENABLED;

tx_thread_performance_system_info_get.c:264

status = TX_FEATURE_NOT_ENABLED;

tx_thread_performance_system_info_get.c:270

status = TX_FEATURE_NOT_ENABLED;

tx_thread_performance_system_info_get.c:276

status = TX_FEATURE_NOT_ENABLED;

tx_thread_performance_system_info_get.c:282

status = TX_FEATURE_NOT_ENABLED;

tx_thread_preemption_change.c:77

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

tx_thread_preemption_change.c:80

tx_thread_preemption_change.c:88

UINT status;

tx_thread_preemption_change.c:92

status = TX_SUCCESS;

tx_thread_preemption_change.c:103

if (new_threshold != ((UINT) 0))

tx_thread_preemption_change.c:108

new_threshold = ((UINT) 0);

tx_thread_preemption_change.c:127

status = TX_THRESH_ERROR;

tx_thread_priority_change.c:89

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

tx_thread_priority_change.c:92

tx_thread_priority_change.c:96

UINT original_priority;

tx_thread_priority_change.c:112

if (thread_ptr -> tx_thread_state != TX_READY)

tx_thread_priority_change.c:144

thread_ptr -> tx_thread_state = TX_PRIORITY_CHANGE;

tx_thread_priority_change.c:191

_tx_thread_preempt_disable = _tx_thread_preempt_disable + ((UINT) 3);

tx_thread_priority_change.c:194

tx_thread_priority_change.c:248

tx_thread_priority_change.c:285

return(TX_SUCCESS);

tx_thread_relinquish.c:81

_tx_thread_relinquish()

UINT priority;

tx_thread_relinquish.c:83

_tx_thread_relinquish()

UINT _tx_thread_reset(TX_THREAD *thread_ptr)

tx_thread_reset.c:75

UINT status;

status = TX_SUCCESS;

status = TX_NOT_DONE;

tx_thread_reset.c:98

if (thread_ptr -> tx_thread_state != TX_COMPLETED)

tx_thread_reset.c:104

if (thread_ptr -> tx_thread_state != TX_TERMINATED)

tx_thread_reset.c:108

status = TX_NOT_DONE;

tx_thread_reset.c:112

if (status == TX_SUCCESS)

tx_thread_reset.c:118

thread_ptr -> tx_thread_state = TX_NOT_DONE;

tx_thread_reset.c:122

tx_thread_reset.c:147

UINT _tx_thread_resume(TX_THREAD *thread_ptr)

tx_thread_resume.c:75

tx_thread_resume.c:78

UINT status;

tx_thread_resume.c:80

UINT saved_threshold = ((UINT) 0);

tx_thread_resume.c:82

if (thread_ptr -> tx_thread_state == TX_SUSPENDED)

tx_thread_resume.c:121

return(TX_SUCCESS);

tx_thread_resume.c:198

else if (thread_ptr -> tx_thread_delayed_suspend == TX_TRUE)

tx_thread_resume.c:525

thread_ptr -> tx_thread_delayed_suspend = TX_FALSE;

tx_thread_resume.c:529

status = TX_SUSPEND_LIFTED;

tx_thread_resume.c:532

status = TX_RESUME_ERROR;

tx_thread_resume.c:538

tx_thread_shell_entry.c:79

tx_thread_shell_entry.c:83

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

(entry_exit_notify)(thread_ptr, TX_THREAD_ENTRY);

tx_thread_shell_entry.c:109

tx_thread_shell_entry.c:138

thread_ptr -> tx_thread_state = TX_COMPLETED;

tx_thread_shell_entry.c:167

thread_ptr -> tx_thread_suspending = TX_TRUE;

tx_thread_shell_entry.c:188

(entry_exit_notify)(thread_ptr, TX_THREAD_EXIT);

UINT _tx_thread_sleep(ULONG timer_ticks)

tx_thread_sleep.c:74

UINT status;

status = TX_CALLER_ERROR;

tx_thread_sleep.c:99

status = TX_CALLER_ERROR;

tx_thread_sleep.c:110

status = TX_CALLER_ERROR;

tx_thread_sleep.c:123

status = TX_SUCCESS;

tx_thread_sleep.c:135

if (_tx_thread_preempt_disable != ((UINT) 0))

tx_thread_sleep.c:141

status = TX_CALLER_ERROR;

tx_thread_sleep.c:148

thread_ptr -> tx_thread_state = TX_SLEEP;

tx_thread_sleep.c:162

thread_ptr -> tx_thread_suspending = TX_TRUE;

tx_thread_sleep.c:174

thread_ptr -> tx_thread_suspend_status = TX_SUCCESS;

tx_thread_sleep.c:177

tx_thread_stack_analyze.c:76

_tx_thread_stack_analyze()

stack_ptr = TX_ULONG_POINTER_ADD(stack_lowest, size);

tx_thread_stack_analyze.c:119

_tx_thread_stack_analyze()

stack_ptr = TX_ULONG_POINTER_ADD(stack_ptr, 1);

tx_thread_stack_analyze.c:142

_tx_thread_stack_analyze()

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

tx_thread_stack_error_notify.c:86

tx_thread_stack_error_notify.c:91

UINT status;

tx_thread_stack_error_notify.c:99

status = TX_FEATURE_NOT_ENABLED;

tx_thread_stack_error_notify.c:105

status = TX_FEATURE_NOT_ENABLED;

UINT _tx_thread_suspend(TX_THREAD *thread_ptr)

tx_thread_suspend.c:79

tx_thread_suspend.c:82

UINT status;

tx_thread_suspend.c:85

tx_thread_suspend.c:103

status = TX_SUCCESS;

tx_thread_suspend.c:107

if (_tx_thread_preempt_disable != ((UINT) 0))

tx_thread_suspend.c:120

status = TX_SUSPEND_ERROR;

tx_thread_suspend.c:125

if (status == TX_SUCCESS)

tx_thread_suspend.c:131

tx_thread_suspend.c:135

tx_thread_suspend.c:147

return(TX_SUCCESS);

tx_thread_suspend.c:172

else if (thread_ptr -> tx_thread_state == TX_TERMINATED)

tx_thread_suspend.c:176

status = TX_SUSPEND_ERROR;

tx_thread_suspend.c:180

else if (thread_ptr -> tx_thread_state == TX_COMPLETED)

tx_thread_suspend.c:182

status = TX_SUSPEND_ERROR;

tx_thread_suspend.c:186

else if (thread_ptr -> tx_thread_state == TX_SUSPENDED)

tx_thread_suspend.c:188

status = TX_SUCCESS;

tx_thread_suspend.c:192

thread_ptr -> tx_thread_delayed_suspend = TX_TRUE;

tx_thread_suspend.c:198

status = TX_SUCCESS;

tx_thread_suspend.c:201

tx_thread_system_resume.c:85

tx_thread_system_resume.c:87

UINT priority;

tx_thread_system_resume.c:101

UINT map_index;

tx_thread_system_resume.c:158

if (thread_ptr -> tx_thread_suspending == TX_FALSE)

tx_thread_system_resume.c:163

if (thread_ptr -> tx_thread_state != TX_READY)

tx_thread_system_resume.c:167

if (thread_ptr -> tx_thread_delayed_suspend == TX_FALSE)

tx_thread_system_resume.c:175

thread_ptr -> tx_thread_state = TX_READY;

tx_thread_system_resume.c:209

map_index = priority/((UINT) 32);

tx_thread_system_resume.c:212

TX_DIV32_BIT_SET(priority, priority_bit)

tx_thread_system_resume.c:217

TX_MOD32_BIT_SET(priority, priority_bit)

tx_thread_system_resume.c:404

thread_ptr -> tx_thread_delayed_suspend = TX_FALSE;

tx_thread_system_resume.c:405

tx_thread_system_resume.c:417

if (thread_ptr -> tx_thread_state != TX_COMPLETED)

tx_thread_system_resume.c:421

if (thread_ptr -> tx_thread_state != TX_TERMINATED)

tx_thread_system_resume.c:425

if (thread_ptr -> tx_thread_delayed_suspend == TX_FALSE)

tx_thread_system_resume.c:429

thread_ptr -> tx_thread_suspending = TX_FALSE;

tx_thread_system_resume.c:432

thread_ptr -> tx_thread_state = TX_READY;

tx_thread_system_resume.c:444

thread_ptr -> tx_thread_delayed_suspend = TX_FALSE;

tx_thread_system_resume.c:445

tx_thread_system_suspend.c:87

tx_thread_system_suspend.c:89

UINT priority;

tx_thread_system_suspend.c:90

UINT base_priority;

tx_thread_system_suspend.c:99

UINT map_index;

tx_thread_system_suspend.c:164

if (thread_ptr -> tx_thread_suspending == TX_TRUE)

tx_thread_system_suspend.c:196

thread_ptr -> tx_thread_suspending = TX_FALSE;

tx_thread_system_suspend.c:266

map_index = priority/((UINT) 32);

tx_thread_system_suspend.c:270

TX_MOD32_BIT_SET(priority, priority_bit)

tx_thread_system_suspend.c:280

TX_DIV32_BIT_SET(priority, priority_bit)

tx_thread_system_suspend.c:323

base_priority = map_index * ((UINT) 32);

tx_thread_system_suspend.c:327

base_priority = ((UINT) 0);

tx_thread_system_suspend.c:339

_tx_thread_highest_priority = ((UINT) TX_MAX_PRIORITIES);

tx_thread_system_suspend.c:396

_tx_thread_highest_priority = base_priority + ((UINT) priority_bit);

tx_thread_system_suspend.c:450

base_priority = ((UINT) 0);

tx_thread_system_suspend.c:460

priority = base_priority + ((UINT) priority_bit);

UINT _tx_thread_terminate(TX_THREAD *thread_ptr)

tx_thread_terminate.c:80

tx_thread_terminate.c:83

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

tx_thread_terminate.c:87

UINT status;

tx_thread_terminate.c:89

status = TX_SUCCESS;

tx_thread_terminate.c:94

tx_thread_terminate.c:109

if (thread_ptr -> tx_thread_state == TX_TERMINATED)

tx_thread_terminate.c:116

status = TX_SUCCESS;

tx_thread_terminate.c:120

else if (thread_ptr -> tx_thread_state != TX_COMPLETED)

tx_thread_terminate.c:133

tx_thread_terminate.c:137

thread_ptr -> tx_thread_state = TX_TERMINATED;

tx_thread_terminate.c:160

tx_thread_terminate.c:184

(entry_exit_notify)(thread_ptr, TX_THREAD_EXIT);

tx_thread_terminate.c:199

thread_ptr -> tx_thread_state = TX_TERMINATED;

tx_thread_terminate.c:206

tx_thread_terminate.c:243

thread_ptr -> tx_thread_suspending = TX_FALSE;

tx_thread_terminate.c:261

(entry_exit_notify)(thread_ptr, TX_THREAD_EXIT);

tx_thread_time_slice.c:82

_tx_thread_time_slice()

_tx_timer_expired_time_slice = TX_FALSE;

tx_thread_time_slice.c:109

_tx_thread_time_slice()

if (thread_ptr -> tx_thread_state == TX_READY)

tx_thread_time_slice.c:116

_tx_thread_time_slice()

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

tx_thread_time_slice_change.c:78

tx_thread_time_slice_change.c:81

tx_thread_time_slice_change.c:117

return(TX_SUCCESS);

tx_thread_wait_abort.c:76

tx_thread_timeout.c:82

_tx_thread_timeout()

if (thread_ptr -> tx_thread_state == TX_SLEEP)

tx_thread_timeout.c:96

_tx_thread_timeout()

UINT _tx_thread_wait_abort(TX_THREAD *thread_ptr)

tx_thread_wait_abort.c:79

tx_thread_wait_abort.c:82

UINT status;

tx_thread_wait_abort.c:96

if (thread_ptr -> tx_thread_state < TX_SLEEP)

tx_thread_wait_abort.c:107

status = TX_WAIT_ABORT_ERROR;

tx_thread_wait_abort.c:113

if (thread_ptr -> tx_thread_state == TX_SLEEP)

tx_thread_wait_abort.c:117

tx_thread_wait_abort.c:121

thread_ptr -> tx_thread_suspend_status = TX_WAIT_ABORTED;

tx_thread_wait_abort.c:141

tx_thread_wait_abort.c:159

thread_ptr -> tx_thread_suspend_status = TX_WAIT_ABORTED;

tx_thread_wait_abort.c:180

if (thread_ptr -> tx_thread_suspend_status == TX_WAIT_ABORTED)

tx_thread_wait_abort.c:206

status = TX_SUCCESS;

tx_thread_wait_abort.c:230

status = TX_WAIT_ABORT_ERROR;

tx_time_get.c:78

_tx_time_get()

_tx_timer_expired_time_slice

tx_time_set.c:76

_tx_time_set()

TIMER_DECLARE UINT _tx_timer_expired_time_slice;

tx_timer.h:97

TIMER_DECLARE UINT _tx_timer_expired;

tx_timer.h:122

_tx_timer_expired

TIMER_DECLARE UINT _tx_timer_priority;

tx_timer.h:159

_tx_timer_priority

TIMER_DECLARE ULONG _tx_timer_thread_stack_area[(((UINT) TX_TIMER_THREAD_STACK_SIZE)+((sizeof(ULONG)) - ((UINT) 1)))/sizeof(ULONG)];

tx_timer.h:164

UINT _tx_timer_activate(TX_TIMER *timer_ptr)

tx_timer_activate.c:74

tx_timer_activate.c:77

UINT status;

tx_timer_activate.c:79

status = TX_ACTIVATE_ERROR;

tx_timer_activate.c:102

status = TX_ACTIVATE_ERROR;

tx_timer_activate.c:110

status = TX_SUCCESS;

tx_timer_activate.c:128

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

tx_timer_change.c:75

tx_timer_change.c:78

return(TX_SUCCESS);

tx_timer_change.c:103

UINT _tx_timer_create(TX_TIMER *timer_ptr, CHAR *name_ptr,

tx_timer_create.c:78

ULONG initial_ticks, ULONG reschedule_ticks, UINT auto_activate)

tx_timer_create.c:80

_tx_timer_create()::auto_activate

tx_timer_create.c:83

if (auto_activate == TX_AUTO_ACTIVATE)

tx_timer_create.c:147

return(TX_SUCCESS);

tx_timer_create.c:167

UINT _tx_timer_deactivate(TX_TIMER *timer_ptr)

tx_timer_deactivate.c:72

tx_timer_deactivate.c:74

UINT active_timer_list;

tx_timer_deactivate.c:81

tx_timer_deactivate.c:114

active_timer_list = TX_FALSE;

tx_timer_deactivate.c:125

active_timer_list = TX_TRUE;

tx_timer_deactivate.c:130

if (active_timer_list == TX_TRUE)

tx_timer_deactivate.c:250

return(TX_SUCCESS);

UINT _tx_timer_delete(TX_TIMER *timer_ptr)

tx_timer_delete.c:72

tx_timer_delete.c:75

return(TX_SUCCESS);

tx_timer_delete.c:142

tx_timer_expiration_process.c:85

_tx_timer_expiration_process()

UINT _tx_timer_info_get(TX_TIMER *timer_ptr, CHAR **name, UINT *active, ULONG *remaining_ticks,

tx_timer_info_get.c:79

tx_timer_info_get.c:83

UINT timer_active;

tx_timer_info_get.c:88

UINT active_timer_list;

tx_timer_info_get.c:89

timer_active = TX_FALSE;

tx_timer_info_get.c:115

timer_active = TX_TRUE;

tx_timer_info_get.c:125

active_timer_list = TX_FALSE;

tx_timer_info_get.c:128

active_timer_list = TX_TRUE;

tx_timer_info_get.c:139

if (active_timer_list == TX_TRUE)

tx_timer_info_get.c:144

return(TX_SUCCESS);

tx_timer_info_get.c:248

_tx_timer_expired_time_slice

UINT _tx_timer_expired_time_slice;

tx_timer_initialize.c:48

UINT _tx_timer_expired;

tx_timer_initialize.c:73

_tx_timer_expired

UINT _tx_timer_priority;

tx_timer_initialize.c:110

_tx_timer_priority

ULONG _tx_timer_thread_stack_area[(((UINT) TX_TIMER_THREAD_STACK_SIZE)+((sizeof(ULONG))- ((UINT) 1)))/(sizeof(ULONG))];

tx_timer_initialize.c:115

UINT status;

tx_timer_initialize.c:209

_tx_timer_expired_time_slice = TX_FALSE;

tx_timer_initialize.c:221

tx_timer_initialize.c:222

_tx_timer_expired = TX_FALSE;

tx_timer_initialize.c:248

_tx_timer_priority = ((UINT) TX_TIMER_THREAD_PRIORITY);

tx_timer_initialize.c:262

_tx_timer_priority, _tx_timer_priority, TX_NO_TIME_SLICE, TX_DONT_START);

tx_timer_initialize.c:278

} while (status != TX_SUCCESS);

tx_timer_performance_info_get.c:86

UINT _tx_timer_performance_info_get(TX_TIMER *timer_ptr, ULONG *activates, ULONG *reactivates,

tx_timer_performance_info_get.c:165

UINT status;

tx_timer_performance_info_get.c:173

status = TX_FEATURE_NOT_ENABLED;

tx_timer_performance_info_get.c:179

status = TX_FEATURE_NOT_ENABLED;

tx_timer_performance_info_get.c:185

status = TX_FEATURE_NOT_ENABLED;

tx_timer_performance_info_get.c:191

status = TX_FEATURE_NOT_ENABLED;

tx_timer_performance_info_get.c:197

status = TX_FEATURE_NOT_ENABLED;

tx_timer_performance_info_get.c:203

status = TX_FEATURE_NOT_ENABLED;

tx_timer_performance_info_get.c:209

status = TX_FEATURE_NOT_ENABLED;

tx_timer_performance_system_info_get.c:83

UINT _tx_timer_performance_system_info_get(ULONG *activates, ULONG *reactivates,

tx_timer_performance_system_info_get.c:144

UINT status;

tx_timer_performance_system_info_get.c:152

status = TX_FEATURE_NOT_ENABLED;

tx_timer_performance_system_info_get.c:158

status = TX_FEATURE_NOT_ENABLED;

tx_timer_performance_system_info_get.c:164

status = TX_FEATURE_NOT_ENABLED;

tx_timer_performance_system_info_get.c:170

status = TX_FEATURE_NOT_ENABLED;

tx_timer_performance_system_info_get.c:176

status = TX_FEATURE_NOT_ENABLED;

tx_timer_performance_system_info_get.c:182

status = TX_FEATURE_NOT_ENABLED;

tx_timer_thread_entry.c:80

tx_timer_thread_entry.c:108

while (TX_LOOP_FOREVER)

tx_timer_thread_entry.c:140

_tx_timer_expired = TX_FALSE;

tx_timer_thread_entry.c:431

if (_tx_timer_expired == TX_FALSE)

tx_timer_thread_entry.c:441

thread_ptr -> tx_thread_state = TX_SUSPENDED;

tx_timer_thread_entry.c:453

thread_ptr -> tx_thread_suspending = TX_TRUE;

tx_trace_buffer_full_notify.c:77

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

tx_trace_buffer_full_notify.c:90

UINT status;

tx_trace_buffer_full_notify.c:98

status = TX_FEATURE_NOT_ENABLED;

tx_trace_buffer_full_notify.c:104

status = TX_FEATURE_NOT_ENABLED;

UINT _tx_trace_disable(VOID)

tx_trace_disable.c:71

_tx_trace_disable()

return(TX_FEATURE_NOT_ENABLED);

tx_trace_disable.c:102

_tx_trace_disable()

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

tx_trace_enable.c:86

UINT status;

tx_trace_enable.c:409

status = TX_FEATURE_NOT_ENABLED;

tx_trace_enable.c:417

status = TX_FEATURE_NOT_ENABLED;

tx_trace_enable.c:423

status = TX_FEATURE_NOT_ENABLED;

tx_trace_enable.c:429

status = TX_FEATURE_NOT_ENABLED;

tx_trace_enable.c:435

tx_trace_event_filter.c:74

UINT _tx_trace_event_filter(ULONG event_filter_bits)

tx_trace_event_filter.c:87

UINT status;

tx_trace_event_filter.c:95

status = TX_FEATURE_NOT_ENABLED;

tx_trace_event_filter.c:101

status = TX_FEATURE_NOT_ENABLED;

tx_trace_event_unfilter.c:74

UINT _tx_trace_event_unfilter(ULONG event_unfilter_bits)

tx_trace_event_unfilter.c:87

UINT status;

tx_trace_event_unfilter.c:95

status = TX_FEATURE_NOT_ENABLED;

tx_trace_event_unfilter.c:101

status = TX_FEATURE_NOT_ENABLED;

tx_trace_interrupt_control.c:73

UINT _tx_trace_interrupt_control(UINT new_posture)

_tx_trace_interrupt_control()

UINT saved_posture;

tx_trace_interrupt_control.c:97

_tx_trace_interrupt_control()

tx_trace_isr_enter_insert.c:78

_tx_trace_isr_enter_insert()

tx_trace_isr_exit_insert.c:78

_tx_trace_isr_exit_insert()

tx_trace_object_register.c:264

_tx_trace_object_register()

tx_trace_object_unregister.c:120

_tx_trace_object_unregister()

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)

tx_trace_user_event_insert.c:75

tx_trace_user_event_insert.c:117

UINT status;

tx_trace_user_event_insert.c:125

status = TX_FEATURE_NOT_ENABLED;

tx_trace_user_event_insert.c:131

status = TX_FEATURE_NOT_ENABLED;

tx_trace_user_event_insert.c:137

status = TX_FEATURE_NOT_ENABLED;

tx_trace_user_event_insert.c:143

status = TX_FEATURE_NOT_ENABLED;

tx_trace_user_event_insert.c:149

status = TX_FEATURE_NOT_ENABLED;

tx_trace_user_event_insert.c:155

status = TX_FEATURE_NOT_ENABLED;

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

txe_block_allocate.c:80

UINT status;

txe_block_allocate.c:83

status = TX_SUCCESS;

txe_block_allocate.c:91

status = TX_POOL_ERROR;

txe_block_allocate.c:98

status = TX_POOL_ERROR;

txe_block_allocate.c:106

status = TX_PTR_ERROR;

txe_block_allocate.c:114

status = TX_WAIT_ERROR;

txe_block_allocate.c:129

status = TX_WAIT_ERROR;

txe_block_allocate.c:144

if (status == TX_SUCCESS)

txe_block_allocate.c:152

txe_block_pool_create.c:85

UINT _txe_block_pool_create(TX_BLOCK_POOL *pool_ptr, CHAR *name_ptr, ULONG block_size,

txe_block_pool_create.c:86

VOID *pool_start, ULONG pool_size, UINT pool_control_block_size)

_txe_block_pool_create()::pool_control_block_size

txe_block_pool_create.c:89

txe_block_pool_create.c:91

UINT status;

txe_block_pool_create.c:100

status = TX_SUCCESS;

txe_block_pool_create.c:107

status = TX_POOL_ERROR;

txe_block_pool_create.c:115

status = TX_POOL_ERROR;

txe_block_pool_create.c:164

status = TX_POOL_ERROR;

txe_block_pool_create.c:172

status = TX_PTR_ERROR;

txe_block_pool_create.c:183

status = TX_SIZE_ERROR;

txe_block_pool_create.c:198

status = TX_CALLER_ERROR;

txe_block_pool_create.c:211

status = TX_CALLER_ERROR;

txe_block_pool_create.c:219

if (status == TX_SUCCESS)

txe_block_pool_delete.c:76

UINT _txe_block_pool_delete(TX_BLOCK_POOL *pool_ptr)

txe_block_pool_delete.c:79

UINT status;

txe_block_pool_delete.c:88

status = TX_SUCCESS;

txe_block_pool_delete.c:96

status = TX_POOL_ERROR;

txe_block_pool_delete.c:104

status = TX_POOL_ERROR;

txe_block_pool_delete.c:114

status = TX_CALLER_ERROR;

txe_block_pool_delete.c:129

status = TX_CALLER_ERROR;

txe_block_pool_delete.c:133

if (status == TX_SUCCESS)

txe_block_pool_info_get.c:81

UINT _txe_block_pool_info_get(TX_BLOCK_POOL *pool_ptr, CHAR **name, ULONG *available_blocks,

txe_block_pool_info_get.c:87

UINT status;

txe_block_pool_info_get.c:95

status = TX_POOL_ERROR;

txe_block_pool_info_get.c:103

status = TX_POOL_ERROR;

txe_block_pool_prioritize.c:72

UINT _txe_block_pool_prioritize(TX_BLOCK_POOL *pool_ptr)

txe_block_pool_prioritize.c:75

UINT status;

txe_block_pool_prioritize.c:83

status = TX_POOL_ERROR;

txe_block_pool_prioritize.c:91

status = TX_POOL_ERROR;

UINT _txe_block_release(VOID *block_ptr)

txe_block_release.c:72

UINT status;

txe_block_release.c:75

status = TX_PTR_ERROR;

txe_block_release.c:86

work_ptr = TX_UCHAR_POINTER_SUB(work_ptr, (sizeof(UCHAR *)));

txe_block_release.c:94

status = TX_PTR_ERROR;

txe_block_release.c:104

status = TX_PTR_ERROR;

txe_block_release.c:112

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

txe_byte_allocate.c:83

UINT status;

txe_byte_allocate.c:87

status = TX_SUCCESS;

txe_byte_allocate.c:94

status = TX_POOL_ERROR;

txe_byte_allocate.c:101

status = TX_POOL_ERROR;

txe_byte_allocate.c:109

status = TX_PTR_ERROR;

txe_byte_allocate.c:117

status = TX_SIZE_ERROR;

txe_byte_allocate.c:125

status = TX_SIZE_ERROR;

txe_byte_allocate.c:133

status = TX_WAIT_ERROR;

txe_byte_allocate.c:149

if (status == TX_SUCCESS)

txe_byte_allocate.c:156

status = TX_CALLER_ERROR;

txe_byte_allocate.c:167

if (status == TX_SUCCESS)

txe_byte_allocate.c:173

status = TX_CALLER_ERROR;

txe_byte_allocate.c:185

if (status == TX_SUCCESS)

txe_byte_allocate.c:191

txe_byte_pool_create.c:84

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:87

txe_byte_pool_create.c:89

UINT status;

txe_byte_pool_create.c:98

status = TX_SUCCESS;

txe_byte_pool_create.c:105

status = TX_POOL_ERROR;

txe_byte_pool_create.c:113

status = TX_POOL_ERROR;

txe_byte_pool_create.c:163

status = TX_POOL_ERROR;

txe_byte_pool_create.c:171

status = TX_PTR_ERROR;

txe_byte_pool_create.c:179

status = TX_SIZE_ERROR;

txe_byte_pool_create.c:194

status = TX_CALLER_ERROR;

txe_byte_pool_create.c:207

status = TX_CALLER_ERROR;

txe_byte_pool_create.c:214

if (status == TX_SUCCESS)

txe_byte_pool_delete.c:76

UINT _txe_byte_pool_delete(TX_BYTE_POOL *pool_ptr)

txe_byte_pool_delete.c:79

UINT status;

txe_byte_pool_delete.c:88

status = TX_SUCCESS;

txe_byte_pool_delete.c:96

status = TX_POOL_ERROR;

txe_byte_pool_delete.c:104

status = TX_POOL_ERROR;

txe_byte_pool_delete.c:112

status = TX_CALLER_ERROR;

txe_byte_pool_delete.c:127

status = TX_CALLER_ERROR;

txe_byte_pool_delete.c:131

if (status == TX_SUCCESS)

txe_byte_pool_info_get.c:81

UINT _txe_byte_pool_info_get(TX_BYTE_POOL *pool_ptr, CHAR **name, ULONG *available_bytes,

txe_byte_pool_info_get.c:86

UINT status;

txe_byte_pool_info_get.c:94

status = TX_POOL_ERROR;

txe_byte_pool_info_get.c:102

status = TX_POOL_ERROR;

txe_byte_pool_prioritize.c:72

UINT _txe_byte_pool_prioritize(TX_BYTE_POOL *pool_ptr)

txe_byte_pool_prioritize.c:75

UINT status;

txe_byte_pool_prioritize.c:83

status = TX_POOL_ERROR;

txe_byte_pool_prioritize.c:91

status = TX_POOL_ERROR;

UINT _txe_byte_release(VOID *memory_ptr)

txe_byte_release.c:76

UINT status;

txe_byte_release.c:79

status = TX_SUCCESS;

txe_byte_release.c:86

status = TX_PTR_ERROR;

txe_byte_release.c:93

status = TX_CALLER_ERROR;

txe_byte_release.c:108

status = TX_CALLER_ERROR;

txe_byte_release.c:121

if (status == TX_SUCCESS)

txe_byte_release.c:127

txe_event_flags_create.c:81

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

txe_event_flags_create.c:84

txe_event_flags_create.c:86

UINT status;

txe_event_flags_create.c:95

status = TX_SUCCESS;

txe_event_flags_create.c:102

status = TX_GROUP_ERROR;

txe_event_flags_create.c:110

status = TX_GROUP_ERROR;

txe_event_flags_create.c:160

status = TX_GROUP_ERROR;

txe_event_flags_create.c:175

status = TX_CALLER_ERROR;

txe_event_flags_create.c:188

status = TX_CALLER_ERROR;

txe_event_flags_create.c:195

if (status == TX_SUCCESS)

txe_event_flags_delete.c:76

UINT _txe_event_flags_delete(TX_EVENT_FLAGS_GROUP *group_ptr)

txe_event_flags_delete.c:79

UINT status;

txe_event_flags_delete.c:88

status = TX_SUCCESS;

txe_event_flags_delete.c:96

status = TX_GROUP_ERROR;

txe_event_flags_delete.c:104

status = TX_GROUP_ERROR;

txe_event_flags_delete.c:114

status = TX_CALLER_ERROR;

txe_event_flags_delete.c:129

status = TX_CALLER_ERROR;

txe_event_flags_delete.c:133

if (status == TX_SUCCESS)

UINT _txe_event_flags_get(TX_EVENT_FLAGS_GROUP *group_ptr, ULONG requested_flags,

txe_event_flags_get.c:84

UINT get_option, ULONG *actual_flags_ptr, ULONG wait_option)

txe_event_flags_get.c:85

_txe_event_flags_get()::get_option

UINT status;

txe_event_flags_get.c:88

status = TX_SUCCESS;

txe_event_flags_get.c:96

txe_event_flags_get.c:103

status = TX_GROUP_ERROR;

txe_event_flags_get.c:111

status = TX_GROUP_ERROR;

txe_event_flags_get.c:119

status = TX_PTR_ERROR;

txe_event_flags_get.c:134

status = TX_WAIT_ERROR;

txe_event_flags_get.c:148

status = TX_WAIT_ERROR;

txe_event_flags_get.c:156

if (status == TX_SUCCESS)

txe_event_flags_get.c:160

if (get_option > TX_AND_CLEAR)

txe_event_flags_get.c:164

status = TX_OPTION_ERROR;

txe_event_flags_get.c:169

if (status == TX_SUCCESS)

txe_event_flags_info_get.c:83

UINT _txe_event_flags_info_get(TX_EVENT_FLAGS_GROUP *group_ptr, CHAR **name, ULONG *current_flags,

txe_event_flags_info_get.c:88

UINT status;

txe_event_flags_info_get.c:96

status = TX_GROUP_ERROR;

txe_event_flags_info_get.c:104

status = TX_GROUP_ERROR;

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

txe_event_flags_set.c:77

UINT status;

txe_event_flags_set.c:80

status = TX_SUCCESS;

txe_event_flags_set.c:84

status = TX_GROUP_ERROR;

txe_event_flags_set.c:91

status = TX_GROUP_ERROR;

txe_event_flags_set.c:99

txe_event_flags_set.c:105

if (set_option != TX_AND)

txe_event_flags_set.c:108

if (set_option != TX_OR)

txe_event_flags_set.c:112

status = TX_OPTION_ERROR;

txe_event_flags_set.c:118

if (status == TX_SUCCESS)

txe_event_flags_set_notify.c:75

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:78

UINT status;

txe_event_flags_set_notify.c:86

status = TX_GROUP_ERROR;

txe_event_flags_set_notify.c:94

status = TX_GROUP_ERROR;

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

txe_mutex_create.c:82

txe_mutex_create.c:85

UINT status;

txe_mutex_create.c:87

status = TX_SUCCESS;

txe_mutex_create.c:96

status = TX_MUTEX_ERROR;

txe_mutex_create.c:103

status = TX_MUTEX_ERROR;

txe_mutex_create.c:111

status = TX_MUTEX_ERROR;

txe_mutex_create.c:161

if (inherit != TX_INHERIT)

txe_mutex_create.c:167

if (inherit != TX_NO_INHERIT)

txe_mutex_create.c:170

status = TX_INHERIT_ERROR;

txe_mutex_create.c:174

if (status == TX_SUCCESS)

txe_mutex_create.c:181

status = TX_CALLER_ERROR;

txe_mutex_create.c:194

status = TX_CALLER_ERROR;

txe_mutex_create.c:207

if (status == TX_SUCCESS)

txe_mutex_create.c:213

UINT _txe_mutex_delete(TX_MUTEX *mutex_ptr)

txe_mutex_delete.c:76

UINT status;

txe_mutex_delete.c:79

status = TX_SUCCESS;

txe_mutex_delete.c:88

status = TX_MUTEX_ERROR;

txe_mutex_delete.c:96

status = TX_MUTEX_ERROR;

txe_mutex_delete.c:104

status = TX_CALLER_ERROR;

txe_mutex_delete.c:114

status = TX_CALLER_ERROR;

txe_mutex_delete.c:129

if (status == TX_SUCCESS)

txe_mutex_delete.c:133

UINT _txe_mutex_get(TX_MUTEX *mutex_ptr, ULONG wait_option)

UINT status;

status = TX_SUCCESS;

status = TX_MUTEX_ERROR;

txe_mutex_get.c:96

status = TX_MUTEX_ERROR;

txe_mutex_get.c:104

status = TX_WAIT_ERROR;

txe_mutex_get.c:119

status = TX_WAIT_ERROR;

txe_mutex_get.c:134

if (status == TX_SUCCESS)

txe_mutex_get.c:142

status = TX_CALLER_ERROR;

txe_mutex_get.c:154

if (status == TX_SUCCESS)

txe_mutex_get.c:160

UINT _txe_mutex_info_get(TX_MUTEX *mutex_ptr, CHAR **name, ULONG *count, TX_THREAD **owner,

txe_mutex_info_get.c:82

UINT status;

txe_mutex_info_get.c:87

status = TX_MUTEX_ERROR;

txe_mutex_info_get.c:95

status = TX_MUTEX_ERROR;

txe_mutex_info_get.c:103

txe_mutex_prioritize.c:72

UINT _txe_mutex_prioritize(TX_MUTEX *mutex_ptr)

txe_mutex_prioritize.c:75

UINT status;

txe_mutex_prioritize.c:83

status = TX_MUTEX_ERROR;

txe_mutex_prioritize.c:91

status = TX_MUTEX_ERROR;

UINT _txe_mutex_put(TX_MUTEX *mutex_ptr)

UINT status;

status = TX_SUCCESS;

status = TX_MUTEX_ERROR;

txe_mutex_put.c:88

status = TX_MUTEX_ERROR;

txe_mutex_put.c:96

status = TX_CALLER_ERROR;

txe_mutex_put.c:110

if (status == TX_SUCCESS)

txe_mutex_put.c:116

UINT _txe_queue_create(TX_QUEUE *queue_ptr, CHAR *name_ptr, UINT message_size,

txe_queue_create.c:83

VOID *queue_start, ULONG queue_size, UINT queue_control_block_size)

txe_queue_create.c:84

_txe_queue_create()::queue_control_block_size

txe_queue_create.c:87

UINT status;

txe_queue_create.c:89

status = TX_SUCCESS;

txe_queue_create.c:98

status = TX_QUEUE_ERROR;

txe_queue_create.c:105

status = TX_QUEUE_ERROR;

txe_queue_create.c:113

status = TX_QUEUE_ERROR;

txe_queue_create.c:163

status = TX_PTR_ERROR;

txe_queue_create.c:171

else if (message_size < TX_1_ULONG)

txe_queue_create.c:175

status = TX_SIZE_ERROR;

txe_queue_create.c:179

else if (message_size > TX_16_ULONG)

txe_queue_create.c:183

status = TX_SIZE_ERROR;

txe_queue_create.c:187

status = TX_SIZE_ERROR;

txe_queue_create.c:195

status = TX_CALLER_ERROR;

txe_queue_create.c:210

status = TX_CALLER_ERROR;

txe_queue_create.c:223

if (status == TX_SUCCESS)

txe_queue_create.c:230

UINT _txe_queue_delete(TX_QUEUE *queue_ptr)

txe_queue_delete.c:75

UINT status;

txe_queue_delete.c:78

status = TX_SUCCESS;

txe_queue_delete.c:85

status = TX_QUEUE_ERROR;

txe_queue_delete.c:92

status = TX_QUEUE_ERROR;

txe_queue_delete.c:100

status = TX_CALLER_ERROR;

txe_queue_delete.c:112

status = TX_CALLER_ERROR;

txe_queue_delete.c:127

if (status == TX_SUCCESS)

txe_queue_delete.c:134

txe_queue_front_send.c:78

UINT _txe_queue_flush(TX_QUEUE *queue_ptr)

UINT status;

status = TX_QUEUE_ERROR;

txe_queue_flush.c:84

_txe_queue_flush()

status = TX_QUEUE_ERROR;

txe_queue_flush.c:92

_txe_queue_flush()

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

txe_queue_front_send.c:81

UINT status;

txe_queue_front_send.c:89

status = TX_SUCCESS;

txe_queue_front_send.c:96

status = TX_QUEUE_ERROR;

txe_queue_front_send.c:104

status = TX_QUEUE_ERROR;

txe_queue_front_send.c:112

status = TX_PTR_ERROR;

txe_queue_front_send.c:127

status = TX_WAIT_ERROR;

txe_queue_front_send.c:142

status = TX_WAIT_ERROR;

txe_queue_front_send.c:150

if (status == TX_SUCCESS)

UINT _txe_queue_info_get(TX_QUEUE *queue_ptr, CHAR **name, ULONG *enqueued, ULONG *available_storage,

txe_queue_info_get.c:81

UINT status;

txe_queue_info_get.c:85

status = TX_QUEUE_ERROR;

txe_queue_info_get.c:93

status = TX_QUEUE_ERROR;

txe_queue_info_get.c:101

txe_queue_prioritize.c:71

UINT _txe_queue_prioritize(TX_QUEUE *queue_ptr)

txe_queue_prioritize.c:74

UINT status;

txe_queue_prioritize.c:81

status = TX_QUEUE_ERROR;

txe_queue_prioritize.c:88

status = TX_QUEUE_ERROR;

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

txe_queue_receive.c:80

UINT status;

txe_queue_receive.c:83

status = TX_SUCCESS;

txe_queue_receive.c:91

status = TX_QUEUE_ERROR;

txe_queue_receive.c:98

status = TX_QUEUE_ERROR;

txe_queue_receive.c:106

status = TX_PTR_ERROR;

txe_queue_receive.c:114

status = TX_WAIT_ERROR;

txe_queue_receive.c:129

status = TX_WAIT_ERROR;

txe_queue_receive.c:144

if (status == TX_SUCCESS)

txe_queue_receive.c:152

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

UINT status;

status = TX_SUCCESS;

status = TX_QUEUE_ERROR;

txe_queue_send.c:96

status = TX_QUEUE_ERROR;

txe_queue_send.c:104

status = TX_PTR_ERROR;

txe_queue_send.c:112

status = TX_WAIT_ERROR;

txe_queue_send.c:127

status = TX_WAIT_ERROR;

txe_queue_send.c:142

if (status == TX_SUCCESS)

txe_queue_send.c:150

txe_queue_send_notify.c:74

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

txe_queue_send_notify.c:77

UINT status;

txe_queue_send_notify.c:85

status = TX_QUEUE_ERROR;

txe_queue_send_notify.c:93

status = TX_QUEUE_ERROR;

txe_semaphore_ceiling_put.c:76

UINT _txe_semaphore_ceiling_put(TX_SEMAPHORE *semaphore_ptr, ULONG ceiling)

txe_semaphore_ceiling_put.c:79

UINT status;

txe_semaphore_ceiling_put.c:87

status = TX_SEMAPHORE_ERROR;

txe_semaphore_ceiling_put.c:95

status = TX_SEMAPHORE_ERROR;

txe_semaphore_ceiling_put.c:103

status = TX_INVALID_CEILING;

txe_semaphore_create.c:81

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

txe_semaphore_create.c:84

txe_semaphore_create.c:86

UINT status;

txe_semaphore_create.c:95

status = TX_SUCCESS;

txe_semaphore_create.c:102

status = TX_SEMAPHORE_ERROR;

txe_semaphore_create.c:110

status = TX_SEMAPHORE_ERROR;

txe_semaphore_create.c:160

status = TX_SEMAPHORE_ERROR;

txe_semaphore_create.c:175

status = TX_CALLER_ERROR;

txe_semaphore_create.c:182

if (status == TX_SUCCESS)

txe_semaphore_create.c:194

status = TX_CALLER_ERROR;

txe_semaphore_create.c:200

if (status == TX_SUCCESS)

txe_semaphore_delete.c:76

UINT _txe_semaphore_delete(TX_SEMAPHORE *semaphore_ptr)

txe_semaphore_delete.c:79

UINT status;

txe_semaphore_delete.c:86

status = TX_SUCCESS;

txe_semaphore_delete.c:93

status = TX_SEMAPHORE_ERROR;

txe_semaphore_delete.c:101

status = TX_SEMAPHORE_ERROR;

txe_semaphore_delete.c:113

status = TX_CALLER_ERROR;

txe_semaphore_delete.c:128

status = TX_CALLER_ERROR;

txe_semaphore_delete.c:135

if (status == TX_SUCCESS)

UINT _txe_semaphore_get(TX_SEMAPHORE *semaphore_ptr, ULONG wait_option)

txe_semaphore_get.c:76

UINT status;

txe_semaphore_get.c:79

status = TX_SUCCESS;

txe_semaphore_get.c:87

status = TX_SEMAPHORE_ERROR;

txe_semaphore_get.c:94

status = TX_SEMAPHORE_ERROR;

txe_semaphore_get.c:102

status = TX_WAIT_ERROR;

txe_semaphore_get.c:117

status = TX_WAIT_ERROR;

txe_semaphore_get.c:132

if (status == TX_SUCCESS)

txe_semaphore_get.c:140

txe_semaphore_info_get.c:81

UINT _txe_semaphore_info_get(TX_SEMAPHORE *semaphore_ptr, CHAR **name, ULONG *current_value,

txe_semaphore_info_get.c:86

UINT status;

txe_semaphore_info_get.c:94

status = TX_SEMAPHORE_ERROR;

txe_semaphore_info_get.c:102

status = TX_SEMAPHORE_ERROR;

txe_semaphore_prioritize.c:72

UINT _txe_semaphore_prioritize(TX_SEMAPHORE *semaphore_ptr)

txe_semaphore_prioritize.c:75

UINT status;

txe_semaphore_prioritize.c:83

status = TX_SEMAPHORE_ERROR;

txe_semaphore_prioritize.c:91

status = TX_SEMAPHORE_ERROR;

UINT _txe_semaphore_put(TX_SEMAPHORE *semaphore_ptr)

txe_semaphore_put.c:72

UINT status;

txe_semaphore_put.c:75

status = TX_SEMAPHORE_ERROR;

txe_semaphore_put.c:83

status = TX_SEMAPHORE_ERROR;

txe_semaphore_put.c:91

txe_semaphore_put_notify.c:75

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

txe_semaphore_put_notify.c:78

UINT status;

txe_semaphore_put_notify.c:86

status = TX_SEMAPHORE_ERROR;

txe_semaphore_put_notify.c:94

status = TX_SEMAPHORE_ERROR;

UINT _txe_thread_create(TX_THREAD *thread_ptr, CHAR *name_ptr,

txe_thread_create.c:90

UINT priority, UINT preempt_threshold,

txe_thread_create.c:93

_txe_thread_create()::priority

ULONG time_slice, UINT auto_start, UINT thread_control_block_size)

txe_thread_create.c:94

_txe_thread_create()::auto_start

txe_thread_create.c:97

UINT status;

txe_thread_create.c:99

UINT break_flag;

txe_thread_create.c:100

status = TX_SUCCESS;

txe_thread_create.c:111

status = TX_THREAD_ERROR;

txe_thread_create.c:118

status = TX_THREAD_ERROR;

txe_thread_create.c:126

break_flag = TX_FALSE;

txe_thread_create.c:141

work_ptr = TX_UCHAR_POINTER_ADD(work_ptr, (stack_size - ((ULONG) 1)));

txe_thread_create.c:144

break_flag = TX_TRUE;

txe_thread_create.c:154

if (break_flag == TX_TRUE)

txe_thread_create.c:158

break_flag = TX_TRUE;

txe_thread_create.c:177

break_flag = TX_TRUE;

txe_thread_create.c:193

status = TX_THREAD_ERROR;

txe_thread_create.c:218

status = TX_PTR_ERROR;

txe_thread_create.c:226

status = TX_PTR_ERROR;

txe_thread_create.c:234

status = TX_SIZE_ERROR;

txe_thread_create.c:242

else if (priority >= ((UINT) TX_MAX_PRIORITIES))

txe_thread_create.c:246

status = TX_PRIORITY_ERROR;

txe_thread_create.c:250

status = TX_THRESH_ERROR;

txe_thread_create.c:258

else if (auto_start > TX_AUTO_START)

txe_thread_create.c:262

status = TX_START_ERROR;

txe_thread_create.c:266

status = TX_CALLER_ERROR;

txe_thread_create.c:281

status = TX_CALLER_ERROR;

txe_thread_create.c:294

if (status == TX_SUCCESS)

txe_thread_create.c:301

UINT _txe_thread_delete(TX_THREAD *thread_ptr)

txe_thread_delete.c:73

UINT status;

txe_thread_delete.c:76

status = TX_CALLER_ERROR;

txe_thread_delete.c:84

status = TX_THREAD_ERROR;

txe_thread_delete.c:92

status = TX_THREAD_ERROR;

txe_thread_delete.c:100

txe_thread_entry_exit_notify.c:75

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:78

UINT status;

txe_thread_entry_exit_notify.c:86

status = TX_THREAD_ERROR;

txe_thread_entry_exit_notify.c:94

status = TX_THREAD_ERROR;

UINT _txe_thread_info_get(TX_THREAD *thread_ptr, CHAR **name, UINT *state, ULONG *run_count,

txe_thread_info_get.c:85

UINT *priority, UINT *preemption_threshold, ULONG *time_slice,

txe_thread_info_get.c:86

_txe_thread_info_get()::priority

UINT status;

txe_thread_info_get.c:90

status = TX_THREAD_ERROR;

txe_thread_info_get.c:98

txe_thread_info_get.c:106

status = TX_THREAD_ERROR;

txe_thread_preemption_change.c:77

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

txe_thread_preemption_change.c:80

UINT status;

txe_thread_preemption_change.c:88

status = TX_THREAD_ERROR;

txe_thread_preemption_change.c:96

status = TX_THREAD_ERROR;

txe_thread_preemption_change.c:104

status = TX_PTR_ERROR;

txe_thread_preemption_change.c:112

status = TX_CALLER_ERROR;

txe_thread_preemption_change.c:120

status = TX_THRESH_ERROR;

txe_thread_priority_change.c:78

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

txe_thread_priority_change.c:81

UINT status;

txe_thread_priority_change.c:89

status = TX_THREAD_ERROR;

txe_thread_priority_change.c:97

status = TX_THREAD_ERROR;

txe_thread_priority_change.c:105

status = TX_PTR_ERROR;

txe_thread_priority_change.c:109

else if (new_priority >= ((UINT) TX_MAX_PRIORITIES))

txe_thread_priority_change.c:113

status = TX_PRIORITY_ERROR;

txe_thread_priority_change.c:121

status = TX_CALLER_ERROR;

UINT _txe_thread_reset(TX_THREAD *thread_ptr)

txe_thread_reset.c:74

UINT status;

txe_thread_reset.c:77

status = TX_SUCCESS;

txe_thread_reset.c:84

status = TX_THREAD_ERROR;

txe_thread_reset.c:91

status = TX_THREAD_ERROR;

txe_thread_reset.c:99

status = TX_CALLER_ERROR;

txe_thread_reset.c:114

status = TX_CALLER_ERROR;

txe_thread_reset.c:123

if (status == TX_SUCCESS)

txe_thread_reset.c:128

UINT _txe_thread_resume(TX_THREAD *thread_ptr)

txe_thread_resume.c:72

UINT status;

txe_thread_resume.c:75

status = TX_THREAD_ERROR;

txe_thread_resume.c:83

status = TX_THREAD_ERROR;

txe_thread_resume.c:91

UINT _txe_thread_suspend(TX_THREAD *thread_ptr)

txe_thread_suspend.c:74

UINT status;

txe_thread_suspend.c:77

status = TX_THREAD_ERROR;

txe_thread_suspend.c:85

status = TX_THREAD_ERROR;

txe_thread_suspend.c:93

txe_thread_terminate.c:75

UINT _txe_thread_terminate(TX_THREAD *thread_ptr)

txe_thread_terminate.c:78

UINT status;

txe_thread_terminate.c:86

status = TX_THREAD_ERROR;

txe_thread_terminate.c:94

status = TX_THREAD_ERROR;

txe_thread_terminate.c:102

status = TX_CALLER_ERROR;

txe_thread_time_slice_change.c:77

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

txe_thread_time_slice_change.c:80

UINT status;

txe_thread_time_slice_change.c:88

status = TX_THREAD_ERROR;

txe_thread_time_slice_change.c:96

status = TX_THREAD_ERROR;

txe_thread_time_slice_change.c:104

status = TX_PTR_ERROR;

txe_thread_time_slice_change.c:112

status = TX_CALLER_ERROR;

txe_thread_wait_abort.c:72

UINT _txe_thread_wait_abort(TX_THREAD *thread_ptr)

txe_thread_wait_abort.c:75

UINT status;

txe_thread_wait_abort.c:83

status = TX_THREAD_ERROR;

txe_thread_wait_abort.c:91

status = TX_THREAD_ERROR;

UINT _txe_timer_activate(TX_TIMER *timer_ptr)

txe_timer_activate.c:74

UINT status;

txe_timer_activate.c:77

status = TX_TIMER_ERROR;

txe_timer_activate.c:84

status = TX_TIMER_ERROR;

txe_timer_activate.c:91

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

txe_timer_change.c:79

UINT status;

txe_timer_change.c:82

status = TX_TIMER_ERROR;

txe_timer_change.c:90

status = TX_TIMER_ERROR;

txe_timer_change.c:98

status = TX_TICK_ERROR;

txe_timer_change.c:106

status = TX_CALLER_ERROR;

txe_timer_change.c:114

UINT _txe_timer_create(TX_TIMER *timer_ptr, CHAR *name_ptr,

txe_timer_create.c:85

ULONG initial_ticks, ULONG reschedule_ticks, UINT auto_activate, UINT timer_control_block_size)

txe_timer_create.c:87

_txe_timer_create()::auto_activate

txe_timer_create.c:90

UINT status;

txe_timer_create.c:92

status = TX_SUCCESS;

txe_timer_create.c:101

status = TX_TIMER_ERROR;

txe_timer_create.c:108

status = TX_TIMER_ERROR;

txe_timer_create.c:116

status = TX_TIMER_ERROR;

txe_timer_create.c:166

status = TX_TICK_ERROR;

txe_timer_create.c:174

if (auto_activate != TX_AUTO_ACTIVATE)

txe_timer_create.c:180

if (auto_activate != TX_NO_ACTIVATE)

txe_timer_create.c:184

status = TX_ACTIVATE_ERROR;

txe_timer_create.c:188

if (status == TX_SUCCESS)

txe_timer_create.c:195

status = TX_CALLER_ERROR;

txe_timer_create.c:208

status = TX_CALLER_ERROR;

txe_timer_create.c:221

if (status == TX_SUCCESS)

txe_timer_create.c:228

txe_timer_deactivate.c:73

UINT _txe_timer_deactivate(TX_TIMER *timer_ptr)

txe_timer_deactivate.c:76

UINT status;

txe_timer_deactivate.c:84

status = TX_TIMER_ERROR;

txe_timer_deactivate.c:92

status = TX_TIMER_ERROR;

UINT _txe_timer_delete(TX_TIMER *timer_ptr)

txe_timer_delete.c:75

UINT status;

txe_timer_delete.c:78

status = TX_SUCCESS;

txe_timer_delete.c:87

status = TX_TIMER_ERROR;

txe_timer_delete.c:94

status = TX_TIMER_ERROR;

txe_timer_delete.c:101

status = TX_CALLER_ERROR;

txe_timer_delete.c:111

status = TX_CALLER_ERROR;

txe_timer_delete.c:126

if (status == TX_SUCCESS)

txe_timer_delete.c:130

UINT _txe_timer_info_get(TX_TIMER *timer_ptr, CHAR **name, UINT *active, ULONG *remaining_ticks,

txe_timer_info_get.c:80

UINT status;

txe_timer_info_get.c:84

status = TX_TIMER_ERROR;

txe_timer_info_get.c:92

status = TX_TIMER_ERROR;

txe_timer_info_get.c:100

TXM_MODULE_INSTANCE_STRUCT

UINT txm_module_instance_maximum_priority;

txm_module.h:467

TXM_MODULE_INSTANCE_STRUCT::txm_module_instance_maximum_priority

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

txm_module.h:499

UINT txm_module_thread_entry_info_start_thread;

txm_module.h:500

TXM_MODULE_THREAD_ENTRY_INFO_STRUCT

TXM_MODULE_THREAD_ENTRY_INFO_STRUCT::txm_module_thread_entry_info_start_thread

extern UINT _txm_module_manager_object_pool_created;

txm_module.h:604

_txm_module_manager_object_pool_created

extern UINT _txm_module_manager_ready;

txm_module.h:607

_txm_module_manager_ready

UINT _txm_module_manager_application_request(ULONG request, ALIGN_TYPE param_1, ALIGN_TYPE param_2, ALIGN_TYPE param_3);

txm_module.h:615

_txm_module_manager_application_request()

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

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

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_properties_get(TXM_MODULE_INSTANCE *module_instance, ULONG *module_properties_ptr);

txm_module.h:632

UINT _txm_module_manager_start(TXM_MODULE_INSTANCE *module_instance);

txm_module.h:633

UINT _txm_module_manager_stop(TXM_MODULE_INSTANCE *module_instance);

txm_module.h:634

_txm_module_manager_thread_create()

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 *stack_start, ULONG stack_size, UINT priority, UINT preempt_threshold,

txm_module.h:637

_txm_module_manager_thread_create()

_txm_module_manager_thread_create()::priority

ULONG time_slice, UINT auto_start, UINT thread_control_block_size, TXM_MODULE_INSTANCE *module_instance);

txm_module.h:638

_txm_module_manager_thread_create()

_txm_module_manager_thread_create()::auto_start

UINT _txm_module_manager_thread_reset(TX_THREAD *thread_ptr);

txm_module.h:639

_txm_module_manager_thread_reset()

UINT _txm_module_manager_unload(TXM_MODULE_INSTANCE *module_instance);

txm_module.h:642

_txm_module_manager_unload()

UINT _txm_module_manager_maximum_module_priority_set(TXM_MODULE_INSTANCE *module_instance, UINT priority);

txm_module.h:644

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

txm_module.h:645

_txm_module_manager_thread_notify_trampoline()

VOID _txm_module_manager_thread_notify_trampoline(TX_THREAD *thread_ptr, UINT type);

txm_module.h:678

_txm_module_manager_thread_notify_trampoline()::type

TXM_MODULE_MANAGER_ADDITIONAL_PROTOTYPES

txm_module.h:684

_txm_module_manager_memory_fault_notify()

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

txm_module_manager_absolute_load.c:77

txm_module_manager_absolute_load.c:80

txm_module_manager_absolute_load.c:86

UINT status;

txm_module_manager_absolute_load.c:110

return(TX_CALLER_ERROR);

txm_module_manager_absolute_load.c:115

txm_module_manager_absolute_load.c:119

return(TX_NOT_AVAILABLE);

txm_module_manager_absolute_load.c:127

return(TX_PTR_ERROR);

txm_module_manager_absolute_load.c:206

if (status != TX_SUCCESS)

txm_module_manager_absolute_load.c:280

return(TX_NO_MEMORY);

txm_module_manager_absolute_load.c:438

return(TX_SUCCESS);

txm_module_manager_application_request.c:75

UINT _txm_module_manager_application_request(ULONG request_id, ALIGN_TYPE param_1, ALIGN_TYPE param_2, ALIGN_TYPE param_3)

_txm_module_manager_application_request()

return(TX_NOT_AVAILABLE);

txm_module_manager_application_request.c:78

_txm_module_manager_application_request()

txm_module_manager_callback_request.c:73

txm_module_manager_callback_request.c:76

UINT enqueued;

txm_module_manager_callback_request.c:77

UINT found;

txm_module_manager_callback_request.c:78

UINT status;

txm_module_manager_callback_request.c:97

found = TX_FALSE;

txm_module_manager_callback_request.c:121

found = TX_TRUE;

txm_module_manager_callback_request.c:146

if (found == TX_FALSE)

txm_module_manager_callback_request.c:153

if (status != TX_SUCCESS)

txm_module_manager_dispatch.h:68

if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_CREATION(module_instance, param_0, sizeof(TX_BLOCK_POOL)))

_txm_module_manager_tx_block_pool_create_dispatch()

(UINT) extra_parameters[3]

txm_module_manager_dispatch.h:87

_txm_module_manager_tx_block_pool_create_dispatch()

if (return_value == TX_SUCCESS)

txm_module_manager_dispatch.h:113

_txm_module_manager_tx_block_pool_delete_dispatch()

if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_CREATION(module_instance, param_0, sizeof(TX_BYTE_POOL)))

txm_module_manager_dispatch.h:373

_txm_module_manager_tx_byte_pool_create_dispatch()

(UINT) extra_parameters[2]

txm_module_manager_dispatch.h:391

_txm_module_manager_tx_byte_pool_create_dispatch()

if (return_value == TX_SUCCESS)

txm_module_manager_dispatch.h:417

_txm_module_manager_tx_byte_pool_delete_dispatch()

if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_CREATION(module_instance, param_0, sizeof(TX_EVENT_FLAGS_GROUP)))

txm_module_manager_dispatch.h:671

_txm_module_manager_tx_event_flags_create_dispatch()

(UINT) param_2

txm_module_manager_dispatch.h:681

_txm_module_manager_tx_event_flags_create_dispatch()

if (return_value == TX_SUCCESS)

txm_module_manager_dispatch.h:707

_txm_module_manager_tx_event_flags_delete_dispatch()

(UINT) extra_parameters[0],

txm_module_manager_dispatch.h:743

_txm_module_manager_tx_event_flags_get_dispatch()

(UINT) param_2

txm_module_manager_dispatch.h:906

_txm_module_manager_tx_event_flags_set_dispatch()

return(TX_GROUP_ERROR);

txm_module_manager_dispatch.h:931

_txm_module_manager_tx_event_flags_set_notify_dispatch()

if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_CREATION(module_instance, param_0, sizeof(TX_MUTEX)))

txm_module_manager_dispatch.h:972

_txm_module_manager_tx_mutex_create_dispatch()

(UINT) extra_parameters[0],

txm_module_manager_dispatch.h:985

_txm_module_manager_tx_mutex_create_dispatch()

(UINT) extra_parameters[1]

txm_module_manager_dispatch.h:986

_txm_module_manager_tx_mutex_create_dispatch()

if (return_value == TX_SUCCESS)

txm_module_manager_dispatch.h:1012

_txm_module_manager_tx_mutex_delete_dispatch()

if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_CREATION(module_instance, param_0, sizeof(TX_QUEUE)))

txm_module_manager_dispatch.h:1264

_txm_module_manager_tx_queue_create_dispatch()

(UINT) extra_parameters[0],

txm_module_manager_dispatch.h:1280

_txm_module_manager_tx_queue_create_dispatch()

(UINT) extra_parameters[3]

txm_module_manager_dispatch.h:1283

_txm_module_manager_tx_queue_create_dispatch()

if (return_value == TX_SUCCESS)

txm_module_manager_dispatch.h:1309

_txm_module_manager_tx_queue_delete_dispatch()

return(TX_QUEUE_ERROR);

txm_module_manager_dispatch.h:1636

_txm_module_manager_tx_queue_send_notify_dispatch()

if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_CREATION(module_instance, param_0, sizeof(TX_SEMAPHORE)))

txm_module_manager_dispatch.h:1701

_txm_module_manager_tx_semaphore_create_dispatch()

(UINT) extra_parameters[1]

txm_module_manager_dispatch.h:1715

_txm_module_manager_tx_semaphore_create_dispatch()

if (return_value == TX_SUCCESS)

txm_module_manager_dispatch.h:1741

_txm_module_manager_tx_semaphore_delete_dispatch()

return(TX_SEMAPHORE_ERROR);

txm_module_manager_dispatch.h:1971

_txm_module_manager_tx_semaphore_put_notify_dispatch()

if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_CREATION(module_instance, param_0, sizeof(TX_THREAD)))

txm_module_manager_dispatch.h:2019

txm_module_manager_dispatch.h:2032

return(TX_PRIORITY_ERROR);

txm_module_manager_dispatch.h:2035

return(TX_THRESH_ERROR);

txm_module_manager_dispatch.h:2046

(UINT) extra_parameters[4],

txm_module_manager_dispatch.h:2047

(UINT) extra_parameters[5],

txm_module_manager_dispatch.h:2049

(UINT) extra_parameters[7],

txm_module_manager_dispatch.h:2050

(UINT) extra_parameters[8],

txm_module_manager_dispatch.h:2077

if (return_value == TX_SUCCESS)

_txm_module_manager_tx_thread_delete_dispatch()

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

txm_module_manager_dispatch.h:2096

return(TX_THREAD_ERROR);

txm_module_manager_dispatch.h:2105

_txm_module_manager_tx_thread_entry_exit_notify_dispatch()

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

if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], sizeof(UINT)))

txm_module_manager_dispatch.h:2176

txm_module_manager_dispatch.h:2182

if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[2], sizeof(UINT)))

txm_module_manager_dispatch.h:2185

if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[3], sizeof(UINT)))

txm_module_manager_dispatch.h:2201

(UINT *) extra_parameters[0],

txm_module_manager_dispatch.h:2203

(UINT *) extra_parameters[2],

txm_module_manager_dispatch.h:2204

(UINT *) extra_parameters[3],

txm_module_manager_dispatch.h:2226

(UINT) param_0

_txm_module_manager_tx_thread_interrupt_control_dispatch()

if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_2, sizeof(UINT)))

txm_module_manager_dispatch.h:2398

_txm_module_manager_tx_thread_preemption_change_dispatch()

(UINT) param_1,

txm_module_manager_dispatch.h:2404

_txm_module_manager_tx_thread_preemption_change_dispatch()

(UINT *) param_2

txm_module_manager_dispatch.h:2405

_txm_module_manager_tx_thread_preemption_change_dispatch()

if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_2, sizeof(UINT)))

txm_module_manager_dispatch.h:2427

_txm_module_manager_tx_thread_priority_change_dispatch()

(UINT) param_1,

txm_module_manager_dispatch.h:2433

_txm_module_manager_tx_thread_priority_change_dispatch()

(UINT *) param_2

txm_module_manager_dispatch.h:2434

_txm_module_manager_tx_thread_priority_change_dispatch()

return(TX_SUCCESS);

txm_module_manager_dispatch.h:2446

_txm_module_manager_tx_thread_relinquish_dispatch()

txm_module_manager_dispatch.h:2558

_txm_module_manager_tx_thread_system_suspend_dispatch()

thread_ptr -> tx_thread_state = TX_COMPLETED;

txm_module_manager_dispatch.h:2581

_txm_module_manager_tx_thread_system_suspend_dispatch()

thread_ptr -> tx_thread_suspending = TX_TRUE;

txm_module_manager_dispatch.h:2587

_txm_module_manager_tx_thread_system_suspend_dispatch()

return(TX_SUCCESS);

txm_module_manager_dispatch.h:2604

_txm_module_manager_tx_thread_system_suspend_dispatch()

return(TX_SUCCESS);

txm_module_manager_dispatch.h:2703

_txm_module_manager_tx_time_set_dispatch()

if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_CREATION(module_instance, param_0, sizeof(TX_TIMER)))

txm_module_manager_dispatch.h:2775

txm_module_manager_dispatch.h:2806

(UINT) extra_parameters[4],

txm_module_manager_dispatch.h:2807

(UINT) extra_parameters[5]

txm_module_manager_dispatch.h:2810

if (return_value == TX_SUCCESS)

txm_module_manager_dispatch.h:2870

if (return_value == TX_SUCCESS)

_txm_module_manager_tx_timer_delete_dispatch()

if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], sizeof(UINT)))

txm_module_manager_dispatch.h:2903

_txm_module_manager_tx_timer_info_get_dispatch()

(UINT *) extra_parameters[0],

txm_module_manager_dispatch.h:2919

_txm_module_manager_tx_timer_info_get_dispatch()

(UINT) param_0

txm_module_manager_dispatch.h:3122

_txm_module_manager_tx_trace_interrupt_control_dispatch()

return(TX_SUCCESS);

txm_module_manager_dispatch.h:3141

_txm_module_manager_tx_trace_isr_enter_insert_dispatch()

return(TX_SUCCESS);

txm_module_manager_dispatch.h:3158

_txm_module_manager_tx_trace_isr_exit_insert_dispatch()

if (_txm_module_manager_object_pool_created == TX_TRUE)

txm_module_manager_dispatch.h:3232

_txm_module_manager_txm_module_object_deallocate_dispatch()

(UINT) param_0,

txm_module_manager_dispatch.h:3289

_txm_module_manager_txm_module_object_pointer_get_dispatch()

(UINT) param_0,

txm_module_manager_dispatch.h:3322

_txm_module_manager_txm_module_object_pointer_get_extended_dispatch()

(UINT) extra_parameters[0],

txm_module_manager_dispatch.h:3324

_txm_module_manager_txm_module_object_pointer_get_extended_dispatch()

txm_module_manager_event_flags_notify_trampoline.c:74

_txm_module_manager_event_flags_notify_trampoline()

UINT _txm_module_manager_external_memory_enable(TXM_MODULE_INSTANCE *module_instance,

txm_module_manager_external_memory_enable.c:76

txm_module_manager_external_memory_enable.c:79

UINT attributes)

_txm_module_manager_external_memory_enable()::attributes

UINT attributes_check = 0;

txm_module_manager_external_memory_enable.c:197

txm_module_manager_external_memory_enable.c:201

txm_module_manager_external_memory_enable.c:204

return(TX_NOT_AVAILABLE);

txm_module_manager_external_memory_enable.c:211

return(TX_PTR_ERROR);

txm_module_manager_external_memory_enable.c:224

return(TX_PTR_ERROR);

txm_module_manager_external_memory_enable.c:234

return(TX_START_ERROR);

txm_module_manager_external_memory_enable.c:292

return(TX_SUCCESS);

txm_module_manager_in_place_load.c:76

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:83

UINT status;

txm_module_manager_in_place_load.c:104

if (status != TX_SUCCESS)

txm_module_manager_initialize.c:63

UINT _txm_module_manager_object_pool_created;

_txm_module_manager_object_pool_created

UINT _txm_module_manager_ready;

txm_module_manager_initialize.c:84

_txm_module_manager_ready

UINT _txm_module_manager_initialize(VOID *module_memory_start, ULONG module_memory_size)

txm_module_manager_initialize.c:140

txm_module_manager_initialize.c:152

return(TX_CALLER_ERROR);

txm_module_manager_initialize.c:163

_txm_module_manager_ready = TX_FALSE;

txm_module_manager_initialize.c:172

_tx_mutex_create(&_txm_module_manager_mutex, "Module Manager Protection Mutex", TX_NO_INHERIT);

_txm_module_manager_object_pool_created = TX_FALSE;

txm_module_manager_initialize.c:178

txm_module_manager_initialize.c:181

_txm_module_manager_ready = TX_TRUE;

txm_module_manager_initialize.c:184

return(TX_SUCCESS);

txm_module_manager_internal_load.c:79

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

txm_module_manager_internal_load.c:83

txm_module_manager_internal_load.c:101

UINT status;

txm_module_manager_internal_load.c:113

return(TX_CALLER_ERROR);

txm_module_manager_internal_load.c:118

txm_module_manager_internal_load.c:122

return(TX_NOT_AVAILABLE);

txm_module_manager_internal_load.c:130

return(TX_PTR_ERROR);

txm_module_manager_internal_load.c:270

return(TX_NO_MEMORY);

txm_module_manager_internal_load.c:423

return(TX_SUCCESS);

txm_module_manager_kernel_dispatch.c:100

ALIGN_TYPE return_value = TX_NOT_AVAILABLE;

_txm_module_manager_kernel_dispatch()

UINT _txm_module_manager_maximum_module_priority_set(TXM_MODULE_INSTANCE *module_instance, UINT priority)

txm_module_manager_maximum_module_priority_set.c:69

txm_module_manager_maximum_module_priority_set.c:72

txm_module_manager_maximum_module_priority_set.c:75

return(TX_NOT_AVAILABLE);

txm_module_manager_maximum_module_priority_set.c:82

return(TX_PTR_ERROR);

txm_module_manager_maximum_module_priority_set.c:95

return(TX_PTR_ERROR);

txm_module_manager_maximum_module_priority_set.c:105

return(TX_START_ERROR);

txm_module_manager_maximum_module_priority_set.c:115

return(TX_SUCCESS);

txm_module_manager_memory_fault_notify.c:77

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

_txm_module_manager_memory_fault_notify()

return(TX_SUCCESS);

txm_module_manager_memory_fault_notify.c:83

_txm_module_manager_memory_fault_notify()

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

txm_module_manager_memory_load.c:77

txm_module_manager_memory_load.c:91

UINT status;

txm_module_manager_memory_load.c:110

if (status != TX_SUCCESS)

txm_module_manager_memory_load.c:121

if (status != TX_SUCCESS)

txm_module_manager_memory_load.c:125

return(TX_NO_MEMORY);

txm_module_manager_memory_load.c:150

if (status != TX_SUCCESS)

txm_module_manager_memory_load.c:161

return(TX_SUCCESS);

txm_module_manager_mm_register_setup.c:194

UINT srd_bit_index;

_txm_module_manager_calculate_srd_bits()

UINT mpu_register = 0;

txm_module_manager_mm_register_setup.c:483

_txm_module_manager_mm_register_setup()

UINT mpu_table_index;

txm_module_manager_mm_register_setup.c:484

_txm_module_manager_mm_register_setup()

UINT i;

txm_module_manager_mm_register_setup.c:485

_txm_module_manager_mm_register_setup()

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

txm_module_manager_object_allocate.c:76

UINT return_value;

txm_module_manager_object_allocate.c:105

if (return_value == TX_SUCCESS)

txm_module_manager_object_allocate.c:148

return_value = TX_NOT_AVAILABLE;

txm_module_manager_object_deallocate.c:69

UINT _txm_module_manager_object_deallocate(VOID *object_ptr)

txm_module_manager_object_deallocate.c:73

UINT return_value;

txm_module_manager_object_deallocate.c:97

return_value = TX_PTR_ERROR;

txm_module_manager_object_deallocate.c:131

return_value = TX_NOT_AVAILABLE;

txm_module_manager_object_pointer_get.c:82

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

txm_module_manager_object_pointer_get.c:85

UINT status;

txm_module_manager_object_pointer_get.c:89

status = _txm_module_manager_object_pointer_get_extended(object_type, name, TXM_MODULE_MANAGER_UTIL_MAX_VALUE_OF_TYPE_UNSIGNED(UINT), object_ptr);

txm_module_manager_object_pointer_get_extended.c:99

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:102

txm_module_manager_object_pointer_get_extended.c:113

UINT status;

txm_module_manager_object_pointer_get_extended.c:122

return(TX_PTR_ERROR);

txm_module_manager_object_pointer_get_extended.c:126

status = TX_NO_INSTANCE;

txm_module_manager_object_pointer_get_extended.c:162

status = TX_SUCCESS;

txm_module_manager_object_pointer_get_extended.c:193

status = TX_SUCCESS;

txm_module_manager_object_pointer_get_extended.c:224

status = TX_SUCCESS;

txm_module_manager_object_pointer_get_extended.c:255

status = TX_SUCCESS;

txm_module_manager_object_pointer_get_extended.c:286

status = TX_SUCCESS;

txm_module_manager_object_pointer_get_extended.c:317

status = TX_SUCCESS;

txm_module_manager_object_pointer_get_extended.c:365

status = TX_SUCCESS;

txm_module_manager_object_pointer_get_extended.c:413

status = TX_SUCCESS;

txm_module_manager_object_pointer_get_extended.c:429

status = TX_OPTION_ERROR;

txm_module_manager_object_pool_create.c:70

UINT _txm_module_manager_object_pool_create(VOID *object_memory, ULONG object_memory_size)

_txm_module_manager_object_pool_created = TX_TRUE;

txm_module_manager_object_pool_create.c:77

txm_module_manager_object_pool_create.c:80

return(TX_SUCCESS);

txm_module_manager_properties_get.c:66

UINT _txm_module_manager_properties_get(TXM_MODULE_INSTANCE *module_instance, ULONG *module_properties_ptr)

txm_module_manager_properties_get.c:70

txm_module_manager_properties_get.c:74

return(TX_NOT_AVAILABLE);

txm_module_manager_properties_get.c:82

return(TX_PTR_ERROR);

txm_module_manager_properties_get.c:90

return(TX_PTR_ERROR);

txm_module_manager_properties_get.c:98

return(TX_PTR_ERROR);

txm_module_manager_properties_get.c:105

return(TX_SUCCESS);

txm_module_manager_queue_notify_trampoline.c:71

_txm_module_manager_queue_notify_trampoline()

txm_module_manager_semaphore_notify_trampoline.c:72

_txm_module_manager_semaphore_notify_trampoline()

UINT _txm_module_manager_start(TXM_MODULE_INSTANCE *module_instance)

txm_module_manager_start.c:76

txm_module_manager_start.c:79

UINT status;

txm_module_manager_start.c:83

txm_module_manager_start.c:87

return(TX_NOT_AVAILABLE);

txm_module_manager_start.c:95

return(TX_PTR_ERROR);

txm_module_manager_start.c:109

return(TX_PTR_ERROR);

txm_module_manager_start.c:120

return(TX_START_ERROR);

txm_module_manager_start.c:132

return(TX_PRIORITY_ERROR);

txm_module_manager_start.c:147

return(TX_START_ERROR);

txm_module_manager_start.c:158

(UINT) module_instance -> txm_module_instance_start_stop_priority,

txm_module_manager_start.c:159

(UINT) module_instance -> txm_module_instance_start_stop_priority,

txm_module_manager_start.c:161

TX_DONT_START,

txm_module_manager_start.c:166

if (status != TX_SUCCESS)

txm_module_manager_start.c:187

(UINT) module_instance -> txm_module_instance_callback_priority,

txm_module_manager_start.c:188

(UINT) module_instance -> txm_module_instance_callback_priority,

txm_module_manager_start.c:190

TX_DONT_START,

txm_module_manager_start.c:195

if (status != TX_SUCCESS)

txm_module_manager_start.c:225

return(TX_SUCCESS);

txm_module_manager_stop.c:117

UINT _txm_module_manager_stop(TXM_MODULE_INSTANCE *module_instance)

txm_module_manager_stop.c:120

txm_module_manager_stop.c:145

return(TX_CALLER_ERROR);

txm_module_manager_stop.c:153

return(TX_CALLER_ERROR);

txm_module_manager_stop.c:163

return(TX_CALLER_ERROR);

txm_module_manager_stop.c:168

txm_module_manager_stop.c:172

return(TX_NOT_AVAILABLE);

txm_module_manager_stop.c:180

return(TX_PTR_ERROR);

txm_module_manager_stop.c:194

return(TX_PTR_ERROR);

txm_module_manager_stop.c:205

return(TX_START_ERROR);

txm_module_manager_stop.c:229

(UINT) module_instance -> txm_module_instance_start_stop_priority,

txm_module_manager_stop.c:230

(UINT) module_instance -> txm_module_instance_start_stop_priority,

txm_module_manager_stop.c:232

TX_AUTO_START,

txm_module_manager_stop.c:238

while ((i < TXM_MODULE_TIMEOUT) && (module_instance -> txm_module_instance_start_stop_thread.tx_thread_state != TX_COMPLETED))