1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
2 /*******************************************************************************
3 *
4 * Module Name: dbexec - debugger control method execution
5 *
6 ******************************************************************************/
7
8 #include <acpi/acpi.h>
9 #include "accommon.h"
10 #include "acdebug.h"
11 #include "acnamesp.h"
12
13 #define _COMPONENT ACPI_CA_DEBUGGER
14 ACPI_MODULE_NAME("dbexec")
15
16 static struct acpi_db_method_info acpi_gbl_db_method_info;
17
18 /* Local prototypes */
19
20 static acpi_status
21 acpi_db_execute_method(struct acpi_db_method_info *info,
22 struct acpi_buffer *return_obj);
23
24 static acpi_status acpi_db_execute_setup(struct acpi_db_method_info *info);
25
26 static u32 acpi_db_get_outstanding_allocations(void);
27
28 static void ACPI_SYSTEM_XFACE acpi_db_method_thread(void *context);
29
30 static acpi_status
31 acpi_db_execution_walk(acpi_handle obj_handle,
32 u32 nesting_level, void *context, void **return_value);
33
34 static void ACPI_SYSTEM_XFACE acpi_db_single_execution_thread(void *context);
35
36 /*******************************************************************************
37 *
38 * FUNCTION: acpi_db_delete_objects
39 *
40 * PARAMETERS: count - Count of objects in the list
41 * objects - Array of ACPI_OBJECTs to be deleted
42 *
43 * RETURN: None
44 *
45 * DESCRIPTION: Delete a list of ACPI_OBJECTS. Handles packages and nested
46 * packages via recursion.
47 *
48 ******************************************************************************/
49
acpi_db_delete_objects(u32 count,union acpi_object * objects)50 void acpi_db_delete_objects(u32 count, union acpi_object *objects)
51 {
52 u32 i;
53
54 for (i = 0; i < count; i++) {
55 switch (objects[i].type) {
56 case ACPI_TYPE_BUFFER:
57
58 ACPI_FREE(objects[i].buffer.pointer);
59 break;
60
61 case ACPI_TYPE_PACKAGE:
62
63 /* Recursive call to delete package elements */
64
65 acpi_db_delete_objects(objects[i].package.count,
66 objects[i].package.elements);
67
68 /* Free the elements array */
69
70 ACPI_FREE(objects[i].package.elements);
71 break;
72
73 default:
74
75 break;
76 }
77 }
78 }
79
80 /*******************************************************************************
81 *
82 * FUNCTION: acpi_db_execute_method
83 *
84 * PARAMETERS: info - Valid info segment
85 * return_obj - Where to put return object
86 *
87 * RETURN: Status
88 *
89 * DESCRIPTION: Execute a control method. Used to evaluate objects via the
90 * "EXECUTE" or "EVALUATE" commands.
91 *
92 ******************************************************************************/
93
94 static acpi_status
acpi_db_execute_method(struct acpi_db_method_info * info,struct acpi_buffer * return_obj)95 acpi_db_execute_method(struct acpi_db_method_info *info,
96 struct acpi_buffer *return_obj)
97 {
98 acpi_status status;
99 struct acpi_object_list param_objects;
100 union acpi_object params[ACPI_DEBUGGER_MAX_ARGS + 1];
101 u32 i;
102
103 ACPI_FUNCTION_TRACE(db_execute_method);
104
105 if (acpi_gbl_db_output_to_file && !acpi_dbg_level) {
106 acpi_os_printf("Warning: debug output is not enabled!\n");
107 }
108
109 param_objects.count = 0;
110 param_objects.pointer = NULL;
111
112 /* Pass through any command-line arguments */
113
114 if (info->args && info->args[0]) {
115
116 /* Get arguments passed on the command line */
117
118 for (i = 0; (info->args[i] && *(info->args[i])); i++) {
119
120 /* Convert input string (token) to an actual union acpi_object */
121
122 status = acpi_db_convert_to_object(info->types[i],
123 info->args[i],
124 ¶ms[i]);
125 if (ACPI_FAILURE(status)) {
126 ACPI_EXCEPTION((AE_INFO, status,
127 "While parsing method arguments"));
128 goto cleanup;
129 }
130 }
131
132 param_objects.count = i;
133 param_objects.pointer = params;
134 }
135
136 /* Prepare for a return object of arbitrary size */
137
138 return_obj->pointer = acpi_gbl_db_buffer;
139 return_obj->length = ACPI_DEBUG_BUFFER_SIZE;
140
141 /* Do the actual method execution */
142
143 acpi_gbl_method_executing = TRUE;
144 status = acpi_evaluate_object(NULL, info->pathname,
145 ¶m_objects, return_obj);
146
147 acpi_gbl_cm_single_step = FALSE;
148 acpi_gbl_method_executing = FALSE;
149
150 if (ACPI_FAILURE(status)) {
151 if ((status == AE_ABORT_METHOD) || acpi_gbl_abort_method) {
152
153 /* Clear the abort and fall back to the debugger prompt */
154
155 ACPI_EXCEPTION((AE_INFO, status,
156 "Aborting top-level method"));
157
158 acpi_gbl_abort_method = FALSE;
159 status = AE_OK;
160 goto cleanup;
161 }
162
163 ACPI_EXCEPTION((AE_INFO, status,
164 "while executing %s from AML Debugger",
165 info->pathname));
166
167 if (status == AE_BUFFER_OVERFLOW) {
168 ACPI_ERROR((AE_INFO,
169 "Possible buffer overflow within AML Debugger "
170 "buffer (size 0x%X needed 0x%X)",
171 ACPI_DEBUG_BUFFER_SIZE,
172 (u32)return_obj->length));
173 }
174 }
175
176 cleanup:
177 acpi_db_delete_objects(param_objects.count, params);
178 return_ACPI_STATUS(status);
179 }
180
181 /*******************************************************************************
182 *
183 * FUNCTION: acpi_db_execute_setup
184 *
185 * PARAMETERS: info - Valid method info
186 *
187 * RETURN: None
188 *
189 * DESCRIPTION: Setup info segment prior to method execution
190 *
191 ******************************************************************************/
192
acpi_db_execute_setup(struct acpi_db_method_info * info)193 static acpi_status acpi_db_execute_setup(struct acpi_db_method_info *info)
194 {
195 acpi_status status;
196
197 ACPI_FUNCTION_NAME(db_execute_setup);
198
199 /* Concatenate the current scope to the supplied name */
200
201 info->pathname[0] = 0;
202 if ((info->name[0] != '\\') && (info->name[0] != '/')) {
203 if (acpi_ut_safe_strcat(info->pathname, sizeof(info->pathname),
204 acpi_gbl_db_scope_buf)) {
205 status = AE_BUFFER_OVERFLOW;
206 goto error_exit;
207 }
208 }
209
210 if (acpi_ut_safe_strcat(info->pathname, sizeof(info->pathname),
211 info->name)) {
212 status = AE_BUFFER_OVERFLOW;
213 goto error_exit;
214 }
215
216 acpi_db_prep_namestring(info->pathname);
217
218 acpi_db_set_output_destination(ACPI_DB_DUPLICATE_OUTPUT);
219 acpi_os_printf("Evaluating %s\n", info->pathname);
220
221 if (info->flags & EX_SINGLE_STEP) {
222 acpi_gbl_cm_single_step = TRUE;
223 acpi_db_set_output_destination(ACPI_DB_CONSOLE_OUTPUT);
224 }
225
226 else {
227 /* No single step, allow redirection to a file */
228
229 acpi_db_set_output_destination(ACPI_DB_REDIRECTABLE_OUTPUT);
230 }
231
232 return (AE_OK);
233
234 error_exit:
235
236 ACPI_EXCEPTION((AE_INFO, status, "During setup for method execution"));
237 return (status);
238 }
239
240 #ifdef ACPI_DBG_TRACK_ALLOCATIONS
acpi_db_get_cache_info(struct acpi_memory_list * cache)241 u32 acpi_db_get_cache_info(struct acpi_memory_list *cache)
242 {
243
244 return (cache->total_allocated - cache->total_freed -
245 cache->current_depth);
246 }
247 #endif
248
249 /*******************************************************************************
250 *
251 * FUNCTION: acpi_db_get_outstanding_allocations
252 *
253 * PARAMETERS: None
254 *
255 * RETURN: Current global allocation count minus cache entries
256 *
257 * DESCRIPTION: Determine the current number of "outstanding" allocations --
258 * those allocations that have not been freed and also are not
259 * in one of the various object caches.
260 *
261 ******************************************************************************/
262
acpi_db_get_outstanding_allocations(void)263 static u32 acpi_db_get_outstanding_allocations(void)
264 {
265 u32 outstanding = 0;
266
267 #ifdef ACPI_DBG_TRACK_ALLOCATIONS
268
269 outstanding += acpi_db_get_cache_info(acpi_gbl_state_cache);
270 outstanding += acpi_db_get_cache_info(acpi_gbl_ps_node_cache);
271 outstanding += acpi_db_get_cache_info(acpi_gbl_ps_node_ext_cache);
272 outstanding += acpi_db_get_cache_info(acpi_gbl_operand_cache);
273 #endif
274
275 return (outstanding);
276 }
277
278 /*******************************************************************************
279 *
280 * FUNCTION: acpi_db_execution_walk
281 *
282 * PARAMETERS: WALK_CALLBACK
283 *
284 * RETURN: Status
285 *
286 * DESCRIPTION: Execute a control method. Name is relative to the current
287 * scope.
288 *
289 ******************************************************************************/
290
291 static acpi_status
acpi_db_execution_walk(acpi_handle obj_handle,u32 nesting_level,void * context,void ** return_value)292 acpi_db_execution_walk(acpi_handle obj_handle,
293 u32 nesting_level, void *context, void **return_value)
294 {
295 union acpi_operand_object *obj_desc;
296 struct acpi_namespace_node *node =
297 (struct acpi_namespace_node *)obj_handle;
298 struct acpi_buffer return_obj;
299 acpi_status status;
300
301 obj_desc = acpi_ns_get_attached_object(node);
302 if (obj_desc->method.param_count) {
303 return (AE_OK);
304 }
305
306 return_obj.pointer = NULL;
307 return_obj.length = ACPI_ALLOCATE_BUFFER;
308
309 acpi_ns_print_node_pathname(node, "Evaluating");
310
311 /* Do the actual method execution */
312
313 acpi_os_printf("\n");
314 acpi_gbl_method_executing = TRUE;
315
316 status = acpi_evaluate_object(node, NULL, NULL, &return_obj);
317
318 acpi_gbl_method_executing = FALSE;
319
320 acpi_os_printf("Evaluation of [%4.4s] returned %s\n",
321 acpi_ut_get_node_name(node),
322 acpi_format_exception(status));
323
324 return (AE_OK);
325 }
326
327 /*******************************************************************************
328 *
329 * FUNCTION: acpi_db_execute
330 *
331 * PARAMETERS: name - Name of method to execute
332 * args - Parameters to the method
333 * Types -
334 * flags - single step/no single step
335 *
336 * RETURN: None
337 *
338 * DESCRIPTION: Execute a control method. Name is relative to the current
339 * scope. Function used for the "EXECUTE", "EVALUATE", and
340 * "ALL" commands
341 *
342 ******************************************************************************/
343
344 void
acpi_db_execute(char * name,char ** args,acpi_object_type * types,u32 flags)345 acpi_db_execute(char *name, char **args, acpi_object_type *types, u32 flags)
346 {
347 acpi_status status;
348 struct acpi_buffer return_obj;
349 char *name_string;
350
351 #ifdef ACPI_DEBUG_OUTPUT
352 u32 previous_allocations;
353 u32 allocations;
354 #endif
355
356 /*
357 * Allow one execution to be performed by debugger or single step
358 * execution will be dead locked by the interpreter mutexes.
359 */
360 if (acpi_gbl_method_executing) {
361 acpi_os_printf("Only one debugger execution is allowed.\n");
362 return;
363 }
364 #ifdef ACPI_DEBUG_OUTPUT
365 /* Memory allocation tracking */
366
367 previous_allocations = acpi_db_get_outstanding_allocations();
368 #endif
369
370 if (*name == '*') {
371 (void)acpi_walk_namespace(ACPI_TYPE_METHOD, ACPI_ROOT_OBJECT,
372 ACPI_UINT32_MAX,
373 acpi_db_execution_walk, NULL, NULL,
374 NULL);
375 return;
376 }
377
378 if ((flags & EX_ALL) && (strlen(name) > 4)) {
379 acpi_os_printf("Input name (%s) must be a 4-char NameSeg\n",
380 name);
381 return;
382 }
383
384 name_string = ACPI_ALLOCATE(strlen(name) + 1);
385 if (!name_string) {
386 return;
387 }
388
389 memset(&acpi_gbl_db_method_info, 0, sizeof(struct acpi_db_method_info));
390 strcpy(name_string, name);
391 acpi_ut_strupr(name_string);
392
393 /* Subcommand to Execute all predefined names in the namespace */
394
395 if (!strncmp(name_string, "PREDEF", 6)) {
396 acpi_db_evaluate_predefined_names();
397 ACPI_FREE(name_string);
398 return;
399 }
400
401 /* Command (ALL <nameseg>) to execute all methods of a particular name */
402
403 else if (flags & EX_ALL) {
404 acpi_gbl_db_method_info.name = name_string;
405 return_obj.pointer = NULL;
406 return_obj.length = ACPI_ALLOCATE_BUFFER;
407 acpi_db_evaluate_all(name_string);
408 ACPI_FREE(name_string);
409 return;
410 } else {
411 acpi_gbl_db_method_info.name = name_string;
412 acpi_gbl_db_method_info.args = args;
413 acpi_gbl_db_method_info.types = types;
414 acpi_gbl_db_method_info.flags = flags;
415
416 return_obj.pointer = NULL;
417 return_obj.length = ACPI_ALLOCATE_BUFFER;
418 }
419
420 status = acpi_db_execute_setup(&acpi_gbl_db_method_info);
421 if (ACPI_FAILURE(status)) {
422 ACPI_FREE(name_string);
423 return;
424 }
425
426 /* Get the NS node, determines existence also */
427
428 status = acpi_get_handle(NULL, acpi_gbl_db_method_info.pathname,
429 &acpi_gbl_db_method_info.method);
430 if (ACPI_SUCCESS(status)) {
431 status = acpi_db_execute_method(&acpi_gbl_db_method_info,
432 &return_obj);
433 }
434 ACPI_FREE(name_string);
435
436 /*
437 * Allow any handlers in separate threads to complete.
438 * (Such as Notify handlers invoked from AML executed above).
439 */
440 acpi_os_sleep((u64)10);
441
442 #ifdef ACPI_DEBUG_OUTPUT
443
444 /* Memory allocation tracking */
445
446 allocations =
447 acpi_db_get_outstanding_allocations() - previous_allocations;
448
449 acpi_db_set_output_destination(ACPI_DB_DUPLICATE_OUTPUT);
450
451 if (allocations > 0) {
452 acpi_os_printf
453 ("0x%X Outstanding allocations after evaluation of %s\n",
454 allocations, acpi_gbl_db_method_info.pathname);
455 }
456 #endif
457
458 if (ACPI_FAILURE(status)) {
459 acpi_os_printf("Evaluation of %s failed with status %s\n",
460 acpi_gbl_db_method_info.pathname,
461 acpi_format_exception(status));
462 } else {
463 /* Display a return object, if any */
464
465 if (return_obj.length) {
466 acpi_os_printf("Evaluation of %s returned object %p, "
467 "external buffer length %X\n",
468 acpi_gbl_db_method_info.pathname,
469 return_obj.pointer,
470 (u32)return_obj.length);
471
472 acpi_db_dump_external_object(return_obj.pointer, 1);
473 acpi_os_printf("\n");
474
475 /* Dump a _PLD buffer if present */
476
477 if (ACPI_COMPARE_NAMESEG
478 ((ACPI_CAST_PTR
479 (struct acpi_namespace_node,
480 acpi_gbl_db_method_info.method)->name.ascii),
481 METHOD_NAME__PLD)) {
482 acpi_db_dump_pld_buffer(return_obj.pointer);
483 }
484 } else {
485 acpi_os_printf
486 ("No object was returned from evaluation of %s\n",
487 acpi_gbl_db_method_info.pathname);
488 }
489 }
490
491 acpi_db_set_output_destination(ACPI_DB_CONSOLE_OUTPUT);
492 }
493
494 /*******************************************************************************
495 *
496 * FUNCTION: acpi_db_method_thread
497 *
498 * PARAMETERS: context - Execution info segment
499 *
500 * RETURN: None
501 *
502 * DESCRIPTION: Debugger execute thread. Waits for a command line, then
503 * simply dispatches it.
504 *
505 ******************************************************************************/
506
acpi_db_method_thread(void * context)507 static void ACPI_SYSTEM_XFACE acpi_db_method_thread(void *context)
508 {
509 acpi_status status;
510 struct acpi_db_method_info *info = context;
511 struct acpi_db_method_info local_info;
512 u32 i;
513 u8 allow;
514 struct acpi_buffer return_obj;
515
516 /*
517 * acpi_gbl_db_method_info.Arguments will be passed as method arguments.
518 * Prevent acpi_gbl_db_method_info from being modified by multiple threads
519 * concurrently.
520 *
521 * Note: The arguments we are passing are used by the ASL test suite
522 * (aslts). Do not change them without updating the tests.
523 */
524 (void)acpi_os_wait_semaphore(info->info_gate, 1, ACPI_WAIT_FOREVER);
525
526 if (info->init_args) {
527 acpi_db_uint32_to_hex_string(info->num_created,
528 info->index_of_thread_str);
529 acpi_db_uint32_to_hex_string((u32)acpi_os_get_thread_id(),
530 info->id_of_thread_str);
531 }
532
533 if (info->threads && (info->num_created < info->num_threads)) {
534 info->threads[info->num_created++] = acpi_os_get_thread_id();
535 }
536
537 local_info = *info;
538 local_info.args = local_info.arguments;
539 local_info.arguments[0] = local_info.num_threads_str;
540 local_info.arguments[1] = local_info.id_of_thread_str;
541 local_info.arguments[2] = local_info.index_of_thread_str;
542 local_info.arguments[3] = NULL;
543
544 local_info.types = local_info.arg_types;
545
546 (void)acpi_os_signal_semaphore(info->info_gate, 1);
547
548 for (i = 0; i < info->num_loops; i++) {
549 status = acpi_db_execute_method(&local_info, &return_obj);
550 if (ACPI_FAILURE(status)) {
551 acpi_os_printf
552 ("%s During evaluation of %s at iteration %X\n",
553 acpi_format_exception(status), info->pathname, i);
554 if (status == AE_ABORT_METHOD) {
555 break;
556 }
557 }
558 #if 0
559 if ((i % 100) == 0) {
560 acpi_os_printf("%u loops, Thread 0x%x\n",
561 i, acpi_os_get_thread_id());
562 }
563
564 if (return_obj.length) {
565 acpi_os_printf
566 ("Evaluation of %s returned object %p Buflen %X\n",
567 info->pathname, return_obj.pointer,
568 (u32)return_obj.length);
569 acpi_db_dump_external_object(return_obj.pointer, 1);
570 }
571 #endif
572 }
573
574 /* Signal our completion */
575
576 allow = 0;
577 (void)acpi_os_wait_semaphore(info->thread_complete_gate,
578 1, ACPI_WAIT_FOREVER);
579 info->num_completed++;
580
581 if (info->num_completed == info->num_threads) {
582
583 /* Do signal for main thread once only */
584 allow = 1;
585 }
586
587 (void)acpi_os_signal_semaphore(info->thread_complete_gate, 1);
588
589 if (allow) {
590 status = acpi_os_signal_semaphore(info->main_thread_gate, 1);
591 if (ACPI_FAILURE(status)) {
592 acpi_os_printf
593 ("Could not signal debugger thread sync semaphore, %s\n",
594 acpi_format_exception(status));
595 }
596 }
597 }
598
599 /*******************************************************************************
600 *
601 * FUNCTION: acpi_db_single_execution_thread
602 *
603 * PARAMETERS: context - Method info struct
604 *
605 * RETURN: None
606 *
607 * DESCRIPTION: Create one thread and execute a method
608 *
609 ******************************************************************************/
610
acpi_db_single_execution_thread(void * context)611 static void ACPI_SYSTEM_XFACE acpi_db_single_execution_thread(void *context)
612 {
613 struct acpi_db_method_info *info = context;
614 acpi_status status;
615 struct acpi_buffer return_obj;
616
617 acpi_os_printf("\n");
618
619 status = acpi_db_execute_method(info, &return_obj);
620 if (ACPI_FAILURE(status)) {
621 acpi_os_printf("%s During evaluation of %s\n",
622 acpi_format_exception(status), info->pathname);
623 return;
624 }
625
626 /* Display a return object, if any */
627
628 if (return_obj.length) {
629 acpi_os_printf("Evaluation of %s returned object %p, "
630 "external buffer length %X\n",
631 acpi_gbl_db_method_info.pathname,
632 return_obj.pointer, (u32)return_obj.length);
633
634 acpi_db_dump_external_object(return_obj.pointer, 1);
635 }
636
637 acpi_os_printf("\nBackground thread completed\n%c ",
638 ACPI_DEBUGGER_COMMAND_PROMPT);
639 }
640
641 /*******************************************************************************
642 *
643 * FUNCTION: acpi_db_create_execution_thread
644 *
645 * PARAMETERS: method_name_arg - Control method to execute
646 * arguments - Array of arguments to the method
647 * types - Corresponding array of object types
648 *
649 * RETURN: None
650 *
651 * DESCRIPTION: Create a single thread to evaluate a namespace object. Handles
652 * arguments passed on command line for control methods.
653 *
654 ******************************************************************************/
655
656 void
acpi_db_create_execution_thread(char * method_name_arg,char ** arguments,acpi_object_type * types)657 acpi_db_create_execution_thread(char *method_name_arg,
658 char **arguments, acpi_object_type *types)
659 {
660 acpi_status status;
661 u32 i;
662
663 memset(&acpi_gbl_db_method_info, 0, sizeof(struct acpi_db_method_info));
664 acpi_gbl_db_method_info.name = method_name_arg;
665 acpi_gbl_db_method_info.init_args = 1;
666 acpi_gbl_db_method_info.args = acpi_gbl_db_method_info.arguments;
667 acpi_gbl_db_method_info.types = acpi_gbl_db_method_info.arg_types;
668
669 /* Setup method arguments, up to 7 (0-6) */
670
671 for (i = 0; (i < ACPI_METHOD_NUM_ARGS) && *arguments; i++) {
672 acpi_gbl_db_method_info.arguments[i] = *arguments;
673 arguments++;
674
675 acpi_gbl_db_method_info.arg_types[i] = *types;
676 types++;
677 }
678
679 status = acpi_db_execute_setup(&acpi_gbl_db_method_info);
680 if (ACPI_FAILURE(status)) {
681 return;
682 }
683
684 /* Get the NS node, determines existence also */
685
686 status = acpi_get_handle(NULL, acpi_gbl_db_method_info.pathname,
687 &acpi_gbl_db_method_info.method);
688 if (ACPI_FAILURE(status)) {
689 acpi_os_printf("%s Could not get handle for %s\n",
690 acpi_format_exception(status),
691 acpi_gbl_db_method_info.pathname);
692 return;
693 }
694
695 status = acpi_os_execute(OSL_DEBUGGER_EXEC_THREAD,
696 acpi_db_single_execution_thread,
697 &acpi_gbl_db_method_info);
698 if (ACPI_FAILURE(status)) {
699 return;
700 }
701
702 acpi_os_printf("\nBackground thread started\n");
703 }
704
705 /*******************************************************************************
706 *
707 * FUNCTION: acpi_db_create_execution_threads
708 *
709 * PARAMETERS: num_threads_arg - Number of threads to create
710 * num_loops_arg - Loop count for the thread(s)
711 * method_name_arg - Control method to execute
712 *
713 * RETURN: None
714 *
715 * DESCRIPTION: Create threads to execute method(s)
716 *
717 ******************************************************************************/
718
719 void
acpi_db_create_execution_threads(char * num_threads_arg,char * num_loops_arg,char * method_name_arg)720 acpi_db_create_execution_threads(char *num_threads_arg,
721 char *num_loops_arg, char *method_name_arg)
722 {
723 acpi_status status;
724 u32 num_threads;
725 u32 num_loops;
726 u32 i;
727 u32 size;
728 acpi_mutex main_thread_gate;
729 acpi_mutex thread_complete_gate;
730 acpi_mutex info_gate;
731
732 /* Get the arguments */
733
734 num_threads = strtoul(num_threads_arg, NULL, 0);
735 num_loops = strtoul(num_loops_arg, NULL, 0);
736
737 if (!num_threads || !num_loops) {
738 acpi_os_printf("Bad argument: Threads %X, Loops %X\n",
739 num_threads, num_loops);
740 return;
741 }
742
743 /*
744 * Create the semaphore for synchronization of
745 * the created threads with the main thread.
746 */
747 status = acpi_os_create_semaphore(1, 0, &main_thread_gate);
748 if (ACPI_FAILURE(status)) {
749 acpi_os_printf("Could not create semaphore for "
750 "synchronization with the main thread, %s\n",
751 acpi_format_exception(status));
752 return;
753 }
754
755 /*
756 * Create the semaphore for synchronization
757 * between the created threads.
758 */
759 status = acpi_os_create_semaphore(1, 1, &thread_complete_gate);
760 if (ACPI_FAILURE(status)) {
761 acpi_os_printf("Could not create semaphore for "
762 "synchronization between the created threads, %s\n",
763 acpi_format_exception(status));
764
765 (void)acpi_os_delete_semaphore(main_thread_gate);
766 return;
767 }
768
769 status = acpi_os_create_semaphore(1, 1, &info_gate);
770 if (ACPI_FAILURE(status)) {
771 acpi_os_printf("Could not create semaphore for "
772 "synchronization of AcpiGbl_DbMethodInfo, %s\n",
773 acpi_format_exception(status));
774
775 (void)acpi_os_delete_semaphore(thread_complete_gate);
776 (void)acpi_os_delete_semaphore(main_thread_gate);
777 return;
778 }
779
780 memset(&acpi_gbl_db_method_info, 0, sizeof(struct acpi_db_method_info));
781
782 /* Array to store IDs of threads */
783
784 acpi_gbl_db_method_info.num_threads = num_threads;
785 size = sizeof(acpi_thread_id) * acpi_gbl_db_method_info.num_threads;
786
787 acpi_gbl_db_method_info.threads = acpi_os_allocate(size);
788 if (acpi_gbl_db_method_info.threads == NULL) {
789 acpi_os_printf("No memory for thread IDs array\n");
790 (void)acpi_os_delete_semaphore(main_thread_gate);
791 (void)acpi_os_delete_semaphore(thread_complete_gate);
792 (void)acpi_os_delete_semaphore(info_gate);
793 return;
794 }
795 memset(acpi_gbl_db_method_info.threads, 0, size);
796
797 /* Setup the context to be passed to each thread */
798
799 acpi_gbl_db_method_info.name = method_name_arg;
800 acpi_gbl_db_method_info.flags = 0;
801 acpi_gbl_db_method_info.num_loops = num_loops;
802 acpi_gbl_db_method_info.main_thread_gate = main_thread_gate;
803 acpi_gbl_db_method_info.thread_complete_gate = thread_complete_gate;
804 acpi_gbl_db_method_info.info_gate = info_gate;
805
806 /* Init arguments to be passed to method */
807
808 acpi_gbl_db_method_info.init_args = 1;
809 acpi_gbl_db_method_info.args = acpi_gbl_db_method_info.arguments;
810 acpi_gbl_db_method_info.arguments[0] =
811 acpi_gbl_db_method_info.num_threads_str;
812 acpi_gbl_db_method_info.arguments[1] =
813 acpi_gbl_db_method_info.id_of_thread_str;
814 acpi_gbl_db_method_info.arguments[2] =
815 acpi_gbl_db_method_info.index_of_thread_str;
816 acpi_gbl_db_method_info.arguments[3] = NULL;
817
818 acpi_gbl_db_method_info.types = acpi_gbl_db_method_info.arg_types;
819 acpi_gbl_db_method_info.arg_types[0] = ACPI_TYPE_INTEGER;
820 acpi_gbl_db_method_info.arg_types[1] = ACPI_TYPE_INTEGER;
821 acpi_gbl_db_method_info.arg_types[2] = ACPI_TYPE_INTEGER;
822
823 acpi_db_uint32_to_hex_string(num_threads,
824 acpi_gbl_db_method_info.num_threads_str);
825
826 status = acpi_db_execute_setup(&acpi_gbl_db_method_info);
827 if (ACPI_FAILURE(status)) {
828 goto cleanup_and_exit;
829 }
830
831 /* Get the NS node, determines existence also */
832
833 status = acpi_get_handle(NULL, acpi_gbl_db_method_info.pathname,
834 &acpi_gbl_db_method_info.method);
835 if (ACPI_FAILURE(status)) {
836 acpi_os_printf("%s Could not get handle for %s\n",
837 acpi_format_exception(status),
838 acpi_gbl_db_method_info.pathname);
839 goto cleanup_and_exit;
840 }
841
842 /* Create the threads */
843
844 acpi_os_printf("Creating %X threads to execute %X times each\n",
845 num_threads, num_loops);
846
847 for (i = 0; i < (num_threads); i++) {
848 status =
849 acpi_os_execute(OSL_DEBUGGER_EXEC_THREAD,
850 acpi_db_method_thread,
851 &acpi_gbl_db_method_info);
852 if (ACPI_FAILURE(status)) {
853 break;
854 }
855 }
856
857 /* Wait for all threads to complete */
858
859 (void)acpi_os_wait_semaphore(main_thread_gate, 1, ACPI_WAIT_FOREVER);
860
861 acpi_db_set_output_destination(ACPI_DB_DUPLICATE_OUTPUT);
862 acpi_os_printf("All threads (%X) have completed\n", num_threads);
863 acpi_db_set_output_destination(ACPI_DB_CONSOLE_OUTPUT);
864
865 cleanup_and_exit:
866
867 /* Cleanup and exit */
868
869 (void)acpi_os_delete_semaphore(main_thread_gate);
870 (void)acpi_os_delete_semaphore(thread_complete_gate);
871 (void)acpi_os_delete_semaphore(info_gate);
872
873 acpi_os_free(acpi_gbl_db_method_info.threads);
874 acpi_gbl_db_method_info.threads = NULL;
875 }
876