Outline ![]()
Files ![]()
loading...
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** ThreadX Component */
/** */
/** Thread */
/** */
/**************************************************************************/
/**************************************************************************/
#define TX_SOURCE_CODE
/* Include necessary system files. */
#include "tx_api.h"
#include "tx_trace.h"
#include "tx_thread.h"
#include "tx_timer.h"
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _tx_thread_terminate PORTABLE C */
/* 6.1 */
/* AUTHOR */
/* */
/* William E. Lamie, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function handles application thread terminate requests. Once */
/* a thread is terminated, it cannot be executed again unless it is */
/* deleted and recreated. */
/* */
/* INPUT */
/* */
/* thread_ptr Pointer to thread to suspend */
/* */
/* OUTPUT */
/* */
/* status Return completion status */
/* */
/* CALLS */
/* */
/* _tx_timer_system_deactivate Timer deactivate function */
/* _tx_thread_system_suspend Actual thread suspension */
/* _tx_thread_system_ni_suspend Non-interruptable suspend */
/* thread */
/* _tx_thread_system_preempt_check Check for preemption */
/* Suspend Cleanup Routine Suspension cleanup function */
/* */
/* CALLED BY */
/* */
/* Application code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 05-19-2020 William E. Lamie Initial Version 6.0 */
/* 09-30-2020 Yuxin Zhou Modified comment(s), */
/* resulting in version 6.1 */
/* */
/**************************************************************************/
UINT _tx_thread_terminate(TX_THREAD *thread_ptr)
{
TX_INTERRUPT_SAVE_AREA
VOID (*suspend_cleanup)(struct TX_THREAD_STRUCT *suspend_thread_ptr, ULONG suspension_sequence);
#ifndef TX_DISABLE_NOTIFY_CALLBACKS
VOID (*entry_exit_notify)(TX_THREAD *notify_thread_ptr, UINT id);
#endif
UINT status;
ULONG suspension_sequence;
/* Default to successful completion. */
status = TX_SUCCESS;
/* Lockout interrupts while the thread is being terminated. */
TX_DISABLE
/* Deactivate thread timer, if active. */
_tx_timer_system_deactivate(&thread_ptr -> tx_thread_timer);
/* If trace is enabled, insert this event into the trace buffer. */
TX_TRACE_IN_LINE_INSERT(TX_TRACE_THREAD_TERMINATE, thread_ptr, thread_ptr -> tx_thread_state, TX_POINTER_TO_ULONG_CONVERT(&suspend_cleanup), 0, TX_TRACE_THREAD_EVENTS)
/* Log this kernel call. */
TX_EL_THREAD_TERMINATE_INSERT
/* Is the thread already terminated? */
if (thread_ptr -> tx_thread_state == TX_TERMINATED)
{
/* Restore interrupts. */
TX_RESTORE
/* Return success since thread is already terminated. */
status = TX_SUCCESS;
}
/* Check the specified thread's current status. */
else if (thread_ptr -> tx_thread_state != TX_COMPLETED)
{
/* Disable preemption. */
_tx_thread_preempt_disable++;
#ifndef TX_DISABLE_NOTIFY_CALLBACKS
/* Pickup the entry/exit application callback routine. */
entry_exit_notify = thread_ptr -> tx_thread_entry_exit_notify;
#endif
/* Check to see if the thread is currently ready. */
if (thread_ptr -> tx_thread_state == TX_READY)
{
/* Set the state to terminated. */
thread_ptr -> tx_thread_state = TX_TERMINATED;
/* Thread state change. */
TX_THREAD_STATE_CHANGE(thread_ptr, TX_TERMINATED)
#ifdef TX_NOT_INTERRUPTABLE
#ifndef TX_DISABLE_NOTIFY_CALLBACKS
/* Determine if an application callback routine is specified. */
if (entry_exit_notify != TX_NULL)
{
/* Yes, notify application that this thread has exited! */
(entry_exit_notify)(thread_ptr, TX_THREAD_EXIT);
}
#endif
/* Call actual non-interruptable thread suspension routine. */
_tx_thread_system_ni_suspend(thread_ptr, ((ULONG) 0));
#else
/* Set the suspending flag. */
thread_ptr -> tx_thread_suspending = TX_TRUE;
/* Setup for no timeout period. */
thread_ptr -> tx_thread_timer.tx_timer_internal_remaining_ticks = ((ULONG) 0);
/* Disable preemption. */
_tx_thread_preempt_disable++;
/* Since the thread is currently ready, we don't need to
worry about calling the suspend cleanup routine! */
/* Restore interrupts. */
TX_RESTORE
/* Perform any additional activities for tool or user purpose. */
TX_THREAD_TERMINATED_EXTENSION(thread_ptr)
#ifndef TX_DISABLE_NOTIFY_CALLBACKS
/* Determine if an application callback routine is specified. */
if (entry_exit_notify != TX_NULL)
{
/* Yes, notify application that this thread has exited! */
(entry_exit_notify)(thread_ptr, TX_THREAD_EXIT);
}
#endif
/* Call actual thread suspension routine. */
_tx_thread_system_suspend(thread_ptr);
/* Disable interrupts. */
TX_DISABLE
#endif
}
else
{
/* Change the state to terminated. */
thread_ptr -> tx_thread_state = TX_TERMINATED;
/* Thread state change. */
TX_THREAD_STATE_CHANGE(thread_ptr, TX_TERMINATED)
/* Set the suspending flag. This prevents the thread from being
resumed before the cleanup routine is executed. */
thread_ptr -> tx_thread_suspending = TX_TRUE;
/* Pickup the cleanup routine address. */
suspend_cleanup = thread_ptr -> tx_thread_suspend_cleanup;
#ifndef TX_NOT_INTERRUPTABLE
/* Pickup the suspension sequence number that is used later to verify that the
cleanup is still necessary. */
suspension_sequence = thread_ptr -> tx_thread_suspension_sequence;
#else
/* When not interruptable is selected, the suspension sequence is not used - just set to 0. */
suspension_sequence = ((ULONG) 0);
#endif
#ifndef TX_NOT_INTERRUPTABLE
/* Restore interrupts. */
TX_RESTORE
#endif
/* Call any cleanup routines. */
if (suspend_cleanup != TX_NULL)
{
/* Yes, there is a function to call. */
(suspend_cleanup)(thread_ptr, suspension_sequence);
}
#ifndef TX_NOT_INTERRUPTABLE
/* Disable interrupts. */
TX_DISABLE
#endif
/* Clear the suspending flag. */
thread_ptr -> tx_thread_suspending = TX_FALSE;
#ifndef TX_NOT_INTERRUPTABLE
/* Restore interrupts. */
TX_RESTORE
#endif
/* Perform any additional activities for tool or user purpose. */
TX_THREAD_TERMINATED_EXTENSION(thread_ptr)
#ifndef TX_DISABLE_NOTIFY_CALLBACKS
/* Determine if an application callback routine is specified. */
if (entry_exit_notify != TX_NULL)
{
/* Yes, notify application that this thread has exited! */
(entry_exit_notify)(thread_ptr, TX_THREAD_EXIT);
}
#endif
#ifndef TX_NOT_INTERRUPTABLE
/* Disable interrupts. */
TX_DISABLE
#endif
}
#ifndef TX_NOT_INTERRUPTABLE
/* Restore interrupts. */
TX_RESTORE
#endif
/* Determine if the application is using mutexes. */
if (_tx_thread_mutex_release != TX_NULL)
{
/* Yes, call the mutex release function via a function pointer that
is setup during initialization. */
(_tx_thread_mutex_release)(thread_ptr);
}
#ifndef TX_NOT_INTERRUPTABLE
/* Disable interrupts. */
TX_DISABLE
#endif
/* Enable preemption. */
_tx_thread_preempt_disable--;
/* Restore interrupts. */
TX_RESTORE
}
else
{
/* Restore interrupts. */
TX_RESTORE
}
/* Check for preemption. */
_tx_thread_system_preempt_check();
/* Return completion status. */
return(status);
}