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
313
314
315
316
317
318
319
320
321
322
323
|
/***************************************************************************
* Copyright (c) 2024 Microsoft Corporation
* Copyright (c) 2026-present Eclipse ThreadX contributors
*
* This program and the accompanying materials are made available under the
* terms of the MIT License which is available at
* https://opensource.org/licenses/MIT.
*
* SPDX-License-Identifier: MIT
**************************************************************************/
// Portions of this file were generated with AI assistance.
/**************************************************************************/
/**************************************************************************/
/** */
/** 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 */
/* */
/**************************************************************************/
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
/* Set the suspending flag, so that the termination transition is marked
as in progress for the same interval it is marked in the interruptable
configuration below. Nothing in this configuration needs the flag to
cancel an interrupted suspension -- interrupts stay disabled through
the whole transition -- but the notification callback below is
application code, reached by a direct call, and interrupt lockout does
not stop it from calling a thread lifecycle service on this same
control block. The flag is cleared in the common tail below. */
thread_ptr -> tx_thread_suspending = TX_TRUE;
#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);
}
/* The suspending flag deliberately stays set here. It used to be
cleared at this point, which left the terminated extension and the
notification callback below -- both application code -- free to delete
or reset this control block while this service still held a pointer to
it and still had mutex-release processing to do. It is now cleared
once, in the common tail below, after the last dereference of the
target. */
/* 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
/* Clear the suspending flag. This is the one place the end of the
termination transition is published, and it is reached from both branches
above, after the notification callback and after the mutex-release
processing, which is the last thing in this service to dereference the
target. Until this store, _tx_thread_delete and _tx_thread_reset refuse
the target. In the interruptable ready branch the flag is already false,
because _tx_thread_system_suspend cleared it when it detached the thread,
so this is a second store of a value the flag already holds; that is
cheaper than testing for it and it keeps the transition to a single clear
site. No suspension-initiating service can have set it again in between:
every one of them acts on a thread that is ready or suspended, and this
thread is terminated. */
thread_ptr -> tx_thread_suspending = TX_FALSE;
/* 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);
}
|
