Release 6.1.9

1 files changed, 114 insertions, 111 deletions

diff --git a/common_smp/inc/tx_api.h b/common_smp/inc/tx_api.h
index e57fd4b6..5910c803 100644
--- a/common_smp/inc/tx_api.h
+++ b/common_smp/inc/tx_api.h
@@ -26,7 +26,7 @@
 /*  APPLICATION INTERFACE DEFINITION                       RELEASE        */
 /*                                                                        */
 /*    tx_api.h                                            PORTABLE SMP    */
-/*                                                           6.1.8        */
+/*                                                           6.1.9        */
 /*  AUTHOR                                                                */
 /*                                                                        */
 /*    William E. Lamie, Microsoft Corporation                             */
@@ -64,6 +64,9 @@
 /*  08-02-2021      Scott Larson            Modified comment(s), and      */
 /*                                            update patch number,        */
 /*                                            resulting in version 6.1.8  */
+/*  10-15-2021      Yuxin Zhou              Modified comment(s),          */
+/*                                            update patch number,        */
+/*                                            resulting in version 6.1.9  */
 /*                                                                        */
 /**************************************************************************/
 
@@ -106,13 +109,13 @@ extern   "C" {
 /* Define basic constants for the ThreadX kernel.  */
 
 
-/* Define the major/minor version information that can be used by the application 
+/* Define the major/minor version information that can be used by the application
    and the ThreadX source as well.  */
-   
+
 #define AZURE_RTOS_THREADX
 #define THREADX_MAJOR_VERSION           6
 #define THREADX_MINOR_VERSION           1
-#define THREADX_PATCH_VERSION           8
+#define THREADX_PATCH_VERSION           9
 
 /* Define the following symbol for backward compatibility */
 #define EL_PRODUCT_THREADX
@@ -219,16 +222,16 @@ extern   "C" {
 #endif
 
 
-/* Event numbers 0 through 4095 are reserved by Azure RTOS. Specific event assignments are: 
-                                
-                                ThreadX events:     1-199 
+/* Event numbers 0 through 4095 are reserved by Azure RTOS. Specific event assignments are:
+
+                                ThreadX events:     1-199
                                 FileX events:       200-299
                                 NetX events:        300-599
                                 USBX events:        600-999
                                 GUIX events:        1000-1500
-   
-   User-defined event numbers start at 4096 and continue through 65535, as defined by the constants 
-   TX_TRACE_USER_EVENT_START and TX_TRACE_USER_EVENT_END, respectively. User events should be based 
+
+   User-defined event numbers start at 4096 and continue through 65535, as defined by the constants
+   TX_TRACE_USER_EVENT_START and TX_TRACE_USER_EVENT_END, respectively. User events should be based
    on these constants in case the user event number assignment is changed in future releases.  */
 
 #define TX_TRACE_USER_EVENT_START           4096            /* I1, I2, I3, I4 are user defined           */
@@ -254,7 +257,7 @@ extern   "C" {
 
 /* Define basic alignment type used in block and byte pool operations. This data type must
    be at least 32-bits in size and also be large enough to hold a pointer type.  */
-   
+
 #ifndef ALIGN_TYPE_DEFINED
 #define ALIGN_TYPE      ULONG
 #endif
@@ -263,10 +266,10 @@ extern   "C" {
 /* Define the control block definitions for all system objects.  */
 
 
-/* Define the basic timer management structures.  These are the structures 
+/* Define the basic timer management structures.  These are the structures
    used to manage thread sleep, timeout, and user timer requests.  */
 
-/* Determine if the internal timer control block has an extension defined. If not, 
+/* Determine if the internal timer control block has an extension defined. If not,
    define the extension to whitespace.  */
 
 #ifndef TX_TIMER_INTERNAL_EXTENSION
@@ -311,7 +314,7 @@ typedef struct TX_TIMER_INTERNAL_STRUCT
 } TX_TIMER_INTERNAL;
 
 
-/* Determine if the timer control block has an extension defined. If not, 
+/* Determine if the timer control block has an extension defined. If not,
    define the extension to whitespace.  */
 
 #ifndef TX_TIMER_EXTENSION
@@ -363,7 +366,7 @@ typedef struct TX_TIMER_STRUCT
 } TX_TIMER;
 
 
-/* Determine if the thread priority change extension is defined. If not, define the 
+/* Determine if the thread priority change extension is defined. If not, define the
    extension to whitespace.  */
 
 #ifndef TX_THREAD_PRIORITY_CHANGE_EXTENSION
@@ -378,7 +381,7 @@ typedef struct TX_TIMER_STRUCT
 typedef struct TX_THREAD_STRUCT
 {
     /* The first section of the control block contains critical
-       information that is referenced by the port-specific 
+       information that is referenced by the port-specific
        assembly language code.  Any changes in this section could
        necessitate changes in the assembly language.  */
 
@@ -398,38 +401,38 @@ typedef struct TX_THREAD_STRUCT
 
     /***************************************************************/
 
-    /* Define the first port extension in the thread control block. This 
+    /* Define the first port extension in the thread control block. This
        is typically defined to whitespace or a pointer type in tx_port.h.  */
     TX_THREAD_EXTENSION_0
-         
+
     CHAR                *tx_thread_name;                /* Pointer to thread's name     */
     UINT                tx_thread_priority;             /* Priority of thread (0-1023)  */
     UINT                tx_thread_state;                /* Thread's execution state     */
     UINT                tx_thread_delayed_suspend;      /* Delayed suspend flag         */
     UINT                tx_thread_suspending;           /* Thread suspending flag       */
     UINT                tx_thread_preempt_threshold;    /* Preemption threshold         */
-    
-    /* Define the thread schedule hook. The usage of this is port/application specific, 
+
+    /* Define the thread schedule hook. The usage of this is port/application specific,
        but when used, the function pointer designated is called whenever the thread is
        scheduled and unscheduled.  */
     VOID                (*tx_thread_schedule_hook)(struct TX_THREAD_STRUCT *thread_ptr, ULONG id);
 
     /* Nothing after this point is referenced by the target-specific
-       assembly language.  Hence, information after this point can 
-       be added to the control block providing the complete system 
+       assembly language.  Hence, information after this point can
+       be added to the control block providing the complete system
        is recompiled.  */
 
     /* Define the thread's entry point and input parameter.  */
     VOID                (*tx_thread_entry)(ULONG id);
     ULONG               tx_thread_entry_parameter;
 
-    /* Define the thread's timer block.   This is used for thread 
+    /* Define the thread's timer block.   This is used for thread
        sleep and timeout requests.  */
     TX_TIMER_INTERNAL   tx_thread_timer;
 
     /* Define the thread's cleanup function and associated data.  This
-       is used to cleanup various data structures when a thread 
-       suspension is lifted or terminated either by the user or 
+       is used to cleanup various data structures when a thread
+       suspension is lifted or terminated either by the user or
        a timeout.  */
     VOID                (*tx_thread_suspend_cleanup)(struct TX_THREAD_STRUCT *thread_ptr, ULONG suspension_sequence);
     VOID                *tx_thread_suspend_control_block;
@@ -441,11 +444,11 @@ typedef struct TX_THREAD_STRUCT
     UINT                tx_thread_suspend_option;
     UINT                tx_thread_suspend_status;
 
-    /* Define the second port extension in the thread control block. This 
+    /* Define the second port extension in the thread control block. This
        is typically defined to whitespace or a pointer type in tx_port.h.  */
     TX_THREAD_EXTENSION_1
 
-    /* Define pointers to the next and previous threads in the 
+    /* Define pointers to the next and previous threads in the
        created list.  */
     struct TX_THREAD_STRUCT
                         *tx_thread_created_next,
@@ -454,12 +457,12 @@ typedef struct TX_THREAD_STRUCT
     /************* Define ThreadX SMP thread control block extensions.  *************/
 
     UINT                tx_thread_smp_core_mapped;
-    ULONG               tx_thread_smp_core_control; 
+    ULONG               tx_thread_smp_core_control;
     UINT                tx_thread_smp_core_executing;
 
     /************* End of ThreadX SMP thread control block extensions.  *************/
-    
-    /* Define the third port extension in the thread control block. This 
+
+    /* Define the third port extension in the thread control block. This
        is typically defined to whitespace in tx_port.h.  */
     TX_THREAD_EXTENSION_2
 
@@ -475,14 +478,14 @@ typedef struct TX_THREAD_STRUCT
 #ifndef TX_NO_FILEX_POINTER
     VOID                *tx_thread_filex_ptr;
 #endif
-    
+
     /* Define the priority inheritance variables. These will be used
-       to manage priority inheritance changes applied to this thread 
+       to manage priority inheritance changes applied to this thread
        as a result of mutex get operations.  */
     UINT                tx_thread_user_priority;
     UINT                tx_thread_user_preempt_threshold;
     UINT                tx_thread_inherit_priority;
-    
+
     /* Define the owned mutex count and list head pointer.  */
     UINT                tx_thread_owned_mutex_count;
     struct TX_MUTEX_STRUCT
@@ -496,7 +499,7 @@ typedef struct TX_THREAD_STRUCT
     /* Define the number of times this thread suspends.  */
     ULONG               tx_thread_performance_suspend_count;
 
-    /* Define the number of times this thread is preempted by calling 
+    /* Define the number of times this thread is preempted by calling
        a ThreadX API service.  */
     ULONG               tx_thread_performance_solicited_preemption_count;
 
@@ -531,22 +534,22 @@ typedef struct TX_THREAD_STRUCT
 
 #ifndef TX_DISABLE_NOTIFY_CALLBACKS
 
-    /* Define the application callback routine used to notify the application when 
+    /* Define the application callback routine used to notify the application when
        the thread is entered or exits.  */
     VOID                (*tx_thread_entry_exit_notify)(struct TX_THREAD_STRUCT *thread_ptr, UINT type);
 #endif
 
-    /* Define the fourth port extension in the thread control block. This 
+    /* Define the fourth port extension in the thread control block. This
        is typically defined to whitespace in tx_port.h.  */
     TX_THREAD_EXTENSION_3
 
-    /* Define suspension sequence number.  This is used to ensure suspension is still valid when 
+    /* Define suspension sequence number.  This is used to ensure suspension is still valid when
        cleanup routine executes.  */
     ULONG               tx_thread_suspension_sequence;
 
-    /* Define the user extension field.  This typically is defined 
-       to white space, but some ports of ThreadX may need to have 
-       additional fields in the thread control block.  This is 
+    /* Define the user extension field.  This typically is defined
+       to white space, but some ports of ThreadX may need to have
+       additional fields in the thread control block.  This is
        defined in the file tx_port.h.  */
     TX_THREAD_USER_EXTENSION
 
@@ -608,14 +611,14 @@ typedef struct TX_BLOCK_POOL_STRUCT
     ULONG               tx_block_pool_performance_timeout_count;
 #endif
 
-    /* Define the port extension in the block pool control block. This 
+    /* Define the port extension in the block pool control block. This
        is typically defined to whitespace in tx_port.h.  */
     TX_BLOCK_POOL_EXTENSION
 
 } TX_BLOCK_POOL;
 
 
-/* Determine if the byte allocate extension is defined. If not, define the 
+/* Determine if the byte allocate extension is defined. If not, define the
    extension to whitespace.  */
 
 #ifndef TX_BYTE_ALLOCATE_EXTENSION
@@ -623,7 +626,7 @@ typedef struct TX_BLOCK_POOL_STRUCT
 #endif
 
 
-/* Determine if the byte release extension is defined. If not, define the 
+/* Determine if the byte release extension is defined. If not, define the
    extension to whitespace.  */
 
 #ifndef TX_BYTE_RELEASE_EXTENSION
@@ -703,7 +706,7 @@ typedef struct TX_BYTE_POOL_STRUCT
     ULONG               tx_byte_pool_performance_timeout_count;
 #endif
 
-    /* Define the port extension in the byte pool control block. This 
+    /* Define the port extension in the byte pool control block. This
        is typically defined to whitespace in tx_port.h.  */
     TX_BYTE_POOL_EXTENSION
 
@@ -721,7 +724,7 @@ typedef struct TX_EVENT_FLAGS_GROUP_STRUCT
     /* Define the event flags group's name.  */
     CHAR                *tx_event_flags_group_name;
 
-    /* Define the actual current event flags in this group. A zero in a 
+    /* Define the actual current event flags in this group. A zero in a
        particular bit indicates the event flag is not set.  */
     ULONG               tx_event_flags_group_current;
 
@@ -760,19 +763,19 @@ typedef struct TX_EVENT_FLAGS_GROUP_STRUCT
 
 #ifndef TX_DISABLE_NOTIFY_CALLBACKS
 
-    /* Define the application callback routine used to notify the application when 
+    /* Define the application callback routine used to notify the application when
        an event flag is set.  */
     VOID                (*tx_event_flags_group_set_notify)(struct TX_EVENT_FLAGS_GROUP_STRUCT *group_ptr);
 #endif
 
-    /* Define the port extension in the event flags group control block. This 
+    /* Define the port extension in the event flags group control block. This
        is typically defined to whitespace in tx_port.h.  */
     TX_EVENT_FLAGS_GROUP_EXTENSION
 
 } TX_EVENT_FLAGS_GROUP;
 
 
-/* Determine if the mutex put extension 1 is defined. If not, define the 
+/* Determine if the mutex put extension 1 is defined. If not, define the
    extension to whitespace.  */
 
 #ifndef TX_MUTEX_PUT_EXTENSION_1
@@ -780,7 +783,7 @@ typedef struct TX_EVENT_FLAGS_GROUP_STRUCT
 #endif
 
 
-/* Determine if the mutex put extension 2 is defined. If not, define the 
+/* Determine if the mutex put extension 2 is defined. If not, define the
    extension to whitespace.  */
 
 #ifndef TX_MUTEX_PUT_EXTENSION_2
@@ -788,7 +791,7 @@ typedef struct TX_EVENT_FLAGS_GROUP_STRUCT
 #endif
 
 
-/* Determine if the mutex priority change extension is defined. If not, define the 
+/* Determine if the mutex priority change extension is defined. If not, define the
    extension to whitespace.  */
 
 #ifndef TX_MUTEX_PRIORITY_CHANGE_EXTENSION
@@ -862,7 +865,7 @@ typedef struct TX_MUTEX_STRUCT
     ULONG               tx_mutex_performance__priority_inheritance_count;
 #endif
 
-    /* Define the port extension in the mutex control block. This 
+    /* Define the port extension in the mutex control block. This
        is typically defined to whitespace in tx_port.h.  */
     TX_MUTEX_EXTENSION
 
@@ -891,7 +894,7 @@ typedef struct TX_QUEUE_STRUCT
     UINT                tx_queue_enqueued;
     UINT                tx_queue_available_storage;
 
-    /* Define pointers that represent the start and end for the queue's 
+    /* Define pointers that represent the start and end for the queue's
        message area.  */
     ULONG               *tx_queue_start;
     ULONG               *tx_queue_end;
@@ -936,12 +939,12 @@ typedef struct TX_QUEUE_STRUCT
 
 #ifndef TX_DISABLE_NOTIFY_CALLBACKS
 
-    /* Define the application callback routine used to notify the application when 
+    /* Define the application callback routine used to notify the application when
        the a message is sent to the queue.  */
     VOID                (*tx_queue_send_notify)(struct TX_QUEUE_STRUCT *queue_ptr);
 #endif
 
-    /* Define the port extension in the queue control block. This 
+    /* Define the port extension in the queue control block. This
        is typically defined to whitespace in tx_port.h.  */
     TX_QUEUE_EXTENSION
 
@@ -991,12 +994,12 @@ typedef struct TX_SEMAPHORE_STRUCT
 
 #ifndef TX_DISABLE_NOTIFY_CALLBACKS
 
-    /* Define the application callback routine used to notify the application when 
+    /* Define the application callback routine used to notify the application when
        the a semaphore is put.  */
     VOID                (*tx_semaphore_put_notify)(struct TX_SEMAPHORE_STRUCT *semaphore_ptr);
 #endif
 
-    /* Define the port extension in the semaphore control block. This 
+    /* Define the port extension in the semaphore control block. This
        is typically defined to whitespace in tx_port.h.  */
     TX_SEMAPHORE_EXTENSION
 
@@ -1042,7 +1045,7 @@ ULONG       _tx_thread_smp_current_state_get(void);
 ULONG       _tx_thread_smp_time_get(void);
 
 
-/* Determine if SMP Debug is selected.  If so, the function prototype is setup. Otherwise, the debug call is 
+/* Determine if SMP Debug is selected.  If so, the function prototype is setup. Otherwise, the debug call is
    simply mapped to whitespace.  */
 
 #ifdef TX_THREAD_SMP_DEBUG_ENABLE
@@ -1063,17 +1066,17 @@ void        _tx_thread_smp_debug_entry_insert(ULONG id, ULONG suspend, VOID *thr
 /************* End of ThreadX SMP function prototypes and remapping.  *************/
 
 
-/* Define the system API mappings based on the error checking 
-   selected by the user.  Note: this section is only applicable to 
+/* Define the system API mappings based on the error checking
+   selected by the user.  Note: this section is only applicable to
    application source code, hence the conditional that turns off this
    stuff when the include file is processed by the ThreadX source. */
 
 #ifndef TX_SOURCE_CODE
 
 
-/* Determine if error checking is desired.  If so, map API functions 
+/* Determine if error checking is desired.  If so, map API functions
    to the appropriate error checking front-ends.  Otherwise, map API
-   functions to the core functions that actually perform the work. 
+   functions to the core functions that actually perform the work.
    Note: error checking is enabled by default.  */
 
 #ifdef TX_DISABLE_ERROR_CHECKING
@@ -1463,8 +1466,8 @@ UINT        _tx_block_allocate(TX_BLOCK_POOL *pool_ptr, VOID **block_ptr, ULONG
 UINT        _tx_block_pool_create(TX_BLOCK_POOL *pool_ptr, CHAR *name_ptr, ULONG block_size,
                     VOID *pool_start, ULONG pool_size);
 UINT        _tx_block_pool_delete(TX_BLOCK_POOL *pool_ptr);
-UINT        _tx_block_pool_info_get(TX_BLOCK_POOL *pool_ptr, CHAR **name, ULONG *available_blocks, 
-                    ULONG *total_blocks, TX_THREAD **first_suspended, 
+UINT        _tx_block_pool_info_get(TX_BLOCK_POOL *pool_ptr, CHAR **name, ULONG *available_blocks,
+                    ULONG *total_blocks, TX_THREAD **first_suspended,
                     ULONG *suspended_count, TX_BLOCK_POOL **next_pool);
 UINT        _tx_block_pool_performance_info_get(TX_BLOCK_POOL *pool_ptr, ULONG *allocates, ULONG *releases,
                     ULONG *suspensions, ULONG *timeouts);
@@ -1474,15 +1477,15 @@ UINT        _tx_block_pool_prioritize(TX_BLOCK_POOL *pool_ptr);
 UINT        _tx_block_release(VOID *block_ptr);
 
 
-/* Define error checking shells for API services.  These are only referenced by the 
+/* Define error checking shells for API services.  These are only referenced by the
    application.  */
 
 UINT        _txe_block_allocate(TX_BLOCK_POOL *pool_ptr, VOID **block_ptr, ULONG wait_option);
 UINT        _txe_block_pool_create(TX_BLOCK_POOL *pool_ptr, CHAR *name_ptr, ULONG block_size,
                     VOID *pool_start, ULONG pool_size, UINT pool_control_block_size);
 UINT        _txe_block_pool_delete(TX_BLOCK_POOL *pool_ptr);
-UINT        _txe_block_pool_info_get(TX_BLOCK_POOL *pool_ptr, CHAR **name, ULONG *available_blocks, 
-                    ULONG *total_blocks, TX_THREAD **first_suspended, 
+UINT        _txe_block_pool_info_get(TX_BLOCK_POOL *pool_ptr, CHAR **name, ULONG *available_blocks,
+                    ULONG *total_blocks, TX_THREAD **first_suspended,
                     ULONG *suspended_count, TX_BLOCK_POOL **next_pool);
 UINT        _txe_block_pool_prioritize(TX_BLOCK_POOL *pool_ptr);
 UINT        _txe_block_release(VOID *block_ptr);
@@ -1495,8 +1498,8 @@ UINT        _tx_byte_allocate(TX_BYTE_POOL *pool_ptr, VOID **memory_ptr, ULONG m
 UINT        _tx_byte_pool_create(TX_BYTE_POOL *pool_ptr, CHAR *name_ptr, VOID *pool_start,
                     ULONG pool_size);
 UINT        _tx_byte_pool_delete(TX_BYTE_POOL *pool_ptr);
-UINT        _tx_byte_pool_info_get(TX_BYTE_POOL *pool_ptr, CHAR **name, ULONG *available_bytes, 
-                    ULONG *fragments, TX_THREAD **first_suspended, 
+UINT        _tx_byte_pool_info_get(TX_BYTE_POOL *pool_ptr, CHAR **name, ULONG *available_bytes,
+                    ULONG *fragments, TX_THREAD **first_suspended,
                     ULONG *suspended_count, TX_BYTE_POOL **next_pool);
 UINT        _tx_byte_pool_performance_info_get(TX_BYTE_POOL *pool_ptr, ULONG *allocates, ULONG *releases,
                     ULONG *fragments_searched, ULONG *merges, ULONG *splits, ULONG *suspensions, ULONG *timeouts);
@@ -1506,7 +1509,7 @@ UINT        _tx_byte_pool_prioritize(TX_BYTE_POOL *pool_ptr);
 UINT        _tx_byte_release(VOID *memory_ptr);
 
 
-/* Define error checking shells for API services.  These are only referenced by the 
+/* Define error checking shells for API services.  These are only referenced by the
    application.  */
 
 UINT        _txe_byte_allocate(TX_BYTE_POOL *pool_ptr, VOID **memory_ptr, ULONG memory_size,
@@ -1514,8 +1517,8 @@ UINT        _txe_byte_allocate(TX_BYTE_POOL *pool_ptr, VOID **memory_ptr, ULONG
 UINT        _txe_byte_pool_create(TX_BYTE_POOL *pool_ptr, CHAR *name_ptr, VOID *pool_start,
                     ULONG pool_size, UINT pool_control_block_size);
 UINT        _txe_byte_pool_delete(TX_BYTE_POOL *pool_ptr);
-UINT        _txe_byte_pool_info_get(TX_BYTE_POOL *pool_ptr, CHAR **name, ULONG *available_bytes, 
-                    ULONG *fragments, TX_THREAD **first_suspended, 
+UINT        _txe_byte_pool_info_get(TX_BYTE_POOL *pool_ptr, CHAR **name, ULONG *available_bytes,
+                    ULONG *fragments, TX_THREAD **first_suspended,
                     ULONG *suspended_count, TX_BYTE_POOL **next_pool);
 UINT        _txe_byte_pool_prioritize(TX_BYTE_POOL *pool_ptr);
 UINT        _txe_byte_release(VOID *memory_ptr);
@@ -1527,29 +1530,29 @@ UINT        _tx_event_flags_create(TX_EVENT_FLAGS_GROUP *group_ptr, CHAR *name_p
 UINT        _tx_event_flags_delete(TX_EVENT_FLAGS_GROUP *group_ptr);
 UINT        _tx_event_flags_get(TX_EVENT_FLAGS_GROUP *group_ptr, ULONG requested_flags,
                     UINT get_option, ULONG *actual_flags_ptr, ULONG wait_option);
-UINT        _tx_event_flags_info_get(TX_EVENT_FLAGS_GROUP *group_ptr, CHAR **name, ULONG *current_flags, 
-                    TX_THREAD **first_suspended, ULONG *suspended_count, 
+UINT        _tx_event_flags_info_get(TX_EVENT_FLAGS_GROUP *group_ptr, CHAR **name, ULONG *current_flags,
+                    TX_THREAD **first_suspended, ULONG *suspended_count,
                     TX_EVENT_FLAGS_GROUP **next_group);
 UINT        _tx_event_flags_performance_info_get(TX_EVENT_FLAGS_GROUP *group_ptr, ULONG *sets, ULONG *gets,
                     ULONG *suspensions, ULONG *timeouts);
 UINT        _tx_event_flags_performance_system_info_get(ULONG *sets, ULONG *gets,
                     ULONG *suspensions, ULONG *timeouts);
-UINT        _tx_event_flags_set(TX_EVENT_FLAGS_GROUP *group_ptr, ULONG flags_to_set, 
+UINT        _tx_event_flags_set(TX_EVENT_FLAGS_GROUP *group_ptr, ULONG flags_to_set,
                     UINT set_option);
 UINT        _tx_event_flags_set_notify(TX_EVENT_FLAGS_GROUP *group_ptr, VOID (*events_set_notify)(TX_EVENT_FLAGS_GROUP *notify_group_ptr));
 
 
-/* Define error checking shells for API services.  These are only referenced by the 
+/* Define error checking shells for API services.  These are only referenced by the
    application.  */
 
 UINT        _txe_event_flags_create(TX_EVENT_FLAGS_GROUP *group_ptr, CHAR *name_ptr, UINT event_control_block_size);
 UINT        _txe_event_flags_delete(TX_EVENT_FLAGS_GROUP *group_ptr);
 UINT        _txe_event_flags_get(TX_EVENT_FLAGS_GROUP *group_ptr, ULONG requested_flags,
                     UINT get_option, ULONG *actual_flags_ptr, ULONG wait_option);
-UINT        _txe_event_flags_info_get(TX_EVENT_FLAGS_GROUP *group_ptr, CHAR **name, ULONG *current_flags, 
-                    TX_THREAD **first_suspended, ULONG *suspended_count, 
+UINT        _txe_event_flags_info_get(TX_EVENT_FLAGS_GROUP *group_ptr, CHAR **name, ULONG *current_flags,
+                    TX_THREAD **first_suspended, ULONG *suspended_count,
                     TX_EVENT_FLAGS_GROUP **next_group);
-UINT        _txe_event_flags_set(TX_EVENT_FLAGS_GROUP *group_ptr, ULONG flags_to_set, 
+UINT        _txe_event_flags_set(TX_EVENT_FLAGS_GROUP *group_ptr, ULONG flags_to_set,
                     UINT 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));
 
@@ -1564,8 +1567,8 @@ VOID        _tx_initialize_kernel_enter(VOID);
 UINT        _tx_mutex_create(TX_MUTEX *mutex_ptr, CHAR *name_ptr, UINT inherit);
 UINT        _tx_mutex_delete(TX_MUTEX *mutex_ptr);
 UINT        _tx_mutex_get(TX_MUTEX *mutex_ptr, ULONG wait_option);
-UINT        _tx_mutex_info_get(TX_MUTEX *mutex_ptr, CHAR **name, ULONG *count, TX_THREAD **owner, 
-                    TX_THREAD **first_suspended, ULONG *suspended_count, 
+UINT        _tx_mutex_info_get(TX_MUTEX *mutex_ptr, CHAR **name, ULONG *count, TX_THREAD **owner,
+                    TX_THREAD **first_suspended, ULONG *suspended_count,
                     TX_MUTEX **next_mutex);
 UINT        _tx_mutex_performance_info_get(TX_MUTEX *mutex_ptr, ULONG *puts, ULONG *gets,
                     ULONG *suspensions, ULONG *timeouts, ULONG *inversions, ULONG *inheritances);
@@ -1575,14 +1578,14 @@ UINT        _tx_mutex_prioritize(TX_MUTEX *mutex_ptr);
 UINT        _tx_mutex_put(TX_MUTEX *mutex_ptr);
 
 
-/* Define error checking shells for API services.  These are only referenced by the 
+/* Define error checking shells for API services.  These are only referenced by the
    application.  */
 
 UINT        _txe_mutex_create(TX_MUTEX *mutex_ptr, CHAR *name_ptr, UINT inherit, UINT mutex_control_block_size);
 UINT        _txe_mutex_delete(TX_MUTEX *mutex_ptr);
 UINT        _txe_mutex_get(TX_MUTEX *mutex_ptr, ULONG wait_option);
-UINT        _txe_mutex_info_get(TX_MUTEX *mutex_ptr, CHAR **name, ULONG *count, TX_THREAD **owner, 
-                    TX_THREAD **first_suspended, ULONG *suspended_count, 
+UINT        _txe_mutex_info_get(TX_MUTEX *mutex_ptr, CHAR **name, ULONG *count, TX_THREAD **owner,
+                    TX_THREAD **first_suspended, ULONG *suspended_count,
                     TX_MUTEX **next_mutex);
 UINT        _txe_mutex_prioritize(TX_MUTEX *mutex_ptr);
 UINT        _txe_mutex_put(TX_MUTEX *mutex_ptr);
@@ -1590,7 +1593,7 @@ UINT        _txe_mutex_put(TX_MUTEX *mutex_ptr);
 
 /* Define queue management function prototypes.  */
 
-UINT        _tx_queue_create(TX_QUEUE *queue_ptr, CHAR *name_ptr, UINT message_size, 
+UINT        _tx_queue_create(TX_QUEUE *queue_ptr, CHAR *name_ptr, UINT message_size,
                         VOID *queue_start, ULONG queue_size);
 UINT        _tx_queue_delete(TX_QUEUE *queue_ptr);
 UINT        _tx_queue_flush(TX_QUEUE *queue_ptr);
@@ -1607,10 +1610,10 @@ UINT        _tx_queue_send_notify(TX_QUEUE *queue_ptr, VOID (*queue_send_notify)
 UINT        _tx_queue_front_send(TX_QUEUE *queue_ptr, VOID *source_ptr, ULONG wait_option);
 
 
-/* Define error checking shells for API services.  These are only referenced by the 
+/* Define error checking shells for API services.  These are only referenced by the
    application.  */
 
-UINT        _txe_queue_create(TX_QUEUE *queue_ptr, CHAR *name_ptr, UINT message_size, 
+UINT        _txe_queue_create(TX_QUEUE *queue_ptr, CHAR *name_ptr, UINT message_size,
                         VOID *queue_start, ULONG queue_size, UINT queue_control_block_size);
 UINT        _txe_queue_delete(TX_QUEUE *queue_ptr);
 UINT        _txe_queue_flush(TX_QUEUE *queue_ptr);
@@ -1629,8 +1632,8 @@ UINT        _tx_semaphore_ceiling_put(TX_SEMAPHORE *semaphore_ptr, ULONG ceiling
 UINT        _tx_semaphore_create(TX_SEMAPHORE *semaphore_ptr, CHAR *name_ptr, ULONG initial_count);
 UINT        _tx_semaphore_delete(TX_SEMAPHORE *semaphore_ptr);
 UINT        _tx_semaphore_get(TX_SEMAPHORE *semaphore_ptr, ULONG wait_option);
-UINT        _tx_semaphore_info_get(TX_SEMAPHORE *semaphore_ptr, CHAR **name, ULONG *current_value, 
-                    TX_THREAD **first_suspended, ULONG *suspended_count, 
+UINT        _tx_semaphore_info_get(TX_SEMAPHORE *semaphore_ptr, CHAR **name, ULONG *current_value,
+                    TX_THREAD **first_suspended, ULONG *suspended_count,
                     TX_SEMAPHORE **next_semaphore);
 UINT        _tx_semaphore_performance_info_get(TX_SEMAPHORE *semaphore_ptr, ULONG *puts, ULONG *gets,
                     ULONG *suspensions, ULONG *timeouts);
@@ -1640,15 +1643,15 @@ UINT        _tx_semaphore_put(TX_SEMAPHORE *semaphore_ptr);
 UINT        _tx_semaphore_put_notify(TX_SEMAPHORE *semaphore_ptr, VOID (*semaphore_put_notify)(TX_SEMAPHORE *notify_semaphore_ptr));
 
 
-/* Define error checking shells for API services.  These are only referenced by the 
+/* Define error checking shells for API services.  These are only referenced by the
    application.  */
 
 UINT        _txe_semaphore_ceiling_put(TX_SEMAPHORE *semaphore_ptr, ULONG ceiling);
 UINT        _txe_semaphore_create(TX_SEMAPHORE *semaphore_ptr, CHAR *name_ptr, ULONG initial_count, UINT semaphore_control_block_size);
 UINT        _txe_semaphore_delete(TX_SEMAPHORE *semaphore_ptr);
 UINT        _txe_semaphore_get(TX_SEMAPHORE *semaphore_ptr, ULONG wait_option);
-UINT        _txe_semaphore_info_get(TX_SEMAPHORE *semaphore_ptr, CHAR **name, ULONG *current_value, 
-                    TX_THREAD **first_suspended, ULONG *suspended_count, 
+UINT        _txe_semaphore_info_get(TX_SEMAPHORE *semaphore_ptr, CHAR **name, ULONG *current_value,
+                    TX_THREAD **first_suspended, ULONG *suspended_count,
                     TX_SEMAPHORE **next_semaphore);
 UINT        _txe_semaphore_prioritize(TX_SEMAPHORE *semaphore_ptr);
 UINT        _txe_semaphore_put(TX_SEMAPHORE *semaphore_ptr);
@@ -1659,19 +1662,19 @@ UINT        _txe_semaphore_put_notify(TX_SEMAPHORE *semaphore_ptr, VOID (*semaph
 
 VOID        _tx_thread_context_save(VOID);
 VOID        _tx_thread_context_restore(VOID);
-UINT        _tx_thread_create(TX_THREAD *thread_ptr, CHAR *name_ptr, 
+UINT        _tx_thread_create(TX_THREAD *thread_ptr, CHAR *name_ptr,
                 VOID (*entry_function)(ULONG entry_input), ULONG entry_input,
-                VOID *stack_start, ULONG stack_size, 
-                UINT priority, UINT preempt_threshold, 
+                VOID *stack_start, ULONG stack_size,
+                UINT priority, UINT preempt_threshold,
                 ULONG time_slice, UINT auto_start);
 UINT        _tx_thread_delete(TX_THREAD *thread_ptr);
 UINT        _tx_thread_entry_exit_notify(TX_THREAD *thread_ptr, VOID (*thread_entry_exit_notify)(TX_THREAD *notify_thread_ptr, UINT type));
 TX_THREAD  *_tx_thread_identify(VOID);
-UINT        _tx_thread_info_get(TX_THREAD *thread_ptr, CHAR **name, UINT *state, ULONG *run_count, 
-                UINT *priority, UINT *preemption_threshold, ULONG *time_slice, 
+UINT        _tx_thread_info_get(TX_THREAD *thread_ptr, CHAR **name, UINT *state, ULONG *run_count,
+                UINT *priority, UINT *preemption_threshold, ULONG *time_slice,
                 TX_THREAD **next_thread, TX_THREAD **next_suspended_thread);
 UINT        _tx_thread_interrupt_control(UINT new_posture);
-UINT        _tx_thread_performance_info_get(TX_THREAD *thread_ptr, ULONG *resumptions, ULONG *suspensions, 
+UINT        _tx_thread_performance_info_get(TX_THREAD *thread_ptr, ULONG *resumptions, ULONG *suspensions,
                 ULONG *solicited_preemptions, ULONG *interrupt_preemptions, ULONG *priority_inversions,
                 ULONG *time_slices, ULONG *relinquishes, ULONG *timeouts, ULONG *wait_aborts, TX_THREAD **last_preempted_by);
 UINT        _tx_thread_performance_system_info_get(ULONG *resumptions, ULONG *suspensions,
@@ -1693,18 +1696,18 @@ UINT        _tx_thread_time_slice_change(TX_THREAD *thread_ptr, ULONG new_time_s
 UINT        _tx_thread_wait_abort(TX_THREAD *thread_ptr);
 
 
-/* Define error checking shells for API services.  These are only referenced by the 
+/* Define error checking shells for API services.  These are only referenced by the
    application.  */
 
-UINT        _txe_thread_create(TX_THREAD *thread_ptr, CHAR *name_ptr, 
+UINT        _txe_thread_create(TX_THREAD *thread_ptr, CHAR *name_ptr,
                 VOID (*entry_function)(ULONG entry_input), ULONG entry_input,
-                VOID *stack_start, ULONG stack_size, 
-                UINT priority, UINT preempt_threshold, 
+                VOID *stack_start, ULONG stack_size,
+                UINT priority, UINT preempt_threshold,
                 ULONG time_slice, UINT auto_start, UINT thread_control_block_size);
 UINT        _txe_thread_delete(TX_THREAD *thread_ptr);
 UINT        _txe_thread_entry_exit_notify(TX_THREAD *thread_ptr, VOID (*thread_entry_exit_notify)(TX_THREAD *notify_thread_ptr, UINT type));
-UINT        _txe_thread_info_get(TX_THREAD *thread_ptr, CHAR **name, UINT *state, ULONG *run_count, 
-                UINT *priority, UINT *preemption_threshold, ULONG *time_slice, 
+UINT        _txe_thread_info_get(TX_THREAD *thread_ptr, CHAR **name, UINT *state, ULONG *run_count,
+                UINT *priority, UINT *preemption_threshold, ULONG *time_slice,
                 TX_THREAD **next_thread, TX_THREAD **next_suspended_thread);
 UINT        _txe_thread_preemption_change(TX_THREAD *thread_ptr, UINT new_threshold,
                         UINT *old_threshold);
@@ -1723,12 +1726,12 @@ UINT        _txe_thread_wait_abort(TX_THREAD *thread_ptr);
 
 UINT        _tx_timer_activate(TX_TIMER *timer_ptr);
 UINT        _tx_timer_change(TX_TIMER *timer_ptr, ULONG initial_ticks, ULONG reschedule_ticks);
-UINT        _tx_timer_create(TX_TIMER *timer_ptr, CHAR *name_ptr, 
+UINT        _tx_timer_create(TX_TIMER *timer_ptr, CHAR *name_ptr,
                 VOID (*expiration_function)(ULONG input), ULONG expiration_input,
                 ULONG initial_ticks, ULONG reschedule_ticks, UINT auto_activate);
 UINT        _tx_timer_deactivate(TX_TIMER *timer_ptr);
 UINT        _tx_timer_delete(TX_TIMER *timer_ptr);
-UINT        _tx_timer_info_get(TX_TIMER *timer_ptr, CHAR **name, UINT *active, ULONG *remaining_ticks, 
+UINT        _tx_timer_info_get(TX_TIMER *timer_ptr, CHAR **name, UINT *active, ULONG *remaining_ticks,
                 ULONG *reschedule_ticks, TX_TIMER **next_timer);
 UINT        _tx_timer_performance_info_get(TX_TIMER *timer_ptr, ULONG *activates, ULONG *reactivates,
                 ULONG *deactivates, ULONG *expirations, ULONG *expiration_adjusts);
@@ -1739,17 +1742,17 @@ ULONG       _tx_time_get(VOID);
 VOID        _tx_time_set(ULONG new_time);
 
 
-/* Define error checking shells for API services.  These are only referenced by the 
+/* Define error checking shells for API services.  These are only referenced by the
    application.  */
 
 UINT        _txe_timer_activate(TX_TIMER *timer_ptr);
 UINT        _txe_timer_change(TX_TIMER *timer_ptr, ULONG initial_ticks, ULONG reschedule_ticks);
-UINT        _txe_timer_create(TX_TIMER *timer_ptr, CHAR *name_ptr, 
+UINT        _txe_timer_create(TX_TIMER *timer_ptr, CHAR *name_ptr,
                 VOID (*expiration_function)(ULONG input), ULONG expiration_input,
                 ULONG initial_ticks, ULONG reschedule_ticks, UINT auto_activate, UINT timer_control_block_size);
 UINT        _txe_timer_deactivate(TX_TIMER *timer_ptr);
 UINT        _txe_timer_delete(TX_TIMER *timer_ptr);
-UINT        _txe_timer_info_get(TX_TIMER *timer_ptr, CHAR **name, UINT *active, ULONG *remaining_ticks, 
+UINT        _txe_timer_info_get(TX_TIMER *timer_ptr, CHAR **name, UINT *active, ULONG *remaining_ticks,
                 ULONG *reschedule_ticks, TX_TIMER **next_timer);
 
 
@@ -1769,13 +1772,13 @@ UINT        _tx_trace_interrupt_control(UINT new_posture);
 /* Add a default macro that can be re-defined in tx_port.h to add default processing when a thread starts. Common usage
    would be for enabling floating point for a thread by default, however, the additional processing could be anything
    defined in tx_port.h.  */
-   
+
 #ifndef TX_THREAD_STARTED_EXTENSION
 #define TX_THREAD_STARTED_EXTENSION(thread_ptr)
 #endif
 
 
-/* Add a default macro that can be re-defined in tx_port.h to add processing to the thread stack analyze function.  
+/* Add a default macro that can be re-defined in tx_port.h to add processing to the thread stack analyze function.
    By default, this is simply defined as whitespace.  */
 
 #ifndef TX_THREAD_STACK_ANALYZE_EXTENSION
@@ -1783,7 +1786,7 @@ UINT        _tx_trace_interrupt_control(UINT new_posture);
 #endif
 
 
-/* Add a default macro that can be re-defined in tx_port.h to add processing to the initialize kernel enter function.  
+/* Add a default macro that can be re-defined in tx_port.h to add processing to the initialize kernel enter function.
    By default, this is simply defined as whitespace.  */
 
 #ifndef TX_INITIALIZE_KERNEL_ENTER_EXTENSION