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