1 /***************************************************************************
2 * Copyright (c) 2024 Microsoft Corporation
3 *
4 * This program and the accompanying materials are made available under the
5 * terms of the MIT License which is available at
6 * https://opensource.org/licenses/MIT.
7 *
8 * SPDX-License-Identifier: MIT
9 **************************************************************************/
10
11
12 /**************************************************************************/
13 /**************************************************************************/
14 /** */
15 /** ThreadX Component */
16 /** */
17 /** Module Manager */
18 /** */
19 /**************************************************************************/
20 /**************************************************************************/
21
22 #ifndef TXM_BLOCK_ALLOCATE_CALL_NOT_USED
23 /* UINT _txe_block_allocate(
24 TX_BLOCK_POOL *pool_ptr, -> param_0
25 VOID **block_ptr, -> param_1
26 ULONG wait_option -> param_2
27 ); */
_txm_module_manager_tx_block_allocate_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE param_2)28 static ALIGN_TYPE _txm_module_manager_tx_block_allocate_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE param_2)
29 {
30
31 ALIGN_TYPE return_value;
32
33 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
34 {
35 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_BLOCK_POOL)))
36 return(TXM_MODULE_INVALID_MEMORY);
37
38 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(VOID *)))
39 return(TXM_MODULE_INVALID_MEMORY);
40 }
41
42 return_value = (ALIGN_TYPE) _txe_block_allocate(
43 (TX_BLOCK_POOL *) param_0,
44 (VOID **) param_1,
45 (ULONG) param_2
46 );
47 return(return_value);
48 }
49 #endif
50
51 #ifndef TXM_BLOCK_POOL_CREATE_CALL_NOT_USED
52 /* UINT _txe_block_pool_create(
53 TX_BLOCK_POOL *pool_ptr, -> param_0
54 CHAR *name_ptr, -> param_1
55 ULONG block_size, -> extra_parameters[0]
56 VOID *pool_start, -> extra_parameters[1]
57 ULONG pool_size, -> extra_parameters[2]
58 UINT pool_control_block_size -> extra_parameters[3]
59 ); */
_txm_module_manager_tx_block_pool_create_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE * extra_parameters)60 static ALIGN_TYPE _txm_module_manager_tx_block_pool_create_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE *extra_parameters)
61 {
62
63 ALIGN_TYPE return_value;
64
65 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
66 {
67 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_CREATION(module_instance, param_0, sizeof(TX_BLOCK_POOL)))
68 return(TXM_MODULE_INVALID_MEMORY);
69
70 if (!TXM_MODULE_MANAGER_PARAM_CHECK_DEREFERENCE_STRING(module_instance, param_1))
71 return(TXM_MODULE_INVALID_MEMORY);
72
73 if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[2])))
74 return(TXM_MODULE_INVALID_MEMORY);
75
76 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[1], extra_parameters[2]))
77 return(TXM_MODULE_INVALID_MEMORY);
78 }
79
80 return_value = (ALIGN_TYPE) _txe_block_pool_create(
81 (TX_BLOCK_POOL *) param_0,
82 (CHAR *) param_1,
83 (ULONG) extra_parameters[0],
84 (VOID *) extra_parameters[1],
85 (ULONG) extra_parameters[2],
86 (UINT) extra_parameters[3]
87 );
88 return(return_value);
89 }
90 #endif
91
92 #ifndef TXM_BLOCK_POOL_DELETE_CALL_NOT_USED
93 /* UINT _txe_block_pool_delete(
94 TX_BLOCK_POOL *pool_ptr -> param_0
95 ); */
_txm_module_manager_tx_block_pool_delete_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0)96 static ALIGN_TYPE _txm_module_manager_tx_block_pool_delete_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0)
97 {
98
99 ALIGN_TYPE return_value;
100
101 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
102 {
103 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_BLOCK_POOL)))
104 return(TXM_MODULE_INVALID_MEMORY);
105 }
106
107 return_value = (ALIGN_TYPE) _txe_block_pool_delete(
108 (TX_BLOCK_POOL *) param_0
109 );
110
111 /* Deallocate object memory. */
112 if (return_value == TX_SUCCESS)
113 {
114 return_value = _txm_module_manager_object_deallocate((VOID *) param_0);
115 }
116 return(return_value);
117 }
118 #endif
119
120 #ifndef TXM_BLOCK_POOL_INFO_GET_CALL_NOT_USED
121 /* UINT _txe_block_pool_info_get(
122 TX_BLOCK_POOL *pool_ptr, -> param_0
123 CHAR **name, -> param_1
124 ULONG *available_blocks, -> extra_parameters[0]
125 ULONG *total_blocks, -> extra_parameters[1]
126 TX_THREAD **first_suspended, -> extra_parameters[2]
127 ULONG *suspended_count, -> extra_parameters[3]
128 TX_BLOCK_POOL **next_pool -> extra_parameters[4]
129 ); */
_txm_module_manager_tx_block_pool_info_get_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE * extra_parameters)130 static ALIGN_TYPE _txm_module_manager_tx_block_pool_info_get_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE *extra_parameters)
131 {
132
133 ALIGN_TYPE return_value;
134
135 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
136 {
137 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_BLOCK_POOL)))
138 return(TXM_MODULE_INVALID_MEMORY);
139
140 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(CHAR *)))
141 return(TXM_MODULE_INVALID_MEMORY);
142
143 if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[5])))
144 return(TXM_MODULE_INVALID_MEMORY);
145
146 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], sizeof(ULONG)))
147 return(TXM_MODULE_INVALID_MEMORY);
148
149 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[1], sizeof(ULONG)))
150 return(TXM_MODULE_INVALID_MEMORY);
151
152 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[2], sizeof(TX_THREAD *)))
153 return(TXM_MODULE_INVALID_MEMORY);
154
155 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[3], sizeof(ULONG)))
156 return(TXM_MODULE_INVALID_MEMORY);
157
158 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[4], sizeof(TX_BLOCK_POOL *)))
159 return(TXM_MODULE_INVALID_MEMORY);
160 }
161
162 return_value = (ALIGN_TYPE) _txe_block_pool_info_get(
163 (TX_BLOCK_POOL *) param_0,
164 (CHAR **) param_1,
165 (ULONG *) extra_parameters[0],
166 (ULONG *) extra_parameters[1],
167 (TX_THREAD **) extra_parameters[2],
168 (ULONG *) extra_parameters[3],
169 (TX_BLOCK_POOL **) extra_parameters[4]
170 );
171 return(return_value);
172 }
173 #endif
174
175 #ifndef TXM_BLOCK_POOL_PERFORMANCE_INFO_GET_CALL_NOT_USED
176 /* UINT _tx_block_pool_performance_info_get(
177 TX_BLOCK_POOL *pool_ptr, -> param_0
178 ULONG *allocates, -> param_1
179 ULONG *releases, -> extra_parameters[0]
180 ULONG *suspensions, -> extra_parameters[1]
181 ULONG *timeouts -> extra_parameters[2]
182 ); */
_txm_module_manager_tx_block_pool_performance_info_get_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE * extra_parameters)183 static ALIGN_TYPE _txm_module_manager_tx_block_pool_performance_info_get_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE *extra_parameters)
184 {
185
186 ALIGN_TYPE return_value;
187
188 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
189 {
190 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_BLOCK_POOL)))
191 return(TXM_MODULE_INVALID_MEMORY);
192
193 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(ULONG)))
194 return(TXM_MODULE_INVALID_MEMORY);
195
196 if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[3])))
197 return(TXM_MODULE_INVALID_MEMORY);
198
199 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], sizeof(ULONG)))
200 return(TXM_MODULE_INVALID_MEMORY);
201
202 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[1], sizeof(ULONG)))
203 return(TXM_MODULE_INVALID_MEMORY);
204
205 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[2], sizeof(ULONG)))
206 return(TXM_MODULE_INVALID_MEMORY);
207 }
208
209 return_value = (ALIGN_TYPE) _tx_block_pool_performance_info_get(
210 (TX_BLOCK_POOL *) param_0,
211 (ULONG *) param_1,
212 (ULONG *) extra_parameters[0],
213 (ULONG *) extra_parameters[1],
214 (ULONG *) extra_parameters[2]
215 );
216 return(return_value);
217 }
218 #endif
219
220 #ifndef TXM_BLOCK_POOL_PERFORMANCE_SYSTEM_INFO_GET_CALL_NOT_USED
221 /* UINT _tx_block_pool_performance_system_info_get(
222 ULONG *allocates, -> param_0
223 ULONG *releases, -> param_1
224 ULONG *suspensions, -> extra_parameters[0]
225 ULONG *timeouts -> extra_parameters[1]
226 ); */
_txm_module_manager_tx_block_pool_performance_system_info_get_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE * extra_parameters)227 static ALIGN_TYPE _txm_module_manager_tx_block_pool_performance_system_info_get_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE *extra_parameters)
228 {
229
230 ALIGN_TYPE return_value;
231
232 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
233 {
234 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_0, sizeof(ULONG)))
235 return(TXM_MODULE_INVALID_MEMORY);
236
237 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(ULONG)))
238 return(TXM_MODULE_INVALID_MEMORY);
239
240 if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[2])))
241 return(TXM_MODULE_INVALID_MEMORY);
242
243 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], sizeof(ULONG)))
244 return(TXM_MODULE_INVALID_MEMORY);
245
246 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[1], sizeof(ULONG)))
247 return(TXM_MODULE_INVALID_MEMORY);
248 }
249
250 return_value = (ALIGN_TYPE) _tx_block_pool_performance_system_info_get(
251 (ULONG *) param_0,
252 (ULONG *) param_1,
253 (ULONG *) extra_parameters[0],
254 (ULONG *) extra_parameters[1]
255 );
256 return(return_value);
257 }
258 #endif
259
260 #ifndef TXM_BLOCK_POOL_PRIORITIZE_CALL_NOT_USED
261 /* UINT _txe_block_pool_prioritize(
262 TX_BLOCK_POOL *pool_ptr -> param_0
263 ); */
_txm_module_manager_tx_block_pool_prioritize_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0)264 static ALIGN_TYPE _txm_module_manager_tx_block_pool_prioritize_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0)
265 {
266
267 ALIGN_TYPE return_value;
268
269 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
270 {
271 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_BLOCK_POOL)))
272 return(TXM_MODULE_INVALID_MEMORY);
273 }
274
275 return_value = (ALIGN_TYPE) _txe_block_pool_prioritize(
276 (TX_BLOCK_POOL *) param_0
277 );
278 return(return_value);
279 }
280 #endif
281
282 #ifndef TXM_BLOCK_RELEASE_CALL_NOT_USED
283 /* UINT _txe_block_release(
284 VOID *block_ptr -> param_0
285 ); */
_txm_module_manager_tx_block_release_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0)286 static ALIGN_TYPE _txm_module_manager_tx_block_release_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0)
287 {
288
289 ALIGN_TYPE return_value;
290 ALIGN_TYPE block_header_start;
291
292 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
293 {
294 /* Is the pointer non-null? */
295 if ((void *) param_0 != TX_NULL)
296 {
297
298 /* Calculate the beginning of the header info for this block (the header
299 consists of 1 pointers. */
300 block_header_start = param_0 - sizeof(ALIGN_TYPE);
301
302 if (/* Did we underflow when doing the subtract? */
303 (block_header_start > param_0) ||
304 /* Ensure the pointer is inside the module's data. Note that we only
305 check the pointer in the header because only that pointer is
306 dereferenced during the pointer's validity check in _tx_block_release. */
307 (!TXM_MODULE_MANAGER_CHECK_INSIDE_DATA(module_instance, block_header_start, sizeof(ALIGN_TYPE))))
308 {
309
310 /* Invalid pointer. */
311 return(TXM_MODULE_INVALID_MEMORY);
312 }
313 }
314 }
315
316 return_value = (ALIGN_TYPE) _txe_block_release(
317 (VOID *) param_0
318 );
319 return(return_value);
320 }
321 #endif
322
323 #ifndef TXM_BYTE_ALLOCATE_CALL_NOT_USED
324 /* UINT _txe_byte_allocate(
325 TX_BYTE_POOL *pool_ptr, -> param_0
326 VOID **memory_ptr, -> param_1
327 ULONG memory_size, -> extra_parameters[0]
328 ULONG wait_option -> extra_parameters[1]
329 ); */
_txm_module_manager_tx_byte_allocate_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE * extra_parameters)330 static ALIGN_TYPE _txm_module_manager_tx_byte_allocate_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE *extra_parameters)
331 {
332
333 ALIGN_TYPE return_value;
334
335 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
336 {
337 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_BYTE_POOL)))
338 return(TXM_MODULE_INVALID_MEMORY);
339
340 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(VOID *)))
341 return(TXM_MODULE_INVALID_MEMORY);
342
343 if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[2])))
344 return(TXM_MODULE_INVALID_MEMORY);
345 }
346
347 return_value = (ALIGN_TYPE) _txe_byte_allocate(
348 (TX_BYTE_POOL *) param_0,
349 (VOID **) param_1,
350 (ULONG) extra_parameters[0],
351 (ULONG) extra_parameters[1]
352 );
353 return(return_value);
354 }
355 #endif
356
357 #ifndef TXM_BYTE_POOL_CREATE_CALL_NOT_USED
358 /* UINT _txe_byte_pool_create(
359 TX_BYTE_POOL *pool_ptr, -> param_0
360 CHAR *name_ptr, -> param_1
361 VOID *pool_start, -> extra_parameters[0]
362 ULONG pool_size, -> extra_parameters[1]
363 UINT pool_control_block_size -> extra_parameters[2]
364 ); */
_txm_module_manager_tx_byte_pool_create_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE * extra_parameters)365 static ALIGN_TYPE _txm_module_manager_tx_byte_pool_create_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE *extra_parameters)
366 {
367
368 ALIGN_TYPE return_value;
369
370 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
371 {
372 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_CREATION(module_instance, param_0, sizeof(TX_BYTE_POOL)))
373 return(TXM_MODULE_INVALID_MEMORY);
374
375 if (!TXM_MODULE_MANAGER_PARAM_CHECK_DEREFERENCE_STRING(module_instance, param_1))
376 return(TXM_MODULE_INVALID_MEMORY);
377
378 if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[3])))
379 return(TXM_MODULE_INVALID_MEMORY);
380
381 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], extra_parameters[1]))
382 return(TXM_MODULE_INVALID_MEMORY);
383 }
384
385 return_value = (ALIGN_TYPE) _txe_byte_pool_create(
386 (TX_BYTE_POOL *) param_0,
387 (CHAR *) param_1,
388 (VOID *) extra_parameters[0],
389 (ULONG) extra_parameters[1],
390 (UINT) extra_parameters[2]
391 );
392 return(return_value);
393 }
394 #endif
395
396 #ifndef TXM_BYTE_POOL_DELETE_CALL_NOT_USED
397 /* UINT _txe_byte_pool_delete(
398 TX_BYTE_POOL *pool_ptr -> param_0
399 ); */
_txm_module_manager_tx_byte_pool_delete_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0)400 static ALIGN_TYPE _txm_module_manager_tx_byte_pool_delete_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0)
401 {
402
403 ALIGN_TYPE return_value;
404
405 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
406 {
407 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_BYTE_POOL)))
408 return(TXM_MODULE_INVALID_MEMORY);
409 }
410
411 return_value = (ALIGN_TYPE) _txe_byte_pool_delete(
412 (TX_BYTE_POOL *) param_0
413 );
414
415 /* Deallocate object memory. */
416 if (return_value == TX_SUCCESS)
417 {
418 return_value = _txm_module_manager_object_deallocate((VOID *) param_0);
419 }
420 return(return_value);
421 }
422 #endif
423
424 #ifndef TXM_BYTE_POOL_INFO_GET_CALL_NOT_USED
425 /* UINT _txe_byte_pool_info_get(
426 TX_BYTE_POOL *pool_ptr, -> param_0
427 CHAR **name, -> param_1
428 ULONG *available_bytes, -> extra_parameters[0]
429 ULONG *fragments, -> extra_parameters[1]
430 TX_THREAD **first_suspended, -> extra_parameters[2]
431 ULONG *suspended_count, -> extra_parameters[3]
432 TX_BYTE_POOL **next_pool -> extra_parameters[4]
433 ); */
_txm_module_manager_tx_byte_pool_info_get_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE * extra_parameters)434 static ALIGN_TYPE _txm_module_manager_tx_byte_pool_info_get_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE *extra_parameters)
435 {
436
437 ALIGN_TYPE return_value;
438
439 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
440 {
441 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_BYTE_POOL)))
442 return(TXM_MODULE_INVALID_MEMORY);
443
444 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(CHAR *)))
445 return(TXM_MODULE_INVALID_MEMORY);
446
447 if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[5])))
448 return(TXM_MODULE_INVALID_MEMORY);
449
450 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], sizeof(ULONG)))
451 return(TXM_MODULE_INVALID_MEMORY);
452
453 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[1], sizeof(ULONG)))
454 return(TXM_MODULE_INVALID_MEMORY);
455
456 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[2], sizeof(TX_THREAD *)))
457 return(TXM_MODULE_INVALID_MEMORY);
458
459 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[3], sizeof(ULONG)))
460 return(TXM_MODULE_INVALID_MEMORY);
461
462 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[4], sizeof(TX_BYTE_POOL *)))
463 return(TXM_MODULE_INVALID_MEMORY);
464 }
465
466 return_value = (ALIGN_TYPE) _txe_byte_pool_info_get(
467 (TX_BYTE_POOL *) param_0,
468 (CHAR **) param_1,
469 (ULONG *) extra_parameters[0],
470 (ULONG *) extra_parameters[1],
471 (TX_THREAD **) extra_parameters[2],
472 (ULONG *) extra_parameters[3],
473 (TX_BYTE_POOL **) extra_parameters[4]
474 );
475 return(return_value);
476 }
477 #endif
478
479 #ifndef TXM_BYTE_POOL_PERFORMANCE_INFO_GET_CALL_NOT_USED
480 /* UINT _tx_byte_pool_performance_info_get(
481 TX_BYTE_POOL *pool_ptr, -> param_0
482 ULONG *allocates, -> param_1
483 ULONG *releases, -> extra_parameters[0]
484 ULONG *fragments_searched, -> extra_parameters[1]
485 ULONG *merges, -> extra_parameters[2]
486 ULONG *splits, -> extra_parameters[3]
487 ULONG *suspensions, -> extra_parameters[4]
488 ULONG *timeouts -> extra_parameters[5]
489 ); */
_txm_module_manager_tx_byte_pool_performance_info_get_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE * extra_parameters)490 static ALIGN_TYPE _txm_module_manager_tx_byte_pool_performance_info_get_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE *extra_parameters)
491 {
492
493 ALIGN_TYPE return_value;
494
495 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
496 {
497 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_BYTE_POOL)))
498 return(TXM_MODULE_INVALID_MEMORY);
499
500 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(ULONG)))
501 return(TXM_MODULE_INVALID_MEMORY);
502
503 if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[6])))
504 return(TXM_MODULE_INVALID_MEMORY);
505
506 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], sizeof(ULONG)))
507 return(TXM_MODULE_INVALID_MEMORY);
508
509 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[1], sizeof(ULONG)))
510 return(TXM_MODULE_INVALID_MEMORY);
511
512 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[2], sizeof(ULONG)))
513 return(TXM_MODULE_INVALID_MEMORY);
514
515 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[3], sizeof(ULONG)))
516 return(TXM_MODULE_INVALID_MEMORY);
517
518 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[4], sizeof(ULONG)))
519 return(TXM_MODULE_INVALID_MEMORY);
520
521 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[5], sizeof(ULONG)))
522 return(TXM_MODULE_INVALID_MEMORY);
523 }
524
525 return_value = (ALIGN_TYPE) _tx_byte_pool_performance_info_get(
526 (TX_BYTE_POOL *) param_0,
527 (ULONG *) param_1,
528 (ULONG *) extra_parameters[0],
529 (ULONG *) extra_parameters[1],
530 (ULONG *) extra_parameters[2],
531 (ULONG *) extra_parameters[3],
532 (ULONG *) extra_parameters[4],
533 (ULONG *) extra_parameters[5]
534 );
535 return(return_value);
536 }
537 #endif
538
539 #ifndef TXM_BYTE_POOL_PERFORMANCE_SYSTEM_INFO_GET_CALL_NOT_USED
540 /* UINT _tx_byte_pool_performance_system_info_get(
541 ULONG *allocates, -> param_0
542 ULONG *releases, -> param_1
543 ULONG *fragments_searched, -> extra_parameters[0]
544 ULONG *merges, -> extra_parameters[1]
545 ULONG *splits, -> extra_parameters[2]
546 ULONG *suspensions, -> extra_parameters[3]
547 ULONG *timeouts -> extra_parameters[4]
548 ); */
_txm_module_manager_tx_byte_pool_performance_system_info_get_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE * extra_parameters)549 static ALIGN_TYPE _txm_module_manager_tx_byte_pool_performance_system_info_get_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE *extra_parameters)
550 {
551
552 ALIGN_TYPE return_value;
553
554 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
555 {
556 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_0, sizeof(ULONG)))
557 return(TXM_MODULE_INVALID_MEMORY);
558
559 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(ULONG)))
560 return(TXM_MODULE_INVALID_MEMORY);
561
562 if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[5])))
563 return(TXM_MODULE_INVALID_MEMORY);
564
565 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], sizeof(ULONG)))
566 return(TXM_MODULE_INVALID_MEMORY);
567
568 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[1], sizeof(ULONG)))
569 return(TXM_MODULE_INVALID_MEMORY);
570
571 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[2], sizeof(ULONG)))
572 return(TXM_MODULE_INVALID_MEMORY);
573
574 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[3], sizeof(ULONG)))
575 return(TXM_MODULE_INVALID_MEMORY);
576
577 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[4], sizeof(ULONG)))
578 return(TXM_MODULE_INVALID_MEMORY);
579 }
580
581 return_value = (ALIGN_TYPE) _tx_byte_pool_performance_system_info_get(
582 (ULONG *) param_0,
583 (ULONG *) param_1,
584 (ULONG *) extra_parameters[0],
585 (ULONG *) extra_parameters[1],
586 (ULONG *) extra_parameters[2],
587 (ULONG *) extra_parameters[3],
588 (ULONG *) extra_parameters[4]
589 );
590 return(return_value);
591 }
592 #endif
593
594 #ifndef TXM_BYTE_POOL_PRIORITIZE_CALL_NOT_USED
595 /* UINT _txe_byte_pool_prioritize(
596 TX_BYTE_POOL *pool_ptr -> param_0
597 ); */
_txm_module_manager_tx_byte_pool_prioritize_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0)598 static ALIGN_TYPE _txm_module_manager_tx_byte_pool_prioritize_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0)
599 {
600
601 ALIGN_TYPE return_value;
602
603 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
604 {
605 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_BYTE_POOL)))
606 return(TXM_MODULE_INVALID_MEMORY);
607 }
608
609 return_value = (ALIGN_TYPE) _txe_byte_pool_prioritize(
610 (TX_BYTE_POOL *) param_0
611 );
612 return(return_value);
613 }
614 #endif
615
616 #ifndef TXM_BYTE_RELEASE_CALL_NOT_USED
617 /* UINT _txe_byte_release(
618 VOID *memory_ptr -> param_0
619 ); */
_txm_module_manager_tx_byte_release_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0)620 static ALIGN_TYPE _txm_module_manager_tx_byte_release_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0)
621 {
622
623 ALIGN_TYPE return_value;
624 ALIGN_TYPE block_header_start;
625
626 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
627 {
628 /* Is the pointer non-null? */
629 if ((void *) param_0 != TX_NULL)
630 {
631
632 /* Calculate the beginning of the header info for this block (the header
633 consists of 2 pointers). */
634 block_header_start = param_0 - 2*sizeof(ALIGN_TYPE);
635
636 if (/* Did we underflow when doing the subtract? */
637 (block_header_start > param_0) ||
638 /* Ensure the pointer is inside the module's data. Note that we only
639 check the pointers in the header because only those two are
640 dereferenced during the pointer's validity check in _tx_byte_release. */
641 (!TXM_MODULE_MANAGER_CHECK_INSIDE_DATA(module_instance, block_header_start, 2*sizeof(ALIGN_TYPE))))
642 {
643
644 /* Invalid pointer. */
645 return(TXM_MODULE_INVALID_MEMORY);
646 }
647 }
648 }
649
650 return_value = (ALIGN_TYPE) _txe_byte_release(
651 (VOID *) param_0
652 );
653 return(return_value);
654 }
655 #endif
656
657 #ifndef TXM_EVENT_FLAGS_CREATE_CALL_NOT_USED
658 /* UINT _txe_event_flags_create(
659 TX_EVENT_FLAGS_GROUP *group_ptr, -> param_0
660 CHAR *name_ptr, -> param_1
661 UINT event_control_block_size -> param_2
662 ); */
_txm_module_manager_tx_event_flags_create_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE param_2)663 static ALIGN_TYPE _txm_module_manager_tx_event_flags_create_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE param_2)
664 {
665
666 ALIGN_TYPE return_value;
667
668 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
669 {
670 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_CREATION(module_instance, param_0, sizeof(TX_EVENT_FLAGS_GROUP)))
671 return(TXM_MODULE_INVALID_MEMORY);
672
673 if (!TXM_MODULE_MANAGER_PARAM_CHECK_DEREFERENCE_STRING(module_instance, param_1))
674 return(TXM_MODULE_INVALID_MEMORY);
675 }
676
677 return_value = (ALIGN_TYPE) _txe_event_flags_create(
678 (TX_EVENT_FLAGS_GROUP *) param_0,
679 (CHAR *) param_1,
680 (UINT) param_2
681 );
682 return(return_value);
683 }
684 #endif
685
686 #ifndef TXM_EVENT_FLAGS_DELETE_CALL_NOT_USED
687 /* UINT _txe_event_flags_delete(
688 TX_EVENT_FLAGS_GROUP *group_ptr -> param_0
689 ); */
_txm_module_manager_tx_event_flags_delete_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0)690 static ALIGN_TYPE _txm_module_manager_tx_event_flags_delete_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0)
691 {
692
693 ALIGN_TYPE return_value;
694
695 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
696 {
697 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_EVENT_FLAGS_GROUP)))
698 return(TXM_MODULE_INVALID_MEMORY);
699 }
700
701 return_value = (ALIGN_TYPE) _txe_event_flags_delete(
702 (TX_EVENT_FLAGS_GROUP *) param_0
703 );
704
705 /* Deallocate object memory. */
706 if (return_value == TX_SUCCESS)
707 {
708 return_value = _txm_module_manager_object_deallocate((VOID *) param_0);
709 }
710 return(return_value);
711 }
712 #endif
713
714 #ifndef TXM_EVENT_FLAGS_GET_CALL_NOT_USED
715 /* UINT _txe_event_flags_get(
716 TX_EVENT_FLAGS_GROUP *group_ptr, -> param_0
717 ULONG requested_flags, -> param_1
718 UINT get_option, -> extra_parameters[0]
719 ULONG *actual_flags_ptr, -> extra_parameters[1]
720 ULONG wait_option -> extra_parameters[2]
721 ); */
_txm_module_manager_tx_event_flags_get_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE * extra_parameters)722 static ALIGN_TYPE _txm_module_manager_tx_event_flags_get_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE *extra_parameters)
723 {
724
725 ALIGN_TYPE return_value;
726
727 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
728 {
729 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_EVENT_FLAGS_GROUP)))
730 return(TXM_MODULE_INVALID_MEMORY);
731
732 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[1], sizeof(ULONG)))
733 return(TXM_MODULE_INVALID_MEMORY);
734
735 if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[3])))
736 return(TXM_MODULE_INVALID_MEMORY);
737 }
738
739 return_value = (ALIGN_TYPE) _txe_event_flags_get(
740 (TX_EVENT_FLAGS_GROUP *) param_0,
741 (ULONG) param_1,
742 (UINT) extra_parameters[0],
743 (ULONG *) extra_parameters[1],
744 (ULONG) extra_parameters[2]
745 );
746 return(return_value);
747 }
748 #endif
749
750 #ifndef TXM_EVENT_FLAGS_INFO_GET_CALL_NOT_USED
751 /* UINT _txe_event_flags_info_get(
752 TX_EVENT_FLAGS_GROUP *group_ptr, -> param_0
753 CHAR **name, -> param_1
754 ULONG *current_flags, -> extra_parameters[0]
755 TX_THREAD **first_suspended, -> extra_parameters[1]
756 ULONG *suspended_count, -> extra_parameters[2]
757 TX_EVENT_FLAGS_GROUP **next_group -> extra_parameters[3]
758 ); */
_txm_module_manager_tx_event_flags_info_get_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE * extra_parameters)759 static ALIGN_TYPE _txm_module_manager_tx_event_flags_info_get_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE *extra_parameters)
760 {
761
762 ALIGN_TYPE return_value;
763
764 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
765 {
766 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_EVENT_FLAGS_GROUP)))
767 return(TXM_MODULE_INVALID_MEMORY);
768
769 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(CHAR *)))
770 return(TXM_MODULE_INVALID_MEMORY);
771
772 if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[4])))
773 return(TXM_MODULE_INVALID_MEMORY);
774
775 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], sizeof(ULONG)))
776 return(TXM_MODULE_INVALID_MEMORY);
777
778 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[1], sizeof(TX_THREAD *)))
779 return(TXM_MODULE_INVALID_MEMORY);
780
781 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[2], sizeof(ULONG)))
782 return(TXM_MODULE_INVALID_MEMORY);
783
784 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[3], sizeof(TX_EVENT_FLAGS_GROUP *)))
785 return(TXM_MODULE_INVALID_MEMORY);
786 }
787
788 return_value = (ALIGN_TYPE) _txe_event_flags_info_get(
789 (TX_EVENT_FLAGS_GROUP *) param_0,
790 (CHAR **) param_1,
791 (ULONG *) extra_parameters[0],
792 (TX_THREAD **) extra_parameters[1],
793 (ULONG *) extra_parameters[2],
794 (TX_EVENT_FLAGS_GROUP **) extra_parameters[3]
795 );
796 return(return_value);
797 }
798 #endif
799
800 #ifndef TXM_EVENT_FLAGS_PERFORMANCE_INFO_GET_CALL_NOT_USED
801 /* UINT _tx_event_flags_performance_info_get(
802 TX_EVENT_FLAGS_GROUP *group_ptr, -> param_0
803 ULONG *sets, -> param_1
804 ULONG *gets, -> extra_parameters[0]
805 ULONG *suspensions, -> extra_parameters[1]
806 ULONG *timeouts -> extra_parameters[2]
807 ); */
_txm_module_manager_tx_event_flags_performance_info_get_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE * extra_parameters)808 static ALIGN_TYPE _txm_module_manager_tx_event_flags_performance_info_get_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE *extra_parameters)
809 {
810
811 ALIGN_TYPE return_value;
812
813 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
814 {
815 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_EVENT_FLAGS_GROUP)))
816 return(TXM_MODULE_INVALID_MEMORY);
817
818 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(ULONG)))
819 return(TXM_MODULE_INVALID_MEMORY);
820
821 if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[3])))
822 return(TXM_MODULE_INVALID_MEMORY);
823
824 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], sizeof(ULONG)))
825 return(TXM_MODULE_INVALID_MEMORY);
826
827 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[1], sizeof(ULONG)))
828 return(TXM_MODULE_INVALID_MEMORY);
829
830 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[2], sizeof(ULONG)))
831 return(TXM_MODULE_INVALID_MEMORY);
832 }
833
834 return_value = (ALIGN_TYPE) _tx_event_flags_performance_info_get(
835 (TX_EVENT_FLAGS_GROUP *) param_0,
836 (ULONG *) param_1,
837 (ULONG *) extra_parameters[0],
838 (ULONG *) extra_parameters[1],
839 (ULONG *) extra_parameters[2]
840 );
841 return(return_value);
842 }
843 #endif
844
845 #ifndef TXM_EVENT_FLAGS_PERFORMANCE_SYSTEM_INFO_GET_CALL_NOT_USED
846 /* UINT _tx_event_flags_performance_system_info_get(
847 ULONG *sets, -> param_0
848 ULONG *gets, -> param_1
849 ULONG *suspensions, -> extra_parameters[0]
850 ULONG *timeouts -> extra_parameters[1]
851 ); */
_txm_module_manager_tx_event_flags_performance_system_info_get_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE * extra_parameters)852 static ALIGN_TYPE _txm_module_manager_tx_event_flags_performance_system_info_get_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE *extra_parameters)
853 {
854
855 ALIGN_TYPE return_value;
856
857 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
858 {
859 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_0, sizeof(ULONG)))
860 return(TXM_MODULE_INVALID_MEMORY);
861
862 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(ULONG)))
863 return(TXM_MODULE_INVALID_MEMORY);
864
865 if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[2])))
866 return(TXM_MODULE_INVALID_MEMORY);
867
868 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], sizeof(ULONG)))
869 return(TXM_MODULE_INVALID_MEMORY);
870
871 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[1], sizeof(ULONG)))
872 return(TXM_MODULE_INVALID_MEMORY);
873 }
874
875 return_value = (ALIGN_TYPE) _tx_event_flags_performance_system_info_get(
876 (ULONG *) param_0,
877 (ULONG *) param_1,
878 (ULONG *) extra_parameters[0],
879 (ULONG *) extra_parameters[1]
880 );
881 return(return_value);
882 }
883 #endif
884
885 #ifndef TXM_EVENT_FLAGS_SET_CALL_NOT_USED
886 /* UINT _txe_event_flags_set(
887 TX_EVENT_FLAGS_GROUP *group_ptr, -> param_0
888 ULONG flags_to_set, -> param_1
889 UINT set_option -> param_2
890 ); */
_txm_module_manager_tx_event_flags_set_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE param_2)891 static ALIGN_TYPE _txm_module_manager_tx_event_flags_set_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE param_2)
892 {
893
894 ALIGN_TYPE return_value;
895
896 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
897 {
898 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_EVENT_FLAGS_GROUP)))
899 return(TXM_MODULE_INVALID_MEMORY);
900 }
901
902 return_value = (ALIGN_TYPE) _txe_event_flags_set(
903 (TX_EVENT_FLAGS_GROUP *) param_0,
904 (ULONG) param_1,
905 (UINT) param_2
906 );
907 return(return_value);
908 }
909 #endif
910
911 #ifndef TXM_EVENT_FLAGS_SET_NOTIFY_CALL_NOT_USED
912 /* UINT _txe_event_flags_set_notify(
913 TX_EVENT_FLAGS_GROUP *group_ptr, -> param_0
914 VOID (*events_set_notify)(TX_EVENT_FLAGS_GROUP *) -> param_1
915 ); */
_txm_module_manager_tx_event_flags_set_notify_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1)916 static ALIGN_TYPE _txm_module_manager_tx_event_flags_set_notify_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1)
917 {
918
919 ALIGN_TYPE return_value;
920 TX_EVENT_FLAGS_GROUP *event_flags_ptr = (TX_EVENT_FLAGS_GROUP *)param_0;
921 VOID (*events_set_notify)(TX_EVENT_FLAGS_GROUP *);
922
923 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
924 {
925 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_EVENT_FLAGS_GROUP)))
926 return(TXM_MODULE_INVALID_MEMORY);
927
928 /* Since we need to write to the object, ensure it's valid. */
929 if ((event_flags_ptr == TX_NULL) || (event_flags_ptr -> tx_event_flags_group_id != TX_EVENT_FLAGS_ID))
930 return(TX_GROUP_ERROR);
931 }
932
933 /* Is it a disable request? */
934 if ((void *) param_1 == TX_NULL)
935 {
936
937 /* Clear the callback. */
938 events_set_notify = (VOID (*)(TX_EVENT_FLAGS_GROUP *)) TX_NULL;
939 }
940 else
941 {
942
943 /* Setup trampoline values. */
944 event_flags_ptr -> tx_event_flags_group_module_instance = (VOID *) module_instance;
945 event_flags_ptr -> tx_event_flags_group_set_module_notify = (VOID (*)(TX_EVENT_FLAGS_GROUP *)) param_1;
946 events_set_notify = _txm_module_manager_event_flags_notify_trampoline;
947 }
948
949 return_value = (ALIGN_TYPE) _txe_event_flags_set_notify(
950 (TX_EVENT_FLAGS_GROUP *) param_0,
951 (VOID (*)(TX_EVENT_FLAGS_GROUP *)) events_set_notify
952 );
953 return(return_value);
954 }
955 #endif
956
957 #ifndef TXM_MUTEX_CREATE_CALL_NOT_USED
958 /* UINT _txe_mutex_create(
959 TX_MUTEX *mutex_ptr, -> param_0
960 CHAR *name_ptr, -> param_1
961 UINT inherit, -> extra_parameters[0]
962 UINT mutex_control_block_size -> extra_parameters[1]
963 ); */
_txm_module_manager_tx_mutex_create_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE * extra_parameters)964 static ALIGN_TYPE _txm_module_manager_tx_mutex_create_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE *extra_parameters)
965 {
966
967 ALIGN_TYPE return_value;
968
969 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
970 {
971 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_CREATION(module_instance, param_0, sizeof(TX_MUTEX)))
972 return(TXM_MODULE_INVALID_MEMORY);
973
974 if (!TXM_MODULE_MANAGER_PARAM_CHECK_DEREFERENCE_STRING(module_instance, param_1))
975 return(TXM_MODULE_INVALID_MEMORY);
976
977 if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[2])))
978 return(TXM_MODULE_INVALID_MEMORY);
979 }
980
981 return_value = (ALIGN_TYPE) _txe_mutex_create(
982 (TX_MUTEX *) param_0,
983 (CHAR *) param_1,
984 (UINT) extra_parameters[0],
985 (UINT) extra_parameters[1]
986 );
987 return(return_value);
988 }
989 #endif
990
991 #ifndef TXM_MUTEX_DELETE_CALL_NOT_USED
992 /* UINT _txe_mutex_delete(
993 TX_MUTEX *mutex_ptr -> param_0
994 ); */
_txm_module_manager_tx_mutex_delete_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0)995 static ALIGN_TYPE _txm_module_manager_tx_mutex_delete_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0)
996 {
997
998 ALIGN_TYPE return_value;
999
1000 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
1001 {
1002 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_MUTEX)))
1003 return(TXM_MODULE_INVALID_MEMORY);
1004 }
1005
1006 return_value = (ALIGN_TYPE) _txe_mutex_delete(
1007 (TX_MUTEX *) param_0
1008 );
1009
1010 /* Deallocate object memory. */
1011 if (return_value == TX_SUCCESS)
1012 {
1013 return_value = _txm_module_manager_object_deallocate((VOID *) param_0);
1014 }
1015 return(return_value);
1016 }
1017 #endif
1018
1019 #ifndef TXM_MUTEX_GET_CALL_NOT_USED
1020 /* UINT _txe_mutex_get(
1021 TX_MUTEX *mutex_ptr, -> param_0
1022 ULONG wait_option -> param_1
1023 ); */
_txm_module_manager_tx_mutex_get_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1)1024 static ALIGN_TYPE _txm_module_manager_tx_mutex_get_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1)
1025 {
1026
1027 ALIGN_TYPE return_value;
1028
1029 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
1030 {
1031 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_MUTEX)))
1032 return(TXM_MODULE_INVALID_MEMORY);
1033 }
1034
1035 return_value = (ALIGN_TYPE) _txe_mutex_get(
1036 (TX_MUTEX *) param_0,
1037 (ULONG) param_1
1038 );
1039 return(return_value);
1040 }
1041 #endif
1042
1043 #ifndef TXM_MUTEX_INFO_GET_CALL_NOT_USED
1044 /* UINT _txe_mutex_info_get(
1045 TX_MUTEX *mutex_ptr, -> param_0
1046 CHAR **name, -> param_1
1047 ULONG *count, -> extra_parameters[0]
1048 TX_THREAD **owner, -> extra_parameters[1]
1049 TX_THREAD **first_suspended, -> extra_parameters[2]
1050 ULONG *suspended_count, -> extra_parameters[3]
1051 TX_MUTEX **next_mutex -> extra_parameters[4]
1052 ); */
_txm_module_manager_tx_mutex_info_get_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE * extra_parameters)1053 static ALIGN_TYPE _txm_module_manager_tx_mutex_info_get_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE *extra_parameters)
1054 {
1055
1056 ALIGN_TYPE return_value;
1057
1058 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
1059 {
1060 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_MUTEX)))
1061 return(TXM_MODULE_INVALID_MEMORY);
1062
1063 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(CHAR *)))
1064 return(TXM_MODULE_INVALID_MEMORY);
1065
1066 if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[5])))
1067 return(TXM_MODULE_INVALID_MEMORY);
1068
1069 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], sizeof(ULONG)))
1070 return(TXM_MODULE_INVALID_MEMORY);
1071
1072 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[1], sizeof(TX_THREAD *)))
1073 return(TXM_MODULE_INVALID_MEMORY);
1074
1075 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[2], sizeof(TX_THREAD *)))
1076 return(TXM_MODULE_INVALID_MEMORY);
1077
1078 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[3], sizeof(ULONG)))
1079 return(TXM_MODULE_INVALID_MEMORY);
1080
1081 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[4], sizeof(TX_MUTEX *)))
1082 return(TXM_MODULE_INVALID_MEMORY);
1083 }
1084
1085 return_value = (ALIGN_TYPE) _txe_mutex_info_get(
1086 (TX_MUTEX *) param_0,
1087 (CHAR **) param_1,
1088 (ULONG *) extra_parameters[0],
1089 (TX_THREAD **) extra_parameters[1],
1090 (TX_THREAD **) extra_parameters[2],
1091 (ULONG *) extra_parameters[3],
1092 (TX_MUTEX **) extra_parameters[4]
1093 );
1094 return(return_value);
1095 }
1096 #endif
1097
1098 #ifndef TXM_MUTEX_PERFORMANCE_INFO_GET_CALL_NOT_USED
1099 /* UINT _tx_mutex_performance_info_get(
1100 TX_MUTEX *mutex_ptr, -> param_0
1101 ULONG *puts, -> param_1
1102 ULONG *gets, -> extra_parameters[0]
1103 ULONG *suspensions, -> extra_parameters[1]
1104 ULONG *timeouts, -> extra_parameters[2]
1105 ULONG *inversions, -> extra_parameters[3]
1106 ULONG *inheritances -> extra_parameters[4]
1107 ); */
_txm_module_manager_tx_mutex_performance_info_get_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE * extra_parameters)1108 static ALIGN_TYPE _txm_module_manager_tx_mutex_performance_info_get_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE *extra_parameters)
1109 {
1110
1111 ALIGN_TYPE return_value;
1112
1113 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
1114 {
1115 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_MUTEX)))
1116 return(TXM_MODULE_INVALID_MEMORY);
1117
1118 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(ULONG)))
1119 return(TXM_MODULE_INVALID_MEMORY);
1120
1121 if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[5])))
1122 return(TXM_MODULE_INVALID_MEMORY);
1123
1124 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], sizeof(ULONG)))
1125 return(TXM_MODULE_INVALID_MEMORY);
1126
1127 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[1], sizeof(ULONG)))
1128 return(TXM_MODULE_INVALID_MEMORY);
1129
1130 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[2], sizeof(ULONG)))
1131 return(TXM_MODULE_INVALID_MEMORY);
1132
1133 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[3], sizeof(ULONG)))
1134 return(TXM_MODULE_INVALID_MEMORY);
1135
1136 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[4], sizeof(ULONG)))
1137 return(TXM_MODULE_INVALID_MEMORY);
1138 }
1139
1140 return_value = (ALIGN_TYPE) _tx_mutex_performance_info_get(
1141 (TX_MUTEX *) param_0,
1142 (ULONG *) param_1,
1143 (ULONG *) extra_parameters[0],
1144 (ULONG *) extra_parameters[1],
1145 (ULONG *) extra_parameters[2],
1146 (ULONG *) extra_parameters[3],
1147 (ULONG *) extra_parameters[4]
1148 );
1149 return(return_value);
1150 }
1151 #endif
1152
1153 #ifndef TXM_MUTEX_PERFORMANCE_SYSTEM_INFO_GET_CALL_NOT_USED
1154 /* UINT _tx_mutex_performance_system_info_get(
1155 ULONG *puts, -> param_0
1156 ULONG *gets, -> param_1
1157 ULONG *suspensions, -> extra_parameters[0]
1158 ULONG *timeouts, -> extra_parameters[1]
1159 ULONG *inversions, -> extra_parameters[2]
1160 ULONG *inheritances -> extra_parameters[3]
1161 ); */
_txm_module_manager_tx_mutex_performance_system_info_get_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE * extra_parameters)1162 static ALIGN_TYPE _txm_module_manager_tx_mutex_performance_system_info_get_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE *extra_parameters)
1163 {
1164
1165 ALIGN_TYPE return_value;
1166
1167 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
1168 {
1169 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_0, sizeof(ULONG)))
1170 return(TXM_MODULE_INVALID_MEMORY);
1171
1172 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(ULONG)))
1173 return(TXM_MODULE_INVALID_MEMORY);
1174
1175 if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[4])))
1176 return(TXM_MODULE_INVALID_MEMORY);
1177
1178 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], sizeof(ULONG)))
1179 return(TXM_MODULE_INVALID_MEMORY);
1180
1181 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[1], sizeof(ULONG)))
1182 return(TXM_MODULE_INVALID_MEMORY);
1183
1184 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[2], sizeof(ULONG)))
1185 return(TXM_MODULE_INVALID_MEMORY);
1186
1187 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[3], sizeof(ULONG)))
1188 return(TXM_MODULE_INVALID_MEMORY);
1189 }
1190
1191 return_value = (ALIGN_TYPE) _tx_mutex_performance_system_info_get(
1192 (ULONG *) param_0,
1193 (ULONG *) param_1,
1194 (ULONG *) extra_parameters[0],
1195 (ULONG *) extra_parameters[1],
1196 (ULONG *) extra_parameters[2],
1197 (ULONG *) extra_parameters[3]
1198 );
1199 return(return_value);
1200 }
1201 #endif
1202
1203 #ifndef TXM_MUTEX_PRIORITIZE_CALL_NOT_USED
1204 /* UINT _txe_mutex_prioritize(
1205 TX_MUTEX *mutex_ptr -> param_0
1206 ); */
_txm_module_manager_tx_mutex_prioritize_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0)1207 static ALIGN_TYPE _txm_module_manager_tx_mutex_prioritize_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0)
1208 {
1209
1210 ALIGN_TYPE return_value;
1211
1212 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
1213 {
1214 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_MUTEX)))
1215 return(TXM_MODULE_INVALID_MEMORY);
1216 }
1217
1218 return_value = (ALIGN_TYPE) _txe_mutex_prioritize(
1219 (TX_MUTEX *) param_0
1220 );
1221 return(return_value);
1222 }
1223 #endif
1224
1225 #ifndef TXM_MUTEX_PUT_CALL_NOT_USED
1226 /* UINT _txe_mutex_put(
1227 TX_MUTEX *mutex_ptr -> param_0
1228 ); */
_txm_module_manager_tx_mutex_put_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0)1229 static ALIGN_TYPE _txm_module_manager_tx_mutex_put_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0)
1230 {
1231
1232 ALIGN_TYPE return_value;
1233
1234 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
1235 {
1236 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_MUTEX)))
1237 return(TXM_MODULE_INVALID_MEMORY);
1238 }
1239
1240 return_value = (ALIGN_TYPE) _txe_mutex_put(
1241 (TX_MUTEX *) param_0
1242 );
1243 return(return_value);
1244 }
1245 #endif
1246
1247 #ifndef TXM_QUEUE_CREATE_CALL_NOT_USED
1248 /* UINT _txe_queue_create(
1249 TX_QUEUE *queue_ptr, -> param_0
1250 CHAR *name_ptr, -> param_1
1251 UINT message_size, -> extra_parameters[0]
1252 VOID *queue_start, -> extra_parameters[1]
1253 ULONG queue_size, -> extra_parameters[2]
1254 UINT queue_control_block_size -> extra_parameters[3]
1255 ); */
_txm_module_manager_tx_queue_create_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE * extra_parameters)1256 static ALIGN_TYPE _txm_module_manager_tx_queue_create_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE *extra_parameters)
1257 {
1258
1259 ALIGN_TYPE return_value;
1260
1261 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
1262 {
1263 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_CREATION(module_instance, param_0, sizeof(TX_QUEUE)))
1264 return(TXM_MODULE_INVALID_MEMORY);
1265
1266 if (!TXM_MODULE_MANAGER_PARAM_CHECK_DEREFERENCE_STRING(module_instance, param_1))
1267 return(TXM_MODULE_INVALID_MEMORY);
1268
1269 if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[4])))
1270 return(TXM_MODULE_INVALID_MEMORY);
1271
1272 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[1], extra_parameters[2]))
1273 return(TXM_MODULE_INVALID_MEMORY);
1274 }
1275
1276 return_value = (ALIGN_TYPE) _txe_queue_create(
1277 (TX_QUEUE *) param_0,
1278 (CHAR *) param_1,
1279 (UINT) extra_parameters[0],
1280 (VOID *) extra_parameters[1],
1281 (ULONG) extra_parameters[2],
1282 (UINT) extra_parameters[3]
1283 );
1284 return(return_value);
1285 }
1286 #endif
1287
1288 #ifndef TXM_QUEUE_DELETE_CALL_NOT_USED
1289 /* UINT _txe_queue_delete(
1290 TX_QUEUE *queue_ptr -> param_0
1291 ); */
_txm_module_manager_tx_queue_delete_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0)1292 static ALIGN_TYPE _txm_module_manager_tx_queue_delete_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0)
1293 {
1294
1295 ALIGN_TYPE return_value;
1296
1297 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
1298 {
1299 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_QUEUE)))
1300 return(TXM_MODULE_INVALID_MEMORY);
1301 }
1302
1303 return_value = (ALIGN_TYPE) _txe_queue_delete(
1304 (TX_QUEUE *) param_0
1305 );
1306
1307 /* Deallocate object memory. */
1308 if (return_value == TX_SUCCESS)
1309 {
1310 return_value = _txm_module_manager_object_deallocate((VOID *) param_0);
1311 }
1312 return(return_value);
1313 }
1314 #endif
1315
1316 #ifndef TXM_QUEUE_FLUSH_CALL_NOT_USED
1317 /* UINT _txe_queue_flush(
1318 TX_QUEUE *queue_ptr -> param_0
1319 ); */
_txm_module_manager_tx_queue_flush_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0)1320 static ALIGN_TYPE _txm_module_manager_tx_queue_flush_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0)
1321 {
1322
1323 ALIGN_TYPE return_value;
1324
1325 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
1326 {
1327 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_QUEUE)))
1328 return(TXM_MODULE_INVALID_MEMORY);
1329 }
1330
1331 return_value = (ALIGN_TYPE) _txe_queue_flush(
1332 (TX_QUEUE *) param_0
1333 );
1334 return(return_value);
1335 }
1336 #endif
1337
1338 #ifndef TXM_QUEUE_FRONT_SEND_CALL_NOT_USED
1339 /* UINT _txe_queue_front_send(
1340 TX_QUEUE *queue_ptr, -> param_0
1341 VOID *source_ptr, -> param_1
1342 ULONG wait_option -> param_2
1343 ); */
_txm_module_manager_tx_queue_front_send_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE param_2)1344 static ALIGN_TYPE _txm_module_manager_tx_queue_front_send_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE param_2)
1345 {
1346
1347 ALIGN_TYPE return_value;
1348 TX_QUEUE *queue_ptr;
1349
1350 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
1351 {
1352 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_QUEUE)))
1353 return(TXM_MODULE_INVALID_MEMORY);
1354
1355 /* We need to get the size of the message from the queue. */
1356 queue_ptr = (TX_QUEUE *) param_0;
1357 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_READ(module_instance, param_1, queue_ptr -> tx_queue_message_size))
1358 return(TXM_MODULE_INVALID_MEMORY);
1359 }
1360
1361 return_value = (ALIGN_TYPE) _txe_queue_front_send(
1362 (TX_QUEUE *) param_0,
1363 (VOID *) param_1,
1364 (ULONG) param_2
1365 );
1366 return(return_value);
1367 }
1368 #endif
1369
1370 #ifndef TXM_QUEUE_INFO_GET_CALL_NOT_USED
1371 /* UINT _txe_queue_info_get(
1372 TX_QUEUE *queue_ptr, -> param_0
1373 CHAR **name, -> param_1
1374 ULONG *enqueued, -> extra_parameters[0]
1375 ULONG *available_storage, -> extra_parameters[1]
1376 TX_THREAD **first_suspended, -> extra_parameters[2]
1377 ULONG *suspended_count, -> extra_parameters[3]
1378 TX_QUEUE **next_queue -> extra_parameters[4]
1379 ); */
_txm_module_manager_tx_queue_info_get_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE * extra_parameters)1380 static ALIGN_TYPE _txm_module_manager_tx_queue_info_get_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE *extra_parameters)
1381 {
1382
1383 ALIGN_TYPE return_value;
1384
1385 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
1386 {
1387 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_QUEUE)))
1388 return(TXM_MODULE_INVALID_MEMORY);
1389
1390 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(CHAR *)))
1391 return(TXM_MODULE_INVALID_MEMORY);
1392
1393 if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[5])))
1394 return(TXM_MODULE_INVALID_MEMORY);
1395
1396 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], sizeof(ULONG)))
1397 return(TXM_MODULE_INVALID_MEMORY);
1398
1399 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[1], sizeof(ULONG)))
1400 return(TXM_MODULE_INVALID_MEMORY);
1401
1402 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[2], sizeof(TX_THREAD *)))
1403 return(TXM_MODULE_INVALID_MEMORY);
1404
1405 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[3], sizeof(ULONG)))
1406 return(TXM_MODULE_INVALID_MEMORY);
1407
1408 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[4], sizeof(TX_QUEUE *)))
1409 return(TXM_MODULE_INVALID_MEMORY);
1410 }
1411
1412 return_value = (ALIGN_TYPE) _txe_queue_info_get(
1413 (TX_QUEUE *) param_0,
1414 (CHAR **) param_1,
1415 (ULONG *) extra_parameters[0],
1416 (ULONG *) extra_parameters[1],
1417 (TX_THREAD **) extra_parameters[2],
1418 (ULONG *) extra_parameters[3],
1419 (TX_QUEUE **) extra_parameters[4]
1420 );
1421 return(return_value);
1422 }
1423 #endif
1424
1425 #ifndef TXM_QUEUE_PERFORMANCE_INFO_GET_CALL_NOT_USED
1426 /* UINT _tx_queue_performance_info_get(
1427 TX_QUEUE *queue_ptr, -> param_0
1428 ULONG *messages_sent, -> param_1
1429 ULONG *messages_received, -> extra_parameters[0]
1430 ULONG *empty_suspensions, -> extra_parameters[1]
1431 ULONG *full_suspensions, -> extra_parameters[2]
1432 ULONG *full_errors, -> extra_parameters[3]
1433 ULONG *timeouts -> extra_parameters[4]
1434 ); */
_txm_module_manager_tx_queue_performance_info_get_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE * extra_parameters)1435 static ALIGN_TYPE _txm_module_manager_tx_queue_performance_info_get_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE *extra_parameters)
1436 {
1437
1438 ALIGN_TYPE return_value;
1439
1440 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
1441 {
1442 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_QUEUE)))
1443 return(TXM_MODULE_INVALID_MEMORY);
1444
1445 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(ULONG)))
1446 return(TXM_MODULE_INVALID_MEMORY);
1447
1448 if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[5])))
1449 return(TXM_MODULE_INVALID_MEMORY);
1450
1451 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], sizeof(ULONG)))
1452 return(TXM_MODULE_INVALID_MEMORY);
1453
1454 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[1], sizeof(ULONG)))
1455 return(TXM_MODULE_INVALID_MEMORY);
1456
1457 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[2], sizeof(ULONG)))
1458 return(TXM_MODULE_INVALID_MEMORY);
1459
1460 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[3], sizeof(ULONG)))
1461 return(TXM_MODULE_INVALID_MEMORY);
1462
1463 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[4], sizeof(ULONG)))
1464 return(TXM_MODULE_INVALID_MEMORY);
1465 }
1466
1467 return_value = (ALIGN_TYPE) _tx_queue_performance_info_get(
1468 (TX_QUEUE *) param_0,
1469 (ULONG *) param_1,
1470 (ULONG *) extra_parameters[0],
1471 (ULONG *) extra_parameters[1],
1472 (ULONG *) extra_parameters[2],
1473 (ULONG *) extra_parameters[3],
1474 (ULONG *) extra_parameters[4]
1475 );
1476 return(return_value);
1477 }
1478 #endif
1479
1480 #ifndef TXM_QUEUE_PERFORMANCE_SYSTEM_INFO_GET_CALL_NOT_USED
1481 /* UINT _tx_queue_performance_system_info_get(
1482 ULONG *messages_sent, -> param_0
1483 ULONG *messages_received, -> param_1
1484 ULONG *empty_suspensions, -> extra_parameters[0]
1485 ULONG *full_suspensions, -> extra_parameters[1]
1486 ULONG *full_errors, -> extra_parameters[2]
1487 ULONG *timeouts -> extra_parameters[3]
1488 ); */
_txm_module_manager_tx_queue_performance_system_info_get_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE * extra_parameters)1489 static ALIGN_TYPE _txm_module_manager_tx_queue_performance_system_info_get_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE *extra_parameters)
1490 {
1491
1492 ALIGN_TYPE return_value;
1493
1494 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
1495 {
1496 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_0, sizeof(ULONG)))
1497 return(TXM_MODULE_INVALID_MEMORY);
1498
1499 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(ULONG)))
1500 return(TXM_MODULE_INVALID_MEMORY);
1501
1502 if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[4])))
1503 return(TXM_MODULE_INVALID_MEMORY);
1504
1505 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], sizeof(ULONG)))
1506 return(TXM_MODULE_INVALID_MEMORY);
1507
1508 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[1], sizeof(ULONG)))
1509 return(TXM_MODULE_INVALID_MEMORY);
1510
1511 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[2], sizeof(ULONG)))
1512 return(TXM_MODULE_INVALID_MEMORY);
1513
1514 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[3], sizeof(ULONG)))
1515 return(TXM_MODULE_INVALID_MEMORY);
1516 }
1517
1518 return_value = (ALIGN_TYPE) _tx_queue_performance_system_info_get(
1519 (ULONG *) param_0,
1520 (ULONG *) param_1,
1521 (ULONG *) extra_parameters[0],
1522 (ULONG *) extra_parameters[1],
1523 (ULONG *) extra_parameters[2],
1524 (ULONG *) extra_parameters[3]
1525 );
1526 return(return_value);
1527 }
1528 #endif
1529
1530 #ifndef TXM_QUEUE_PRIORITIZE_CALL_NOT_USED
1531 /* UINT _txe_queue_prioritize(
1532 TX_QUEUE *queue_ptr -> param_0
1533 ); */
_txm_module_manager_tx_queue_prioritize_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0)1534 static ALIGN_TYPE _txm_module_manager_tx_queue_prioritize_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0)
1535 {
1536
1537 ALIGN_TYPE return_value;
1538
1539 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
1540 {
1541 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_QUEUE)))
1542 return(TXM_MODULE_INVALID_MEMORY);
1543 }
1544
1545 return_value = (ALIGN_TYPE) _txe_queue_prioritize(
1546 (TX_QUEUE *) param_0
1547 );
1548 return(return_value);
1549 }
1550 #endif
1551
1552 #ifndef TXM_QUEUE_RECEIVE_CALL_NOT_USED
1553 /* UINT _txe_queue_receive(
1554 TX_QUEUE *queue_ptr, -> param_0
1555 VOID *destination_ptr, -> param_1
1556 ULONG wait_option -> param_2
1557 ); */
_txm_module_manager_tx_queue_receive_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE param_2)1558 static ALIGN_TYPE _txm_module_manager_tx_queue_receive_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE param_2)
1559 {
1560
1561 ALIGN_TYPE return_value;
1562 TX_QUEUE *queue_ptr;
1563
1564 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
1565 {
1566 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_QUEUE)))
1567 return(TXM_MODULE_INVALID_MEMORY);
1568
1569 /* We need to get the max size of the buffer from the queue. */
1570 queue_ptr = (TX_QUEUE *) param_0;
1571 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(ULONG)*queue_ptr -> tx_queue_message_size))
1572 return(TXM_MODULE_INVALID_MEMORY);
1573 }
1574
1575 return_value = (ALIGN_TYPE) _txe_queue_receive(
1576 (TX_QUEUE *) param_0,
1577 (VOID *) param_1,
1578 (ULONG) param_2
1579 );
1580 return(return_value);
1581 }
1582 #endif
1583
1584 #ifndef TXM_QUEUE_SEND_CALL_NOT_USED
1585 /* UINT _txe_queue_send(
1586 TX_QUEUE *queue_ptr, -> param_0
1587 VOID *source_ptr, -> param_1
1588 ULONG wait_option -> param_2
1589 ); */
_txm_module_manager_tx_queue_send_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE param_2)1590 static ALIGN_TYPE _txm_module_manager_tx_queue_send_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE param_2)
1591 {
1592
1593 ALIGN_TYPE return_value;
1594 TX_QUEUE *queue_ptr;
1595
1596 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
1597 {
1598 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_QUEUE)))
1599 return(TXM_MODULE_INVALID_MEMORY);
1600
1601 /* We need to get the size of the message from the queue. */
1602 queue_ptr = (TX_QUEUE *) param_0;
1603 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_READ(module_instance, param_1, sizeof(ULONG)*queue_ptr -> tx_queue_message_size))
1604 return(TXM_MODULE_INVALID_MEMORY);
1605 }
1606
1607 return_value = (ALIGN_TYPE) _txe_queue_send(
1608 (TX_QUEUE *) param_0,
1609 (VOID *) param_1,
1610 (ULONG) param_2
1611 );
1612 return(return_value);
1613 }
1614 #endif
1615
1616 #ifndef TXM_QUEUE_SEND_NOTIFY_CALL_NOT_USED
1617 /* UINT _txe_queue_send_notify(
1618 TX_QUEUE *queue_ptr, -> param_0
1619 VOID (*queue_send_notify)(TX_QUEUE *notify_queue_ptr) -> param_1
1620 ); */
_txm_module_manager_tx_queue_send_notify_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1)1621 static ALIGN_TYPE _txm_module_manager_tx_queue_send_notify_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1)
1622 {
1623
1624 ALIGN_TYPE return_value;
1625 TX_QUEUE *queue_ptr = (TX_QUEUE *) param_0;
1626 VOID (*queue_send_notify)(TX_QUEUE *);
1627
1628 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
1629 {
1630 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_QUEUE)))
1631 return(TXM_MODULE_INVALID_MEMORY);
1632
1633 /* Since we need to write to the object, ensure it's valid. */
1634 if ((queue_ptr == TX_NULL) || (queue_ptr -> tx_queue_id != TX_QUEUE_ID))
1635 return(TX_QUEUE_ERROR);
1636 }
1637
1638 /* Is it a disable request? */
1639 if ((void *) param_1 == TX_NULL)
1640 {
1641
1642 /* Clear the callback. */
1643 queue_send_notify = (VOID (*)(TX_QUEUE *)) TX_NULL;
1644 }
1645 else
1646 {
1647
1648 /* Setup trampoline values. */
1649 queue_ptr -> tx_queue_module_instance = (VOID *) module_instance;
1650 queue_ptr -> tx_queue_send_module_notify = (VOID (*)(TX_QUEUE *)) param_1;
1651 queue_send_notify = _txm_module_manager_queue_notify_trampoline;
1652 }
1653
1654 return_value = (ALIGN_TYPE) _txe_queue_send_notify(
1655 (TX_QUEUE *) param_0,
1656 (VOID (*)(TX_QUEUE *notify_queue_ptr)) queue_send_notify
1657 );
1658 return(return_value);
1659 }
1660 #endif
1661
1662 #ifndef TXM_SEMAPHORE_CEILING_PUT_CALL_NOT_USED
1663 /* UINT _txe_semaphore_ceiling_put(
1664 TX_SEMAPHORE *semaphore_ptr, -> param_0
1665 ULONG ceiling -> param_1
1666 ); */
_txm_module_manager_tx_semaphore_ceiling_put_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1)1667 static ALIGN_TYPE _txm_module_manager_tx_semaphore_ceiling_put_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1)
1668 {
1669
1670 ALIGN_TYPE return_value;
1671
1672 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
1673 {
1674 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_SEMAPHORE)))
1675 return(TXM_MODULE_INVALID_MEMORY);
1676 }
1677
1678 return_value = (ALIGN_TYPE) _txe_semaphore_ceiling_put(
1679 (TX_SEMAPHORE *) param_0,
1680 (ULONG) param_1
1681 );
1682 return(return_value);
1683 }
1684 #endif
1685
1686 #ifndef TXM_SEMAPHORE_CREATE_CALL_NOT_USED
1687 /* UINT _txe_semaphore_create(
1688 TX_SEMAPHORE *semaphore_ptr, -> param_0
1689 CHAR *name_ptr, -> param_1
1690 ULONG initial_count, -> extra_parameters[0]
1691 UINT semaphore_control_block_size -> extra_parameters[1]
1692 ); */
_txm_module_manager_tx_semaphore_create_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE * extra_parameters)1693 static ALIGN_TYPE _txm_module_manager_tx_semaphore_create_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE *extra_parameters)
1694 {
1695
1696 ALIGN_TYPE return_value;
1697
1698 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
1699 {
1700 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_CREATION(module_instance, param_0, sizeof(TX_SEMAPHORE)))
1701 return(TXM_MODULE_INVALID_MEMORY);
1702
1703 if (!TXM_MODULE_MANAGER_PARAM_CHECK_DEREFERENCE_STRING(module_instance, param_1))
1704 return(TXM_MODULE_INVALID_MEMORY);
1705
1706 if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[2])))
1707 return(TXM_MODULE_INVALID_MEMORY);
1708 }
1709
1710 return_value = (ALIGN_TYPE) _txe_semaphore_create(
1711 (TX_SEMAPHORE *) param_0,
1712 (CHAR *) param_1,
1713 (ULONG) extra_parameters[0],
1714 (UINT) extra_parameters[1]
1715 );
1716 return(return_value);
1717 }
1718 #endif
1719
1720 #ifndef TXM_SEMAPHORE_DELETE_CALL_NOT_USED
1721 /* UINT _txe_semaphore_delete(
1722 TX_SEMAPHORE *semaphore_ptr -> param_0
1723 ); */
_txm_module_manager_tx_semaphore_delete_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0)1724 static ALIGN_TYPE _txm_module_manager_tx_semaphore_delete_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0)
1725 {
1726
1727 ALIGN_TYPE return_value;
1728
1729 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
1730 {
1731 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_SEMAPHORE)))
1732 return(TXM_MODULE_INVALID_MEMORY);
1733 }
1734
1735 return_value = (ALIGN_TYPE) _txe_semaphore_delete(
1736 (TX_SEMAPHORE *) param_0
1737 );
1738
1739 /* Deallocate object memory. */
1740 if (return_value == TX_SUCCESS)
1741 {
1742 return_value = _txm_module_manager_object_deallocate((VOID *) param_0);
1743 }
1744 return(return_value);
1745 }
1746 #endif
1747
1748 #ifndef TXM_SEMAPHORE_GET_CALL_NOT_USED
1749 /* UINT _txe_semaphore_get(
1750 TX_SEMAPHORE *semaphore_ptr, -> param_0
1751 ULONG wait_option -> param_1
1752 ); */
_txm_module_manager_tx_semaphore_get_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1)1753 static ALIGN_TYPE _txm_module_manager_tx_semaphore_get_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1)
1754 {
1755
1756 ALIGN_TYPE return_value;
1757
1758 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
1759 {
1760 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_SEMAPHORE)))
1761 return(TXM_MODULE_INVALID_MEMORY);
1762 }
1763
1764 return_value = (ALIGN_TYPE) _txe_semaphore_get(
1765 (TX_SEMAPHORE *) param_0,
1766 (ULONG) param_1
1767 );
1768 return(return_value);
1769 }
1770 #endif
1771
1772 #ifndef TXM_SEMAPHORE_INFO_GET_CALL_NOT_USED
1773 /* UINT _txe_semaphore_info_get(
1774 TX_SEMAPHORE *semaphore_ptr, -> param_0
1775 CHAR **name, -> param_1
1776 ULONG *current_value, -> extra_parameters[0]
1777 TX_THREAD **first_suspended, -> extra_parameters[1]
1778 ULONG *suspended_count, -> extra_parameters[2]
1779 TX_SEMAPHORE **next_semaphore -> extra_parameters[3]
1780 ); */
_txm_module_manager_tx_semaphore_info_get_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE * extra_parameters)1781 static ALIGN_TYPE _txm_module_manager_tx_semaphore_info_get_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE *extra_parameters)
1782 {
1783
1784 ALIGN_TYPE return_value;
1785
1786 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
1787 {
1788 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_SEMAPHORE)))
1789 return(TXM_MODULE_INVALID_MEMORY);
1790
1791 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(CHAR *)))
1792 return(TXM_MODULE_INVALID_MEMORY);
1793
1794 if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[4])))
1795 return(TXM_MODULE_INVALID_MEMORY);
1796
1797 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], sizeof(ULONG)))
1798 return(TXM_MODULE_INVALID_MEMORY);
1799
1800 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[1], sizeof(TX_THREAD *)))
1801 return(TXM_MODULE_INVALID_MEMORY);
1802
1803 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[2], sizeof(ULONG)))
1804 return(TXM_MODULE_INVALID_MEMORY);
1805
1806 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[3], sizeof(TX_SEMAPHORE *)))
1807 return(TXM_MODULE_INVALID_MEMORY);
1808 }
1809
1810 return_value = (ALIGN_TYPE) _txe_semaphore_info_get(
1811 (TX_SEMAPHORE *) param_0,
1812 (CHAR **) param_1,
1813 (ULONG *) extra_parameters[0],
1814 (TX_THREAD **) extra_parameters[1],
1815 (ULONG *) extra_parameters[2],
1816 (TX_SEMAPHORE **) extra_parameters[3]
1817 );
1818 return(return_value);
1819 }
1820 #endif
1821
1822 #ifndef TXM_SEMAPHORE_PERFORMANCE_INFO_GET_CALL_NOT_USED
1823 /* UINT _tx_semaphore_performance_info_get(
1824 TX_SEMAPHORE *semaphore_ptr, -> param_0
1825 ULONG *puts, -> param_1
1826 ULONG *gets, -> extra_parameters[0]
1827 ULONG *suspensions, -> extra_parameters[1]
1828 ULONG *timeouts -> extra_parameters[2]
1829 ); */
_txm_module_manager_tx_semaphore_performance_info_get_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE * extra_parameters)1830 static ALIGN_TYPE _txm_module_manager_tx_semaphore_performance_info_get_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE *extra_parameters)
1831 {
1832
1833 ALIGN_TYPE return_value;
1834
1835 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
1836 {
1837 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_SEMAPHORE)))
1838 return(TXM_MODULE_INVALID_MEMORY);
1839
1840 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(ULONG)))
1841 return(TXM_MODULE_INVALID_MEMORY);
1842
1843 if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[3])))
1844 return(TXM_MODULE_INVALID_MEMORY);
1845
1846 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], sizeof(ULONG)))
1847 return(TXM_MODULE_INVALID_MEMORY);
1848
1849 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[1], sizeof(ULONG)))
1850 return(TXM_MODULE_INVALID_MEMORY);
1851
1852 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[2], sizeof(ULONG)))
1853 return(TXM_MODULE_INVALID_MEMORY);
1854 }
1855
1856 return_value = (ALIGN_TYPE) _tx_semaphore_performance_info_get(
1857 (TX_SEMAPHORE *) param_0,
1858 (ULONG *) param_1,
1859 (ULONG *) extra_parameters[0],
1860 (ULONG *) extra_parameters[1],
1861 (ULONG *) extra_parameters[2]
1862 );
1863 return(return_value);
1864 }
1865 #endif
1866
1867 #ifndef TXM_SEMAPHORE_PERFORMANCE_SYSTEM_INFO_GET_CALL_NOT_USED
1868 /* UINT _tx_semaphore_performance_system_info_get(
1869 ULONG *puts, -> param_0
1870 ULONG *gets, -> param_1
1871 ULONG *suspensions, -> extra_parameters[0]
1872 ULONG *timeouts -> extra_parameters[1]
1873 ); */
_txm_module_manager_tx_semaphore_performance_system_info_get_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE * extra_parameters)1874 static ALIGN_TYPE _txm_module_manager_tx_semaphore_performance_system_info_get_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE *extra_parameters)
1875 {
1876
1877 ALIGN_TYPE return_value;
1878
1879 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
1880 {
1881 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_0, sizeof(ULONG)))
1882 return(TXM_MODULE_INVALID_MEMORY);
1883
1884 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(ULONG)))
1885 return(TXM_MODULE_INVALID_MEMORY);
1886
1887 if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[2])))
1888 return(TXM_MODULE_INVALID_MEMORY);
1889
1890 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], sizeof(ULONG)))
1891 return(TXM_MODULE_INVALID_MEMORY);
1892
1893 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[1], sizeof(ULONG)))
1894 return(TXM_MODULE_INVALID_MEMORY);
1895 }
1896
1897 return_value = (ALIGN_TYPE) _tx_semaphore_performance_system_info_get(
1898 (ULONG *) param_0,
1899 (ULONG *) param_1,
1900 (ULONG *) extra_parameters[0],
1901 (ULONG *) extra_parameters[1]
1902 );
1903 return(return_value);
1904 }
1905 #endif
1906
1907 #ifndef TXM_SEMAPHORE_PRIORITIZE_CALL_NOT_USED
1908 /* UINT _txe_semaphore_prioritize(
1909 TX_SEMAPHORE *semaphore_ptr -> param_0
1910 ); */
_txm_module_manager_tx_semaphore_prioritize_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0)1911 static ALIGN_TYPE _txm_module_manager_tx_semaphore_prioritize_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0)
1912 {
1913
1914 ALIGN_TYPE return_value;
1915
1916 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
1917 {
1918 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_SEMAPHORE)))
1919 return(TXM_MODULE_INVALID_MEMORY);
1920 }
1921
1922 return_value = (ALIGN_TYPE) _txe_semaphore_prioritize(
1923 (TX_SEMAPHORE *) param_0
1924 );
1925 return(return_value);
1926 }
1927 #endif
1928
1929 #ifndef TXM_SEMAPHORE_PUT_CALL_NOT_USED
1930 /* UINT _txe_semaphore_put(
1931 TX_SEMAPHORE *semaphore_ptr -> param_0
1932 ); */
_txm_module_manager_tx_semaphore_put_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0)1933 static ALIGN_TYPE _txm_module_manager_tx_semaphore_put_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0)
1934 {
1935
1936 ALIGN_TYPE return_value;
1937
1938 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
1939 {
1940 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_SEMAPHORE)))
1941 return(TXM_MODULE_INVALID_MEMORY);
1942 }
1943
1944 return_value = (ALIGN_TYPE) _txe_semaphore_put(
1945 (TX_SEMAPHORE *) param_0
1946 );
1947 return(return_value);
1948 }
1949 #endif
1950
1951 #ifndef TXM_SEMAPHORE_PUT_NOTIFY_CALL_NOT_USED
1952 /* UINT _txe_semaphore_put_notify(
1953 TX_SEMAPHORE *semaphore_ptr, -> param_0
1954 VOID (*semaphore_put_notify)(TX_SEMAPHORE *notify_semaphore_ptr) -> param_1
1955 ); */
_txm_module_manager_tx_semaphore_put_notify_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1)1956 static ALIGN_TYPE _txm_module_manager_tx_semaphore_put_notify_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1)
1957 {
1958
1959 ALIGN_TYPE return_value;
1960 TX_SEMAPHORE *semaphore_ptr = (TX_SEMAPHORE *) param_0;
1961 VOID (*semaphore_put_notify)(TX_SEMAPHORE *);
1962
1963 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
1964 {
1965 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_SEMAPHORE)))
1966 return(TXM_MODULE_INVALID_MEMORY);
1967
1968 /* Since we need to write to the object, ensure it's valid. */
1969 if ((semaphore_ptr == TX_NULL) || (semaphore_ptr -> tx_semaphore_id != TX_SEMAPHORE_ID))
1970 return(TX_SEMAPHORE_ERROR);
1971 }
1972
1973 /* Is it a disable request? */
1974 if ((void *) param_1 == TX_NULL)
1975 {
1976
1977 /* Clear the callback. */
1978 semaphore_put_notify = (VOID (*)(TX_SEMAPHORE *)) TX_NULL;
1979 }
1980 else
1981 {
1982
1983 /* Setup trampoline values. */
1984 semaphore_ptr -> tx_semaphore_module_instance = (VOID *) module_instance;
1985 semaphore_ptr -> tx_semaphore_put_module_notify = (VOID (*)(TX_SEMAPHORE *)) param_1;
1986 semaphore_put_notify = _txm_module_manager_semaphore_notify_trampoline;
1987 }
1988
1989 return_value = (ALIGN_TYPE) _txe_semaphore_put_notify(
1990 (TX_SEMAPHORE *) param_0,
1991 (VOID (*)(TX_SEMAPHORE *notify_semaphore_ptr)) semaphore_put_notify
1992 );
1993 return(return_value);
1994 }
1995 #endif
1996
1997 #ifndef TXM_THREAD_CREATE_CALL_NOT_USED
1998 /* UINT _txe_thread_create(
1999 TX_THREAD *thread_ptr, -> param_0
2000 CHAR *name_ptr, -> param_1
2001 VOID (*entry_function)(ULONG entry_input), -> extra_parameters[0]
2002 ULONG entry_input, -> extra_parameters[1]
2003 VOID *stack_start, -> extra_parameters[2]
2004 ULONG stack_size, -> extra_parameters[3]
2005 UINT priority, -> extra_parameters[4]
2006 UINT preempt_threshold, -> extra_parameters[5]
2007 ULONG time_slice, -> extra_parameters[6]
2008 UINT auto_start, -> extra_parameters[7]
2009 UINT thread_control_block_size -> extra_parameters[8]
2010 ); */
_txm_module_manager_tx_thread_create_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE * extra_parameters)2011 static ALIGN_TYPE _txm_module_manager_tx_thread_create_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE *extra_parameters)
2012 {
2013
2014 ALIGN_TYPE return_value;
2015
2016 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
2017 {
2018 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_CREATION(module_instance, param_0, sizeof(TX_THREAD)))
2019 return(TXM_MODULE_INVALID_MEMORY);
2020
2021 if (!TXM_MODULE_MANAGER_PARAM_CHECK_DEREFERENCE_STRING(module_instance, param_1))
2022 return(TXM_MODULE_INVALID_MEMORY);
2023
2024 if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[9])))
2025 return(TXM_MODULE_INVALID_MEMORY);
2026
2027 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[2], extra_parameters[3]))
2028 return(TXM_MODULE_INVALID_MEMORY);
2029
2030 if (extra_parameters[4] < module_instance -> txm_module_instance_maximum_priority)
2031 return(TX_PRIORITY_ERROR);
2032
2033 if (extra_parameters[5] < module_instance -> txm_module_instance_maximum_priority)
2034 return(TX_THRESH_ERROR);
2035 }
2036
2037 return_value = (ALIGN_TYPE) _txm_module_manager_thread_create(
2038 (TX_THREAD *) param_0,
2039 (CHAR *) param_1,
2040 module_instance -> txm_module_instance_shell_entry_function,
2041 (VOID (*)(ULONG entry_input)) extra_parameters[0],
2042 (ULONG) extra_parameters[1],
2043 (VOID *) extra_parameters[2],
2044 (ULONG) extra_parameters[3],
2045 (UINT) extra_parameters[4],
2046 (UINT) extra_parameters[5],
2047 (ULONG) extra_parameters[6],
2048 (UINT) extra_parameters[7],
2049 (UINT) extra_parameters[8],
2050 module_instance
2051 );
2052 return(return_value);
2053 }
2054 #endif
2055
2056 #ifndef TXM_THREAD_DELETE_CALL_NOT_USED
2057 /* UINT _txe_thread_delete(
2058 TX_THREAD *thread_ptr -> param_0
2059 ); */
_txm_module_manager_tx_thread_delete_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0)2060 static ALIGN_TYPE _txm_module_manager_tx_thread_delete_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0)
2061 {
2062
2063 ALIGN_TYPE return_value;
2064
2065 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
2066 {
2067 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_THREAD)))
2068 return(TXM_MODULE_INVALID_MEMORY);
2069 }
2070
2071 return_value = (ALIGN_TYPE) _txe_thread_delete(
2072 (TX_THREAD *) param_0
2073 );
2074
2075 /* Deallocate object memory. */
2076 if (return_value == TX_SUCCESS)
2077 {
2078 return_value = _txm_module_manager_object_deallocate((VOID *) param_0);
2079 }
2080 return(return_value);
2081 }
2082 #endif
2083
2084 #ifndef TXM_THREAD_ENTRY_EXIT_NOTIFY_CALL_NOT_USED
2085 /* UINT _txe_thread_entry_exit_notify(
2086 TX_THREAD *thread_ptr, -> param_0
2087 VOID (*thread_entry_exit_notify)(TX_THREAD *notify_thread_ptr, UINT type) -> param_1
2088 ); */
_txm_module_manager_tx_thread_entry_exit_notify_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1)2089 static ALIGN_TYPE _txm_module_manager_tx_thread_entry_exit_notify_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1)
2090 {
2091
2092 ALIGN_TYPE return_value;
2093 TX_THREAD *thread_ptr = (TX_THREAD *) param_0;
2094 TXM_MODULE_THREAD_ENTRY_INFO *thread_entry_info_ptr;
2095 VOID (*thread_entry_exit_notify)(TX_THREAD *, UINT);
2096
2097 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
2098 {
2099 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_THREAD)))
2100 return(TXM_MODULE_INVALID_MEMORY);
2101
2102 /* Since we need to write to the object, ensure it's valid. */
2103 if ((thread_ptr == TX_NULL) || (thread_ptr -> tx_thread_id != TX_THREAD_ID))
2104 return(TX_THREAD_ERROR);
2105
2106 /* Ensure this thread is from the module trying to set the callback. */
2107 if (thread_ptr -> tx_thread_module_instance_ptr != module_instance)
2108 return(TXM_MODULE_INVALID);
2109 }
2110
2111 /* Is it a disable request? */
2112 if ((void *) param_1 == TX_NULL)
2113 {
2114
2115 /* Clear the callback. */
2116 thread_entry_exit_notify = (VOID (*)(TX_THREAD *, UINT)) TX_NULL;
2117 }
2118 else
2119 {
2120
2121 /* Setup trampoline values. */
2122 thread_entry_info_ptr = (TXM_MODULE_THREAD_ENTRY_INFO *) thread_ptr -> tx_thread_module_entry_info_ptr;
2123 thread_entry_info_ptr -> txm_module_thread_entry_info_exit_notify = (VOID (*)(TX_THREAD *, UINT)) param_1;
2124 thread_entry_exit_notify = _txm_module_manager_thread_notify_trampoline;
2125 }
2126
2127 return_value = (ALIGN_TYPE) _txe_thread_entry_exit_notify(
2128 (TX_THREAD *) param_0,
2129 (VOID (*)(TX_THREAD *notify_thread_ptr, UINT type)) thread_entry_exit_notify
2130 );
2131 return(return_value);
2132 }
2133 #endif
2134
2135 #ifndef TXM_THREAD_IDENTIFY_CALL_NOT_USED
2136 /* TX_THREAD *_tx_thread_identify(); */
_txm_module_manager_tx_thread_identify_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE * extra_parameters)2137 static ALIGN_TYPE _txm_module_manager_tx_thread_identify_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE *extra_parameters)
2138 {
2139
2140 ALIGN_TYPE return_value;
2141
2142 return_value = (ALIGN_TYPE) _tx_thread_identify();
2143 return(return_value);
2144 }
2145 #endif
2146
2147 #ifndef TXM_THREAD_INFO_GET_CALL_NOT_USED
2148 /* UINT _txe_thread_info_get(
2149 TX_THREAD *thread_ptr, -> param_0
2150 CHAR **name, -> param_1
2151 UINT *state, -> extra_parameters[0]
2152 ULONG *run_count, -> extra_parameters[1]
2153 UINT *priority, -> extra_parameters[2]
2154 UINT *preemption_threshold, -> extra_parameters[3]
2155 ULONG *time_slice, -> extra_parameters[4]
2156 TX_THREAD **next_thread, -> extra_parameters[5]
2157 TX_THREAD **next_suspended_thread -> extra_parameters[6]
2158 ); */
_txm_module_manager_tx_thread_info_get_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE * extra_parameters)2159 static ALIGN_TYPE _txm_module_manager_tx_thread_info_get_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE *extra_parameters)
2160 {
2161
2162 ALIGN_TYPE return_value;
2163
2164 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
2165 {
2166 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_THREAD)))
2167 return(TXM_MODULE_INVALID_MEMORY);
2168
2169 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(CHAR *)))
2170 return(TXM_MODULE_INVALID_MEMORY);
2171
2172 if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[7])))
2173 return(TXM_MODULE_INVALID_MEMORY);
2174
2175 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], sizeof(UINT)))
2176 return(TXM_MODULE_INVALID_MEMORY);
2177
2178 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[1], sizeof(ULONG)))
2179 return(TXM_MODULE_INVALID_MEMORY);
2180
2181 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[2], sizeof(UINT)))
2182 return(TXM_MODULE_INVALID_MEMORY);
2183
2184 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[3], sizeof(UINT)))
2185 return(TXM_MODULE_INVALID_MEMORY);
2186
2187 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[4], sizeof(ULONG)))
2188 return(TXM_MODULE_INVALID_MEMORY);
2189
2190 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[5], sizeof(TX_THREAD *)))
2191 return(TXM_MODULE_INVALID_MEMORY);
2192
2193 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[6], sizeof(TX_THREAD *)))
2194 return(TXM_MODULE_INVALID_MEMORY);
2195 }
2196
2197 return_value = (ALIGN_TYPE) _txe_thread_info_get(
2198 (TX_THREAD *) param_0,
2199 (CHAR **) param_1,
2200 (UINT *) extra_parameters[0],
2201 (ULONG *) extra_parameters[1],
2202 (UINT *) extra_parameters[2],
2203 (UINT *) extra_parameters[3],
2204 (ULONG *) extra_parameters[4],
2205 (TX_THREAD **) extra_parameters[5],
2206 (TX_THREAD **) extra_parameters[6]
2207 );
2208 return(return_value);
2209 }
2210 #endif
2211
2212 #ifndef TXM_THREAD_INTERRUPT_CONTROL_CALL_NOT_USED
2213 /* UINT _tx_thread_interrupt_control(
2214 UINT new_posture -> param_0
2215 ); */
_txm_module_manager_tx_thread_interrupt_control_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0)2216 static ALIGN_TYPE _txm_module_manager_tx_thread_interrupt_control_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0)
2217 {
2218
2219 ALIGN_TYPE return_value;
2220
2221 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_USER_MODE)
2222 return(TXM_MODULE_INVALID_PROPERTIES);
2223
2224 return_value = (ALIGN_TYPE) _tx_thread_interrupt_control(
2225 (UINT) param_0
2226 );
2227 return(return_value);
2228 }
2229 #endif
2230
2231 #ifndef TXM_THREAD_PERFORMANCE_INFO_GET_CALL_NOT_USED
2232 /* UINT _tx_thread_performance_info_get(
2233 TX_THREAD *thread_ptr, -> param_0
2234 ULONG *resumptions, -> param_1
2235 ULONG *suspensions, -> extra_parameters[0]
2236 ULONG *solicited_preemptions, -> extra_parameters[1]
2237 ULONG *interrupt_preemptions, -> extra_parameters[2]
2238 ULONG *priority_inversions, -> extra_parameters[3]
2239 ULONG *time_slices, -> extra_parameters[4]
2240 ULONG *relinquishes, -> extra_parameters[5]
2241 ULONG *timeouts, -> extra_parameters[6]
2242 ULONG *wait_aborts, -> extra_parameters[7]
2243 TX_THREAD **last_preempted_by -> extra_parameters[8]
2244 ); */
_txm_module_manager_tx_thread_performance_info_get_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE * extra_parameters)2245 static ALIGN_TYPE _txm_module_manager_tx_thread_performance_info_get_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE *extra_parameters)
2246 {
2247
2248 ALIGN_TYPE return_value;
2249
2250 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
2251 {
2252 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_THREAD)))
2253 return(TXM_MODULE_INVALID_MEMORY);
2254
2255 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(ULONG)))
2256 return(TXM_MODULE_INVALID_MEMORY);
2257
2258 if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[9])))
2259 return(TXM_MODULE_INVALID_MEMORY);
2260
2261 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], sizeof(ULONG)))
2262 return(TXM_MODULE_INVALID_MEMORY);
2263
2264 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[1], sizeof(ULONG)))
2265 return(TXM_MODULE_INVALID_MEMORY);
2266
2267 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[2], sizeof(ULONG)))
2268 return(TXM_MODULE_INVALID_MEMORY);
2269
2270 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[3], sizeof(ULONG)))
2271 return(TXM_MODULE_INVALID_MEMORY);
2272
2273 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[4], sizeof(ULONG)))
2274 return(TXM_MODULE_INVALID_MEMORY);
2275
2276 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[5], sizeof(ULONG)))
2277 return(TXM_MODULE_INVALID_MEMORY);
2278
2279 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[6], sizeof(ULONG)))
2280 return(TXM_MODULE_INVALID_MEMORY);
2281
2282 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[7], sizeof(ULONG)))
2283 return(TXM_MODULE_INVALID_MEMORY);
2284
2285 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[8], sizeof(TX_THREAD *)))
2286 return(TXM_MODULE_INVALID_MEMORY);
2287 }
2288
2289 return_value = (ALIGN_TYPE) _tx_thread_performance_info_get(
2290 (TX_THREAD *) param_0,
2291 (ULONG *) param_1,
2292 (ULONG *) extra_parameters[0],
2293 (ULONG *) extra_parameters[1],
2294 (ULONG *) extra_parameters[2],
2295 (ULONG *) extra_parameters[3],
2296 (ULONG *) extra_parameters[4],
2297 (ULONG *) extra_parameters[5],
2298 (ULONG *) extra_parameters[6],
2299 (ULONG *) extra_parameters[7],
2300 (TX_THREAD **) extra_parameters[8]
2301 );
2302 return(return_value);
2303 }
2304 #endif
2305
2306 #ifndef TXM_THREAD_PERFORMANCE_SYSTEM_INFO_GET_CALL_NOT_USED
2307 /* UINT _tx_thread_performance_system_info_get(
2308 ULONG *resumptions, -> param_0
2309 ULONG *suspensions, -> param_1
2310 ULONG *solicited_preemptions, -> extra_parameters[0]
2311 ULONG *interrupt_preemptions, -> extra_parameters[1]
2312 ULONG *priority_inversions, -> extra_parameters[2]
2313 ULONG *time_slices, -> extra_parameters[3]
2314 ULONG *relinquishes, -> extra_parameters[4]
2315 ULONG *timeouts, -> extra_parameters[5]
2316 ULONG *wait_aborts, -> extra_parameters[6]
2317 ULONG *non_idle_returns, -> extra_parameters[7]
2318 ULONG *idle_returns -> extra_parameters[8]
2319 ); */
_txm_module_manager_tx_thread_performance_system_info_get_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE * extra_parameters)2320 static ALIGN_TYPE _txm_module_manager_tx_thread_performance_system_info_get_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE *extra_parameters)
2321 {
2322
2323 ALIGN_TYPE return_value;
2324
2325 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
2326 {
2327 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_0, sizeof(ULONG)))
2328 return(TXM_MODULE_INVALID_MEMORY);
2329
2330 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(ULONG)))
2331 return(TXM_MODULE_INVALID_MEMORY);
2332
2333 if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[9])))
2334 return(TXM_MODULE_INVALID_MEMORY);
2335
2336 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], sizeof(ULONG)))
2337 return(TXM_MODULE_INVALID_MEMORY);
2338
2339 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[1], sizeof(ULONG)))
2340 return(TXM_MODULE_INVALID_MEMORY);
2341
2342 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[2], sizeof(ULONG)))
2343 return(TXM_MODULE_INVALID_MEMORY);
2344
2345 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[3], sizeof(ULONG)))
2346 return(TXM_MODULE_INVALID_MEMORY);
2347
2348 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[4], sizeof(ULONG)))
2349 return(TXM_MODULE_INVALID_MEMORY);
2350
2351 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[5], sizeof(ULONG)))
2352 return(TXM_MODULE_INVALID_MEMORY);
2353
2354 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[6], sizeof(ULONG)))
2355 return(TXM_MODULE_INVALID_MEMORY);
2356
2357 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[7], sizeof(ULONG)))
2358 return(TXM_MODULE_INVALID_MEMORY);
2359
2360 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[8], sizeof(ULONG)))
2361 return(TXM_MODULE_INVALID_MEMORY);
2362 }
2363
2364 return_value = (ALIGN_TYPE) _tx_thread_performance_system_info_get(
2365 (ULONG *) param_0,
2366 (ULONG *) param_1,
2367 (ULONG *) extra_parameters[0],
2368 (ULONG *) extra_parameters[1],
2369 (ULONG *) extra_parameters[2],
2370 (ULONG *) extra_parameters[3],
2371 (ULONG *) extra_parameters[4],
2372 (ULONG *) extra_parameters[5],
2373 (ULONG *) extra_parameters[6],
2374 (ULONG *) extra_parameters[7],
2375 (ULONG *) extra_parameters[8]
2376 );
2377 return(return_value);
2378 }
2379 #endif
2380
2381 #ifndef TXM_THREAD_PREEMPTION_CHANGE_CALL_NOT_USED
2382 /* UINT _txe_thread_preemption_change(
2383 TX_THREAD *thread_ptr, -> param_0
2384 UINT new_threshold, -> param_1
2385 UINT *old_threshold -> param_2
2386 ); */
_txm_module_manager_tx_thread_preemption_change_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE param_2)2387 static ALIGN_TYPE _txm_module_manager_tx_thread_preemption_change_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE param_2)
2388 {
2389
2390 ALIGN_TYPE return_value;
2391
2392 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
2393 {
2394 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_THREAD)))
2395 return(TXM_MODULE_INVALID_MEMORY);
2396
2397 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_2, sizeof(UINT)))
2398 return(TXM_MODULE_INVALID_MEMORY);
2399 }
2400
2401 return_value = (ALIGN_TYPE) _txe_thread_preemption_change(
2402 (TX_THREAD *) param_0,
2403 (UINT) param_1,
2404 (UINT *) param_2
2405 );
2406 return(return_value);
2407 }
2408 #endif
2409
2410 #ifndef TXM_THREAD_PRIORITY_CHANGE_CALL_NOT_USED
2411 /* UINT _txe_thread_priority_change(
2412 TX_THREAD *thread_ptr, -> param_0
2413 UINT new_priority, -> param_1
2414 UINT *old_priority -> param_2
2415 ); */
_txm_module_manager_tx_thread_priority_change_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE param_2)2416 static ALIGN_TYPE _txm_module_manager_tx_thread_priority_change_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE param_2)
2417 {
2418
2419 ALIGN_TYPE return_value;
2420
2421 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
2422 {
2423 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_THREAD)))
2424 return(TXM_MODULE_INVALID_MEMORY);
2425
2426 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_2, sizeof(UINT)))
2427 return(TXM_MODULE_INVALID_MEMORY);
2428 }
2429
2430 return_value = (ALIGN_TYPE) _txe_thread_priority_change(
2431 (TX_THREAD *) param_0,
2432 (UINT) param_1,
2433 (UINT *) param_2
2434 );
2435 return(return_value);
2436 }
2437 #endif
2438
2439 #ifndef TXM_THREAD_RELINQUISH_CALL_NOT_USED
2440 /* VOID _txe_thread_relinquish(); */
_txm_module_manager_tx_thread_relinquish_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE * extra_parameters)2441 static ALIGN_TYPE _txm_module_manager_tx_thread_relinquish_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE *extra_parameters)
2442 {
2443
2444 _txe_thread_relinquish();
2445 return(TX_SUCCESS);
2446 }
2447 #endif
2448
2449 #ifndef TXM_THREAD_RESET_CALL_NOT_USED
2450 /* UINT _txe_thread_reset(
2451 TX_THREAD *thread_ptr -> param_0
2452 ); */
_txm_module_manager_tx_thread_reset_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0)2453 static ALIGN_TYPE _txm_module_manager_tx_thread_reset_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0)
2454 {
2455
2456 ALIGN_TYPE return_value;
2457
2458 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
2459 {
2460 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_THREAD)))
2461 return(TXM_MODULE_INVALID_MEMORY);
2462 }
2463
2464 return_value = (ALIGN_TYPE) _txm_module_manager_thread_reset(
2465 (TX_THREAD *) param_0
2466 );
2467 return(return_value);
2468 }
2469 #endif
2470
2471 #ifndef TXM_THREAD_RESUME_CALL_NOT_USED
2472 /* UINT _txe_thread_resume(
2473 TX_THREAD *thread_ptr -> param_0
2474 ); */
_txm_module_manager_tx_thread_resume_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0)2475 static ALIGN_TYPE _txm_module_manager_tx_thread_resume_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0)
2476 {
2477
2478 ALIGN_TYPE return_value;
2479
2480 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
2481 {
2482 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_THREAD)))
2483 return(TXM_MODULE_INVALID_MEMORY);
2484 }
2485
2486 return_value = (ALIGN_TYPE) _txe_thread_resume(
2487 (TX_THREAD *) param_0
2488 );
2489 return(return_value);
2490 }
2491 #endif
2492
2493 #ifndef TXM_THREAD_SLEEP_CALL_NOT_USED
2494 /* UINT _tx_thread_sleep(
2495 ULONG timer_ticks -> param_0
2496 ); */
_txm_module_manager_tx_thread_sleep_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0)2497 static ALIGN_TYPE _txm_module_manager_tx_thread_sleep_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0)
2498 {
2499
2500 ALIGN_TYPE return_value;
2501
2502 return_value = (ALIGN_TYPE) _tx_thread_sleep(
2503 (ULONG) param_0
2504 );
2505 return(return_value);
2506 }
2507 #endif
2508
2509 #ifndef TXM_THREAD_STACK_ERROR_NOTIFY_CALL_NOT_USED
2510 /* UINT _tx_thread_stack_error_notify(
2511 VOID (*stack_error_handler)(TX_THREAD *thread_ptr) -> param_0
2512 ); */
_txm_module_manager_tx_thread_stack_error_notify_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0)2513 static ALIGN_TYPE _txm_module_manager_tx_thread_stack_error_notify_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0)
2514 {
2515
2516 ALIGN_TYPE return_value;
2517
2518 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_USER_MODE)
2519 return(TXM_MODULE_INVALID_PROPERTIES);
2520
2521 return_value = (ALIGN_TYPE) _tx_thread_stack_error_notify(
2522 (VOID (*)(TX_THREAD *thread_ptr)) param_0
2523 );
2524 return(return_value);
2525 }
2526 #endif
2527
2528 #ifndef TXM_THREAD_SUSPEND_CALL_NOT_USED
2529 /* UINT _txe_thread_suspend(
2530 TX_THREAD *thread_ptr -> param_0
2531 ); */
_txm_module_manager_tx_thread_suspend_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0)2532 static ALIGN_TYPE _txm_module_manager_tx_thread_suspend_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0)
2533 {
2534
2535 ALIGN_TYPE return_value;
2536
2537 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
2538 {
2539 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_THREAD)))
2540 return(TXM_MODULE_INVALID_MEMORY);
2541 }
2542
2543 return_value = (ALIGN_TYPE) _txe_thread_suspend(
2544 (TX_THREAD *) param_0
2545 );
2546 return(return_value);
2547 }
2548 #endif
2549
2550 #ifndef TXM_THREAD_SYSTEM_SUSPEND_CALL_NOT_USED
2551 /* VOID _tx_thread_system_suspend(
2552 TX_THREAD *thread_ptr -> param_0
2553 ); */
_txm_module_manager_tx_thread_system_suspend_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0)2554 static ALIGN_TYPE _txm_module_manager_tx_thread_system_suspend_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0)
2555 {
2556
2557 TX_INTERRUPT_SAVE_AREA
2558
2559 TX_THREAD *thread_ptr;
2560
2561 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
2562 {
2563 /* Ensure the thread is suspending itself. */
2564 if (((TX_THREAD *) param_0) != _tx_thread_current_ptr)
2565 {
2566 return(TXM_MODULE_INVALID_MEMORY);
2567 }
2568 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_THREAD)))
2569 return(TXM_MODULE_INVALID_MEMORY);
2570 }
2571
2572 /* Get the thread pointer. */
2573 thread_ptr = (TX_THREAD *) param_0;
2574
2575 /* Disable interrupts temporarily. */
2576 TX_DISABLE
2577
2578 /* Set the status to suspending, in order to indicate the suspension
2579 is in progress. */
2580 thread_ptr -> tx_thread_state = TX_COMPLETED;
2581
2582 /* Thread state change. */
2583 TX_THREAD_STATE_CHANGE(thread_ptr, TX_COMPLETED)
2584
2585 /* Set the suspending flag. */
2586 thread_ptr -> tx_thread_suspending = TX_TRUE;
2587
2588 /* Setup for no timeout period. */
2589 thread_ptr -> tx_thread_timer.tx_timer_internal_remaining_ticks = 0;
2590
2591 /* Temporarily disable preemption. */
2592 _tx_thread_preempt_disable++;
2593
2594 /* Restore interrupts. */
2595 TX_RESTORE
2596
2597 /* Perform any additional activities for tool or user purpose. */
2598 TX_THREAD_COMPLETED_EXTENSION(thread_ptr);
2599
2600 _tx_thread_system_suspend(
2601 (TX_THREAD *) param_0
2602 );
2603 return(TX_SUCCESS);
2604 }
2605 #endif
2606
2607 #ifndef TXM_THREAD_TERMINATE_CALL_NOT_USED
2608 /* UINT _txe_thread_terminate(
2609 TX_THREAD *thread_ptr -> param_0
2610 ); */
_txm_module_manager_tx_thread_terminate_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0)2611 static ALIGN_TYPE _txm_module_manager_tx_thread_terminate_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0)
2612 {
2613
2614 ALIGN_TYPE return_value;
2615
2616 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
2617 {
2618 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_THREAD)))
2619 return(TXM_MODULE_INVALID_MEMORY);
2620 }
2621
2622 return_value = (ALIGN_TYPE) _txe_thread_terminate(
2623 (TX_THREAD *) param_0
2624 );
2625 return(return_value);
2626 }
2627 #endif
2628
2629 #ifndef TXM_THREAD_TIME_SLICE_CHANGE_CALL_NOT_USED
2630 /* UINT _txe_thread_time_slice_change(
2631 TX_THREAD *thread_ptr, -> param_0
2632 ULONG new_time_slice, -> param_1
2633 ULONG *old_time_slice -> param_2
2634 ); */
_txm_module_manager_tx_thread_time_slice_change_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE param_2)2635 static ALIGN_TYPE _txm_module_manager_tx_thread_time_slice_change_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE param_2)
2636 {
2637
2638 ALIGN_TYPE return_value;
2639
2640 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
2641 {
2642 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_THREAD)))
2643 return(TXM_MODULE_INVALID_MEMORY);
2644
2645 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_2, sizeof(ULONG)))
2646 return(TXM_MODULE_INVALID_MEMORY);
2647 }
2648
2649 return_value = (ALIGN_TYPE) _txe_thread_time_slice_change(
2650 (TX_THREAD *) param_0,
2651 (ULONG) param_1,
2652 (ULONG *) param_2
2653 );
2654 return(return_value);
2655 }
2656 #endif
2657
2658 #ifndef TXM_THREAD_WAIT_ABORT_CALL_NOT_USED
2659 /* UINT _txe_thread_wait_abort(
2660 TX_THREAD *thread_ptr -> param_0
2661 ); */
_txm_module_manager_tx_thread_wait_abort_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0)2662 static ALIGN_TYPE _txm_module_manager_tx_thread_wait_abort_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0)
2663 {
2664
2665 ALIGN_TYPE return_value;
2666
2667 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
2668 {
2669 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_THREAD)))
2670 return(TXM_MODULE_INVALID_MEMORY);
2671 }
2672
2673 return_value = (ALIGN_TYPE) _txe_thread_wait_abort(
2674 (TX_THREAD *) param_0
2675 );
2676 return(return_value);
2677 }
2678 #endif
2679
2680 #ifndef TXM_TIME_GET_CALL_NOT_USED
2681 /* ULONG _tx_time_get(); */
_txm_module_manager_tx_time_get_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE * extra_parameters)2682 static ALIGN_TYPE _txm_module_manager_tx_time_get_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE *extra_parameters)
2683 {
2684
2685 ALIGN_TYPE return_value;
2686
2687 return_value = (ALIGN_TYPE) _tx_time_get();
2688 return(return_value);
2689 }
2690 #endif
2691
2692 #ifndef TXM_TIME_SET_CALL_NOT_USED
2693 /* VOID _tx_time_set(
2694 ULONG new_time -> param_0
2695 ); */
_txm_module_manager_tx_time_set_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0)2696 static ALIGN_TYPE _txm_module_manager_tx_time_set_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0)
2697 {
2698
2699 _tx_time_set(
2700 (ULONG) param_0
2701 );
2702 return(TX_SUCCESS);
2703 }
2704 #endif
2705
2706 #ifndef TXM_TIMER_ACTIVATE_CALL_NOT_USED
2707 /* UINT _txe_timer_activate(
2708 TX_TIMER *timer_ptr -> param_0
2709 ); */
_txm_module_manager_tx_timer_activate_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0)2710 static ALIGN_TYPE _txm_module_manager_tx_timer_activate_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0)
2711 {
2712
2713 ALIGN_TYPE return_value;
2714
2715 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
2716 {
2717 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_TIMER)))
2718 return(TXM_MODULE_INVALID_MEMORY);
2719 }
2720
2721 return_value = (ALIGN_TYPE) _txe_timer_activate(
2722 (TX_TIMER *) param_0
2723 );
2724 return(return_value);
2725 }
2726 #endif
2727
2728 #ifndef TXM_TIMER_CHANGE_CALL_NOT_USED
2729 /* UINT _txe_timer_change(
2730 TX_TIMER *timer_ptr, -> param_0
2731 ULONG initial_ticks, -> param_1
2732 ULONG reschedule_ticks -> param_2
2733 ); */
_txm_module_manager_tx_timer_change_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE param_2)2734 static ALIGN_TYPE _txm_module_manager_tx_timer_change_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE param_2)
2735 {
2736
2737 ALIGN_TYPE return_value;
2738
2739 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
2740 {
2741 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_TIMER)))
2742 return(TXM_MODULE_INVALID_MEMORY);
2743 }
2744
2745 return_value = (ALIGN_TYPE) _txe_timer_change(
2746 (TX_TIMER *) param_0,
2747 (ULONG) param_1,
2748 (ULONG) param_2
2749 );
2750 return(return_value);
2751 }
2752 #endif
2753
2754 #ifndef TXM_TIMER_CREATE_CALL_NOT_USED
2755 /* UINT _txe_timer_create(
2756 TX_TIMER *timer_ptr, -> param_0
2757 CHAR *name_ptr, -> param_1
2758 VOID (*expiration_function)(ULONG), -> extra_parameters[0]
2759 ULONG expiration_input, -> extra_parameters[1]
2760 ULONG initial_ticks, -> extra_parameters[2]
2761 ULONG reschedule_ticks, -> extra_parameters[3]
2762 UINT auto_activate, -> extra_parameters[4]
2763 UINT timer_control_block_size -> extra_parameters[5]
2764 ); */
_txm_module_manager_tx_timer_create_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE * extra_parameters)2765 static ALIGN_TYPE _txm_module_manager_tx_timer_create_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE *extra_parameters)
2766 {
2767
2768 ALIGN_TYPE return_value;
2769 TX_TIMER *timer_ptr;
2770 VOID (*expiration_function)(ULONG);
2771
2772 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
2773 {
2774 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_CREATION(module_instance, param_0, sizeof(TX_TIMER)))
2775 return(TXM_MODULE_INVALID_MEMORY);
2776
2777 if (!TXM_MODULE_MANAGER_PARAM_CHECK_DEREFERENCE_STRING(module_instance, param_1))
2778 return(TXM_MODULE_INVALID_MEMORY);
2779
2780 if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[6])))
2781 return(TXM_MODULE_INVALID_MEMORY);
2782 }
2783
2784 /* Is it a disable request? */
2785 if ((void *) extra_parameters[0] == TX_NULL)
2786 {
2787
2788 /* Clear the callback. */
2789 expiration_function = (VOID (*)(ULONG)) TX_NULL;
2790 }
2791 else
2792 {
2793
2794 /* Set trampoline callback. */
2795 expiration_function = _txm_module_manager_timer_notify_trampoline;
2796 }
2797
2798 return_value = (ALIGN_TYPE) _txe_timer_create(
2799 (TX_TIMER *) param_0,
2800 (CHAR *) param_1,
2801 (VOID (*)(ULONG)) expiration_function,
2802 (ULONG) extra_parameters[1],
2803 (ULONG) extra_parameters[2],
2804 (ULONG) extra_parameters[3],
2805 (UINT) extra_parameters[4],
2806 (UINT) extra_parameters[5]
2807 );
2808
2809 if (return_value == TX_SUCCESS)
2810 {
2811
2812 /* Get the object pointer. */
2813 timer_ptr = (TX_TIMER *) param_0;
2814
2815 /* Setup trampoline values. */
2816 if ((void *) extra_parameters[0] != TX_NULL)
2817 {
2818
2819 timer_ptr -> tx_timer_module_instance = (VOID *) module_instance;
2820 timer_ptr -> tx_timer_module_expiration_function = (VOID (*)(ULONG)) extra_parameters[0];
2821 }
2822 }
2823 return(return_value);
2824 }
2825 #endif
2826
2827 #ifndef TXM_TIMER_DEACTIVATE_CALL_NOT_USED
2828 /* UINT _txe_timer_deactivate(
2829 TX_TIMER *timer_ptr -> param_0
2830 ); */
_txm_module_manager_tx_timer_deactivate_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0)2831 static ALIGN_TYPE _txm_module_manager_tx_timer_deactivate_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0)
2832 {
2833
2834 ALIGN_TYPE return_value;
2835
2836 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
2837 {
2838 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_TIMER)))
2839 return(TXM_MODULE_INVALID_MEMORY);
2840 }
2841
2842 return_value = (ALIGN_TYPE) _txe_timer_deactivate(
2843 (TX_TIMER *) param_0
2844 );
2845 return(return_value);
2846 }
2847 #endif
2848
2849 #ifndef TXM_TIMER_DELETE_CALL_NOT_USED
2850 /* UINT _txe_timer_delete(
2851 TX_TIMER *timer_ptr -> param_0
2852 ); */
_txm_module_manager_tx_timer_delete_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0)2853 static ALIGN_TYPE _txm_module_manager_tx_timer_delete_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0)
2854 {
2855
2856 ALIGN_TYPE return_value;
2857
2858 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
2859 {
2860 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_TIMER)))
2861 return(TXM_MODULE_INVALID_MEMORY);
2862 }
2863
2864 return_value = (ALIGN_TYPE) _txe_timer_delete(
2865 (TX_TIMER *) param_0
2866 );
2867
2868 /* Deallocate object memory. */
2869 if (return_value == TX_SUCCESS)
2870 {
2871 return_value = _txm_module_manager_object_deallocate((VOID *) param_0);
2872 }
2873 return(return_value);
2874 }
2875 #endif
2876
2877 #ifndef TXM_TIMER_INFO_GET_CALL_NOT_USED
2878 /* UINT _txe_timer_info_get(
2879 TX_TIMER *timer_ptr, -> param_0
2880 CHAR **name, -> param_1
2881 UINT *active, -> extra_parameters[0]
2882 ULONG *remaining_ticks, -> extra_parameters[1]
2883 ULONG *reschedule_ticks, -> extra_parameters[2]
2884 TX_TIMER **next_timer -> extra_parameters[3]
2885 ); */
_txm_module_manager_tx_timer_info_get_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE * extra_parameters)2886 static ALIGN_TYPE _txm_module_manager_tx_timer_info_get_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE *extra_parameters)
2887 {
2888
2889 ALIGN_TYPE return_value;
2890
2891 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
2892 {
2893 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_TIMER)))
2894 return(TXM_MODULE_INVALID_MEMORY);
2895
2896 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(CHAR *)))
2897 return(TXM_MODULE_INVALID_MEMORY);
2898
2899 if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[4])))
2900 return(TXM_MODULE_INVALID_MEMORY);
2901
2902 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], sizeof(UINT)))
2903 return(TXM_MODULE_INVALID_MEMORY);
2904
2905 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[1], sizeof(ULONG)))
2906 return(TXM_MODULE_INVALID_MEMORY);
2907
2908 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[2], sizeof(ULONG)))
2909 return(TXM_MODULE_INVALID_MEMORY);
2910
2911 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[3], sizeof(TX_TIMER *)))
2912 return(TXM_MODULE_INVALID_MEMORY);
2913 }
2914
2915 return_value = (ALIGN_TYPE) _txe_timer_info_get(
2916 (TX_TIMER *) param_0,
2917 (CHAR **) param_1,
2918 (UINT *) extra_parameters[0],
2919 (ULONG *) extra_parameters[1],
2920 (ULONG *) extra_parameters[2],
2921 (TX_TIMER **) extra_parameters[3]
2922 );
2923 return(return_value);
2924 }
2925 #endif
2926
2927 #ifndef TXM_TIMER_PERFORMANCE_INFO_GET_CALL_NOT_USED
2928 /* UINT _tx_timer_performance_info_get(
2929 TX_TIMER *timer_ptr, -> param_0
2930 ULONG *activates, -> param_1
2931 ULONG *reactivates, -> extra_parameters[0]
2932 ULONG *deactivates, -> extra_parameters[1]
2933 ULONG *expirations, -> extra_parameters[2]
2934 ULONG *expiration_adjusts -> extra_parameters[3]
2935 ); */
_txm_module_manager_tx_timer_performance_info_get_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE * extra_parameters)2936 static ALIGN_TYPE _txm_module_manager_tx_timer_performance_info_get_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE *extra_parameters)
2937 {
2938
2939 ALIGN_TYPE return_value;
2940
2941 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
2942 {
2943 if (!TXM_MODULE_MANAGER_PARAM_CHECK_OBJECT_FOR_USE(module_instance, param_0, sizeof(TX_TIMER)))
2944 return(TXM_MODULE_INVALID_MEMORY);
2945
2946 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(ULONG)))
2947 return(TXM_MODULE_INVALID_MEMORY);
2948
2949 if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[4])))
2950 return(TXM_MODULE_INVALID_MEMORY);
2951
2952 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], sizeof(ULONG)))
2953 return(TXM_MODULE_INVALID_MEMORY);
2954
2955 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[1], sizeof(ULONG)))
2956 return(TXM_MODULE_INVALID_MEMORY);
2957
2958 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[2], sizeof(ULONG)))
2959 return(TXM_MODULE_INVALID_MEMORY);
2960
2961 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[3], sizeof(ULONG)))
2962 return(TXM_MODULE_INVALID_MEMORY);
2963 }
2964
2965 return_value = (ALIGN_TYPE) _tx_timer_performance_info_get(
2966 (TX_TIMER *) param_0,
2967 (ULONG *) param_1,
2968 (ULONG *) extra_parameters[0],
2969 (ULONG *) extra_parameters[1],
2970 (ULONG *) extra_parameters[2],
2971 (ULONG *) extra_parameters[3]
2972 );
2973 return(return_value);
2974 }
2975 #endif
2976
2977 #ifndef TXM_TIMER_PERFORMANCE_SYSTEM_INFO_GET_CALL_NOT_USED
2978 /* UINT _tx_timer_performance_system_info_get(
2979 ULONG *activates, -> param_0
2980 ULONG *reactivates, -> param_1
2981 ULONG *deactivates, -> extra_parameters[0]
2982 ULONG *expirations, -> extra_parameters[1]
2983 ULONG *expiration_adjusts -> extra_parameters[2]
2984 ); */
_txm_module_manager_tx_timer_performance_system_info_get_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE * extra_parameters)2985 static ALIGN_TYPE _txm_module_manager_tx_timer_performance_system_info_get_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE *extra_parameters)
2986 {
2987
2988 ALIGN_TYPE return_value;
2989
2990 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
2991 {
2992 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_0, sizeof(ULONG)))
2993 return(TXM_MODULE_INVALID_MEMORY);
2994
2995 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_1, sizeof(ULONG)))
2996 return(TXM_MODULE_INVALID_MEMORY);
2997
2998 if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[3])))
2999 return(TXM_MODULE_INVALID_MEMORY);
3000
3001 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[0], sizeof(ULONG)))
3002 return(TXM_MODULE_INVALID_MEMORY);
3003
3004 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[1], sizeof(ULONG)))
3005 return(TXM_MODULE_INVALID_MEMORY);
3006
3007 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[2], sizeof(ULONG)))
3008 return(TXM_MODULE_INVALID_MEMORY);
3009 }
3010
3011 return_value = (ALIGN_TYPE) _tx_timer_performance_system_info_get(
3012 (ULONG *) param_0,
3013 (ULONG *) param_1,
3014 (ULONG *) extra_parameters[0],
3015 (ULONG *) extra_parameters[1],
3016 (ULONG *) extra_parameters[2]
3017 );
3018 return(return_value);
3019 }
3020 #endif
3021
3022 #ifndef TXM_TRACE_BUFFER_FULL_NOTIFY_CALL_NOT_USED
3023 /* UINT _tx_trace_buffer_full_notify(
3024 VOID (*full_buffer_callback)(VOID *buffer) -> param_0
3025 ); */
_txm_module_manager_tx_trace_buffer_full_notify_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0)3026 static ALIGN_TYPE _txm_module_manager_tx_trace_buffer_full_notify_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0)
3027 {
3028
3029 ALIGN_TYPE return_value;
3030
3031 return_value = (ALIGN_TYPE) _tx_trace_buffer_full_notify(
3032 (VOID (*)(VOID *buffer)) param_0
3033 );
3034 return(return_value);
3035 }
3036 #endif
3037
3038 #ifndef TXM_TRACE_DISABLE_CALL_NOT_USED
3039 /* UINT _tx_trace_disable(); */
_txm_module_manager_tx_trace_disable_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE * extra_parameters)3040 static ALIGN_TYPE _txm_module_manager_tx_trace_disable_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE *extra_parameters)
3041 {
3042
3043 ALIGN_TYPE return_value;
3044
3045 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_USER_MODE)
3046 return(TXM_MODULE_INVALID_PROPERTIES);
3047
3048 return_value = (ALIGN_TYPE) _tx_trace_disable();
3049 return(return_value);
3050 }
3051 #endif
3052
3053 #ifndef TXM_TRACE_ENABLE_CALL_NOT_USED
3054 /* UINT _tx_trace_enable(
3055 VOID *trace_buffer_start, -> param_0
3056 ULONG trace_buffer_size, -> param_1
3057 ULONG registry_entries -> param_2
3058 ); */
_txm_module_manager_tx_trace_enable_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE param_2)3059 static ALIGN_TYPE _txm_module_manager_tx_trace_enable_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE param_2)
3060 {
3061
3062 ALIGN_TYPE return_value;
3063
3064 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_USER_MODE)
3065 return(TXM_MODULE_INVALID_PROPERTIES);
3066
3067 return_value = (ALIGN_TYPE) _tx_trace_enable(
3068 (VOID *) param_0,
3069 (ULONG) param_1,
3070 (ULONG) param_2
3071 );
3072 return(return_value);
3073 }
3074 #endif
3075
3076 #ifndef TXM_TRACE_EVENT_FILTER_CALL_NOT_USED
3077 /* UINT _tx_trace_event_filter(
3078 ULONG event_filter_bits -> param_0
3079 ); */
_txm_module_manager_tx_trace_event_filter_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0)3080 static ALIGN_TYPE _txm_module_manager_tx_trace_event_filter_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0)
3081 {
3082
3083 ALIGN_TYPE return_value;
3084
3085 return_value = (ALIGN_TYPE) _tx_trace_event_filter(
3086 (ULONG) param_0
3087 );
3088 return(return_value);
3089 }
3090 #endif
3091
3092 #ifndef TXM_TRACE_EVENT_UNFILTER_CALL_NOT_USED
3093 /* UINT _tx_trace_event_unfilter(
3094 ULONG event_unfilter_bits -> param_0
3095 ); */
_txm_module_manager_tx_trace_event_unfilter_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0)3096 static ALIGN_TYPE _txm_module_manager_tx_trace_event_unfilter_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0)
3097 {
3098
3099 ALIGN_TYPE return_value;
3100
3101 return_value = (ALIGN_TYPE) _tx_trace_event_unfilter(
3102 (ULONG) param_0
3103 );
3104 return(return_value);
3105 }
3106 #endif
3107
3108 #ifndef TXM_TRACE_INTERRUPT_CONTROL_CALL_NOT_USED
3109 /* UINT _tx_trace_interrupt_control(
3110 UINT new_posture -> param_0
3111 ); */
_txm_module_manager_tx_trace_interrupt_control_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0)3112 static ALIGN_TYPE _txm_module_manager_tx_trace_interrupt_control_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0)
3113 {
3114
3115 ALIGN_TYPE return_value;
3116
3117 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_USER_MODE)
3118 return(TXM_MODULE_INVALID_PROPERTIES);
3119
3120 return_value = (ALIGN_TYPE) _tx_trace_interrupt_control(
3121 (UINT) param_0
3122 );
3123 return(return_value);
3124 }
3125 #endif
3126
3127 #ifndef TXM_TRACE_ISR_ENTER_INSERT_CALL_NOT_USED
3128 /* VOID _tx_trace_isr_enter_insert(
3129 ULONG isr_id -> param_0
3130 ); */
_txm_module_manager_tx_trace_isr_enter_insert_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0)3131 static ALIGN_TYPE _txm_module_manager_tx_trace_isr_enter_insert_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0)
3132 {
3133
3134 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_USER_MODE)
3135 return(TXM_MODULE_INVALID_PROPERTIES);
3136
3137 _tx_trace_isr_enter_insert(
3138 (ULONG) param_0
3139 );
3140 return(TX_SUCCESS);
3141 }
3142 #endif
3143
3144 #ifndef TXM_TRACE_ISR_EXIT_INSERT_CALL_NOT_USED
3145 /* VOID _tx_trace_isr_exit_insert(
3146 ULONG isr_id -> param_0
3147 ); */
_txm_module_manager_tx_trace_isr_exit_insert_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0)3148 static ALIGN_TYPE _txm_module_manager_tx_trace_isr_exit_insert_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0)
3149 {
3150
3151 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_USER_MODE)
3152 return(TXM_MODULE_INVALID_PROPERTIES);
3153
3154 _tx_trace_isr_exit_insert(
3155 (ULONG) param_0
3156 );
3157 return(TX_SUCCESS);
3158 }
3159 #endif
3160
3161 #ifndef TXM_TRACE_USER_EVENT_INSERT_CALL_NOT_USED
3162 /* UINT _tx_trace_user_event_insert(
3163 ULONG event_id, -> param_0
3164 ULONG info_field_1, -> param_1
3165 ULONG info_field_2, -> extra_parameters[0]
3166 ULONG info_field_3, -> extra_parameters[1]
3167 ULONG info_field_4 -> extra_parameters[2]
3168 ); */
_txm_module_manager_tx_trace_user_event_insert_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE * extra_parameters)3169 static ALIGN_TYPE _txm_module_manager_tx_trace_user_event_insert_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE *extra_parameters)
3170 {
3171
3172 ALIGN_TYPE return_value;
3173
3174 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
3175 {
3176 if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[3])))
3177 return(TXM_MODULE_INVALID_MEMORY);
3178 }
3179
3180 return_value = (ALIGN_TYPE) _tx_trace_user_event_insert(
3181 (ULONG) param_0,
3182 (ULONG) param_1,
3183 (ULONG) extra_parameters[0],
3184 (ULONG) extra_parameters[1],
3185 (ULONG) extra_parameters[2]
3186 );
3187 return(return_value);
3188 }
3189 #endif
3190
3191 #ifndef TXM_MODULE_OBJECT_ALLOCATE_CALL_NOT_USED
3192 /* UINT _txm_module_object_allocate(
3193 VOID **object_ptr, -> param_0
3194 ULONG object_size -> param_1
3195 ); */
_txm_module_manager_txm_module_object_allocate_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1)3196 static ALIGN_TYPE _txm_module_manager_txm_module_object_allocate_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1)
3197 {
3198
3199 ALIGN_TYPE return_value;
3200
3201 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
3202 {
3203 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_0, sizeof(VOID *)))
3204 return(TXM_MODULE_INVALID_MEMORY);
3205 }
3206
3207 return_value = (ALIGN_TYPE) _txm_module_manager_object_allocate(
3208 (VOID **) param_0,
3209 (ULONG) param_1,
3210 module_instance
3211 );
3212 return(return_value);
3213 }
3214 #endif
3215
3216 #ifndef TXM_MODULE_OBJECT_DEALLOCATE_CALL_NOT_USED
3217 /* UINT _txm_module_object_deallocate(
3218 VOID *object_ptr -> param_0
3219 ); */
_txm_module_manager_txm_module_object_deallocate_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0)3220 static ALIGN_TYPE _txm_module_manager_txm_module_object_deallocate_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0)
3221 {
3222
3223 ALIGN_TYPE return_value;
3224 TXM_MODULE_ALLOCATED_OBJECT *object_ptr;
3225 ALIGN_TYPE object_end;
3226 ALIGN_TYPE object_pool_end;
3227
3228 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
3229 {
3230 /* Is the object pool created? */
3231 if (_txm_module_manager_object_pool_created == TX_TRUE)
3232 {
3233
3234 /* Get the module allocated object. */
3235 object_ptr = ((TXM_MODULE_ALLOCATED_OBJECT *) param_0) - 1;
3236
3237 /* Get the end address of the object pool. */
3238 object_pool_end = (ALIGN_TYPE) (_txm_module_manager_object_pool.tx_byte_pool_start + _txm_module_manager_object_pool.tx_byte_pool_size);
3239
3240 /* Check that the pointer is in the object pool. */
3241 if ((ALIGN_TYPE) object_ptr < (ALIGN_TYPE) _txm_module_manager_object_pool.tx_byte_pool_start ||
3242 (ALIGN_TYPE) object_ptr >= (ALIGN_TYPE) object_pool_end)
3243 {
3244 /* Pointer is outside of the object pool. */
3245 return(TXM_MODULE_INVALID_MEMORY);
3246 }
3247
3248 /* Get the end addresses of the object. */
3249 object_end = ((ALIGN_TYPE) object_ptr) + sizeof(TXM_MODULE_ALLOCATED_OBJECT) + object_ptr -> txm_module_object_size;
3250
3251 /* Check that the object is in the object pool. */
3252 if (object_end >= object_pool_end)
3253 {
3254 /* Object is outside of the object pool. */
3255 return(TXM_MODULE_INVALID_MEMORY);
3256 }
3257 }
3258 }
3259
3260 return_value = (ALIGN_TYPE) _txm_module_manager_object_deallocate(
3261 (VOID *) param_0
3262 );
3263 return(return_value);
3264 }
3265 #endif
3266
3267 #ifndef TXM_MODULE_OBJECT_POINTER_GET_CALL_NOT_USED
3268 /* UINT _txm_module_object_pointer_get(
3269 UINT object_type, -> param_0
3270 CHAR *name, -> param_1
3271 VOID **object_ptr -> param_2
3272 ); */
_txm_module_manager_txm_module_object_pointer_get_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE param_2)3273 static ALIGN_TYPE _txm_module_manager_txm_module_object_pointer_get_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE param_2)
3274 {
3275
3276 ALIGN_TYPE return_value;
3277
3278 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
3279 {
3280 if (!TXM_MODULE_MANAGER_PARAM_CHECK_DEREFERENCE_STRING(module_instance, param_1))
3281 return(TXM_MODULE_INVALID_MEMORY);
3282
3283 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, param_2, sizeof(VOID *)))
3284 return(TXM_MODULE_INVALID_MEMORY);
3285 }
3286
3287 return_value = (ALIGN_TYPE) _txm_module_manager_object_pointer_get(
3288 (UINT) param_0,
3289 (CHAR *) param_1,
3290 (VOID **) param_2
3291 );
3292 return(return_value);
3293 }
3294 #endif
3295
3296 #ifndef TXM_MODULE_OBJECT_POINTER_GET_EXTENDED_CALL_NOT_USED
3297 /* UINT _txm_module_object_pointer_get_extended(
3298 UINT object_type, -> param_0
3299 CHAR *name, -> param_1
3300 UINT name_length, -> extra_parameters[0]
3301 VOID **object_ptr -> extra_parameters[1]
3302 ); */
_txm_module_manager_txm_module_object_pointer_get_extended_dispatch(TXM_MODULE_INSTANCE * module_instance,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE * extra_parameters)3303 static ALIGN_TYPE _txm_module_manager_txm_module_object_pointer_get_extended_dispatch(TXM_MODULE_INSTANCE *module_instance, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE *extra_parameters)
3304 {
3305
3306 ALIGN_TYPE return_value;
3307
3308 if (module_instance -> txm_module_instance_property_flags & TXM_MODULE_MEMORY_PROTECTION)
3309 {
3310 if (!TXM_MODULE_MANAGER_PARAM_CHECK_DEREFERENCE_STRING(module_instance, param_1))
3311 return(TXM_MODULE_INVALID_MEMORY);
3312
3313 if (!TXM_MODULE_MANAGER_ENSURE_INSIDE_MODULE_DATA(module_instance, (ALIGN_TYPE)extra_parameters, sizeof(ALIGN_TYPE[2])))
3314 return(TXM_MODULE_INVALID_MEMORY);
3315
3316 if (!TXM_MODULE_MANAGER_PARAM_CHECK_BUFFER_WRITE(module_instance, extra_parameters[1], sizeof(VOID *)))
3317 return(TXM_MODULE_INVALID_MEMORY);
3318 }
3319
3320 return_value = (ALIGN_TYPE) _txm_module_manager_object_pointer_get_extended(
3321 (UINT) param_0,
3322 (CHAR *) param_1,
3323 (UINT) extra_parameters[0],
3324 (VOID **) extra_parameters[1]
3325 );
3326 return(return_value);
3327 }
3328 #endif
3329
