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 							   &params[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 				      &param_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