dsmethod.c

  1// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
  2/******************************************************************************
  3 *
  4 * Module Name: dsmethod - Parser/Interpreter interface - control method parsing
  5 *
  6 * Copyright (C) 2000 - 2025, Intel Corp.
  7 *
  8 *****************************************************************************/
  9
 10#include <acpi/acpi.h>
 11#include "accommon.h"
 12#include "acdispat.h"
 13#include "acinterp.h"
 14#include "acnamesp.h"
 15#include "acparser.h"
 16#include "amlcode.h"
 17#include "acdebug.h"
 18
 19#define _COMPONENT          ACPI_DISPATCHER
 20ACPI_MODULE_NAME("dsmethod")
 21
 22/* Local prototypes */
 23static acpi_status
 24acpi_ds_detect_named_opcodes(struct acpi_walk_state *walk_state,
 25			     union acpi_parse_object **out_op);
 26
 27static acpi_status
 28acpi_ds_create_method_mutex(union acpi_operand_object *method_desc);
 29
 30/*******************************************************************************
 31 *
 32 * FUNCTION:    acpi_ds_auto_serialize_method
 33 *
 34 * PARAMETERS:  node                        - Namespace Node of the method
 35 *              obj_desc                    - Method object attached to node
 36 *
 37 * RETURN:      Status
 38 *
 39 * DESCRIPTION: Parse a control method AML to scan for control methods that
 40 *              need serialization due to the creation of named objects.
 41 *
 42 * NOTE: It is a bit of overkill to mark all such methods serialized, since
 43 * there is only a problem if the method actually blocks during execution.
 44 * A blocking operation is, for example, a Sleep() operation, or any access
 45 * to an operation region. However, it is probably not possible to easily
 46 * detect whether a method will block or not, so we simply mark all suspicious
 47 * methods as serialized.
 48 *
 49 * NOTE2: This code is essentially a generic routine for parsing a single
 50 * control method.
 51 *
 52 ******************************************************************************/
 53
 54acpi_status
 55acpi_ds_auto_serialize_method(struct acpi_namespace_node *node,
 56			      union acpi_operand_object *obj_desc)
 57{
 58	acpi_status status;
 59	union acpi_parse_object *op = NULL;
 60	struct acpi_walk_state *walk_state;
 61
 62	ACPI_FUNCTION_TRACE_PTR(ds_auto_serialize_method, node);
 63
 64	ACPI_DEBUG_PRINT((ACPI_DB_PARSE,
 65			  "Method auto-serialization parse [%4.4s] %p\n",
 66			  acpi_ut_get_node_name(node), node));
 67
 68	/* Create/Init a root op for the method parse tree */
 69
 70	op = acpi_ps_alloc_op(AML_METHOD_OP, obj_desc->method.aml_start);
 71	if (!op) {
 72		return_ACPI_STATUS(AE_NO_MEMORY);
 73	}
 74
 75	acpi_ps_set_name(op, node->name.integer);
 76	op->common.node = node;
 77
 78	/* Create and initialize a new walk state */
 79
 80	walk_state =
 81	    acpi_ds_create_walk_state(node->owner_id, NULL, NULL, NULL);
 82	if (!walk_state) {
 83		acpi_ps_free_op(op);
 84		return_ACPI_STATUS(AE_NO_MEMORY);
 85	}
 86
 87	status = acpi_ds_init_aml_walk(walk_state, op, node,
 88				       obj_desc->method.aml_start,
 89				       obj_desc->method.aml_length, NULL, 0);
 90	if (ACPI_FAILURE(status)) {
 91		acpi_ds_delete_walk_state(walk_state);
 92		acpi_ps_free_op(op);
 93		return_ACPI_STATUS(status);
 94	}
 95
 96	walk_state->descending_callback = acpi_ds_detect_named_opcodes;
 97
 98	/* Parse the method, scan for creation of named objects */
 99
100	status = acpi_ps_parse_aml(walk_state);
101
102	acpi_ps_delete_parse_tree(op);
103	return_ACPI_STATUS(status);
104}
105
106/*******************************************************************************
107 *
108 * FUNCTION:    acpi_ds_detect_named_opcodes
109 *
110 * PARAMETERS:  walk_state      - Current state of the parse tree walk
111 *              out_op          - Unused, required for parser interface
112 *
113 * RETURN:      Status
114 *
115 * DESCRIPTION: Descending callback used during the loading of ACPI tables.
116 *              Currently used to detect methods that must be marked serialized
117 *              in order to avoid problems with the creation of named objects.
118 *
119 ******************************************************************************/
120
121static acpi_status
122acpi_ds_detect_named_opcodes(struct acpi_walk_state *walk_state,
123			     union acpi_parse_object **out_op)
124{
125
126	ACPI_FUNCTION_NAME(acpi_ds_detect_named_opcodes);
127
128	/* We are only interested in opcodes that create a new name */
129
130	if (!
131	    (walk_state->op_info->
132	     flags & (AML_NAMED | AML_CREATE | AML_FIELD))) {
133		return (AE_OK);
134	}
135
136	/*
137	 * At this point, we know we have a Named object opcode.
138	 * Mark the method as serialized. Later code will create a mutex for
139	 * this method to enforce serialization.
140	 *
141	 * Note, ACPI_METHOD_IGNORE_SYNC_LEVEL flag means that we will ignore the
142	 * Sync Level mechanism for this method, even though it is now serialized.
143	 * Otherwise, there can be conflicts with existing ASL code that actually
144	 * uses sync levels.
145	 */
146	walk_state->method_desc->method.sync_level = 0;
147	walk_state->method_desc->method.info_flags |=
148	    (ACPI_METHOD_SERIALIZED | ACPI_METHOD_IGNORE_SYNC_LEVEL);
149
150	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
151			  "Method serialized [%4.4s] %p - [%s] (%4.4X)\n",
152			  walk_state->method_node->name.ascii,
153			  walk_state->method_node, walk_state->op_info->name,
154			  walk_state->opcode));
155
156	/* Abort the parse, no need to examine this method any further */
157
158	return (AE_CTRL_TERMINATE);
159}
160
161/*******************************************************************************
162 *
163 * FUNCTION:    acpi_ds_method_error
164 *
165 * PARAMETERS:  status          - Execution status
166 *              walk_state      - Current state
167 *
168 * RETURN:      Status
169 *
170 * DESCRIPTION: Called on method error. Invoke the global exception handler if
171 *              present, dump the method data if the debugger is configured
172 *
173 *              Note: Allows the exception handler to change the status code
174 *
175 ******************************************************************************/
176
177acpi_status
178acpi_ds_method_error(acpi_status status, struct acpi_walk_state *walk_state)
179{
180	u32 aml_offset;
181	acpi_name name = 0;
182
183	ACPI_FUNCTION_ENTRY();
184
185	/* Ignore AE_OK and control exception codes */
186
187	if (ACPI_SUCCESS(status) || (status & AE_CODE_CONTROL)) {
188		return (status);
189	}
190
191	/* Invoke the global exception handler */
192
193	if (acpi_gbl_exception_handler) {
194
195		/* Exit the interpreter, allow handler to execute methods */
196
197		acpi_ex_exit_interpreter();
198
199		/*
200		 * Handler can map the exception code to anything it wants, including
201		 * AE_OK, in which case the executing method will not be aborted.
202		 */
203		aml_offset = (u32)ACPI_PTR_DIFF(walk_state->aml,
204						walk_state->parser_state.
205						aml_start);
206
207		if (walk_state->method_node) {
208			name = walk_state->method_node->name.integer;
209		} else if (walk_state->deferred_node) {
210			name = walk_state->deferred_node->name.integer;
211		}
212
213		status = acpi_gbl_exception_handler(status, name,
214						    walk_state->opcode,
215						    aml_offset, NULL);
216		acpi_ex_enter_interpreter();
217	}
218
219	acpi_ds_clear_implicit_return(walk_state);
220
221	if (ACPI_FAILURE(status)) {
222		acpi_ds_dump_method_stack(status, walk_state, walk_state->op);
223
224		/* Display method locals/args if debugger is present */
225
226#ifdef ACPI_DEBUGGER
227		acpi_db_dump_method_info(status, walk_state);
228#endif
229	}
230
231	return (status);
232}
233
234/*******************************************************************************
235 *
236 * FUNCTION:    acpi_ds_create_method_mutex
237 *
238 * PARAMETERS:  obj_desc            - The method object
239 *
240 * RETURN:      Status
241 *
242 * DESCRIPTION: Create a mutex object for a serialized control method
243 *
244 ******************************************************************************/
245
246static acpi_status
247acpi_ds_create_method_mutex(union acpi_operand_object *method_desc)
248{
249	union acpi_operand_object *mutex_desc;
250	acpi_status status;
251
252	ACPI_FUNCTION_TRACE(ds_create_method_mutex);
253
254	/* Create the new mutex object */
255
256	mutex_desc = acpi_ut_create_internal_object(ACPI_TYPE_MUTEX);
257	if (!mutex_desc) {
258		return_ACPI_STATUS(AE_NO_MEMORY);
259	}
260
261	/* Create the actual OS Mutex */
262
263	status = acpi_os_create_mutex(&mutex_desc->mutex.os_mutex);
264	if (ACPI_FAILURE(status)) {
265		acpi_ut_delete_object_desc(mutex_desc);
266		return_ACPI_STATUS(status);
267	}
268
269	mutex_desc->mutex.sync_level = method_desc->method.sync_level;
270	method_desc->method.mutex = mutex_desc;
271	return_ACPI_STATUS(AE_OK);
272}
273
274/*******************************************************************************
275 *
276 * FUNCTION:    acpi_ds_begin_method_execution
277 *
278 * PARAMETERS:  method_node         - Node of the method
279 *              obj_desc            - The method object
280 *              walk_state          - current state, NULL if not yet executing
281 *                                    a method.
282 *
283 * RETURN:      Status
284 *
285 * DESCRIPTION: Prepare a method for execution. Parses the method if necessary,
286 *              increments the thread count, and waits at the method semaphore
287 *              for clearance to execute.
288 *
289 ******************************************************************************/
290
291acpi_status
292acpi_ds_begin_method_execution(struct acpi_namespace_node *method_node,
293			       union acpi_operand_object *obj_desc,
294			       struct acpi_walk_state *walk_state)
295{
296	acpi_status status = AE_OK;
297
298	ACPI_FUNCTION_TRACE_PTR(ds_begin_method_execution, method_node);
299
300	if (!method_node) {
301		return_ACPI_STATUS(AE_NULL_ENTRY);
302	}
303
304	acpi_ex_start_trace_method(method_node, obj_desc, walk_state);
305
306	/* Prevent wraparound of thread count */
307
308	if (obj_desc->method.thread_count == ACPI_UINT8_MAX) {
309		ACPI_ERROR((AE_INFO,
310			    "Method reached maximum reentrancy limit (255)"));
311		return_ACPI_STATUS(AE_AML_METHOD_LIMIT);
312	}
313
314	/*
315	 * If this method is serialized, we need to acquire the method mutex.
316	 */
317	if (obj_desc->method.info_flags & ACPI_METHOD_SERIALIZED) {
318		/*
319		 * Create a mutex for the method if it is defined to be Serialized
320		 * and a mutex has not already been created. We defer the mutex creation
321		 * until a method is actually executed, to minimize the object count
322		 */
323		if (!obj_desc->method.mutex) {
324			status = acpi_ds_create_method_mutex(obj_desc);
325			if (ACPI_FAILURE(status)) {
326				return_ACPI_STATUS(status);
327			}
328		}
329
330		/*
331		 * The current_sync_level (per-thread) must be less than or equal to
332		 * the sync level of the method. This mechanism provides some
333		 * deadlock prevention.
334		 *
335		 * If the method was auto-serialized, we just ignore the sync level
336		 * mechanism, because auto-serialization of methods can interfere
337		 * with ASL code that actually uses sync levels.
338		 *
339		 * Top-level method invocation has no walk state at this point
340		 */
341		if (walk_state &&
342		    (!(obj_desc->method.
343		       info_flags & ACPI_METHOD_IGNORE_SYNC_LEVEL))
344		    && (walk_state->thread->current_sync_level >
345			obj_desc->method.mutex->mutex.sync_level)) {
346			ACPI_ERROR((AE_INFO,
347				    "Cannot acquire Mutex for method [%4.4s]"
348				    ", current SyncLevel is too large (%u)",
349				    acpi_ut_get_node_name(method_node),
350				    walk_state->thread->current_sync_level));
351
352			return_ACPI_STATUS(AE_AML_MUTEX_ORDER);
353		}
354
355		/*
356		 * Obtain the method mutex if necessary. Do not acquire mutex for a
357		 * recursive call.
358		 */
359		if (!walk_state ||
360		    !obj_desc->method.mutex->mutex.thread_id ||
361		    (walk_state->thread->thread_id !=
362		     obj_desc->method.mutex->mutex.thread_id)) {
363			/*
364			 * Acquire the method mutex. This releases the interpreter if we
365			 * block (and reacquires it before it returns)
366			 */
367			status =
368			    acpi_ex_system_wait_mutex(obj_desc->method.mutex->
369						      mutex.os_mutex,
370						      ACPI_WAIT_FOREVER);
371			if (ACPI_FAILURE(status)) {
372				return_ACPI_STATUS(status);
373			}
374
375			/* Update the mutex and walk info and save the original sync_level */
376
377			if (walk_state) {
378				obj_desc->method.mutex->mutex.
379				    original_sync_level =
380				    walk_state->thread->current_sync_level;
381
382				obj_desc->method.mutex->mutex.thread_id =
383				    walk_state->thread->thread_id;
384
385				/*
386				 * Update the current sync_level only if this is not an auto-
387				 * serialized method. In the auto case, we have to ignore
388				 * the sync level for the method mutex (created for the
389				 * auto-serialization) because we have no idea of what the
390				 * sync level should be. Therefore, just ignore it.
391				 */
392				if (!(obj_desc->method.info_flags &
393				      ACPI_METHOD_IGNORE_SYNC_LEVEL)) {
394					walk_state->thread->current_sync_level =
395					    obj_desc->method.sync_level;
396				}
397			} else {
398				obj_desc->method.mutex->mutex.
399				    original_sync_level =
400				    obj_desc->method.mutex->mutex.sync_level;
401
402				obj_desc->method.mutex->mutex.thread_id =
403				    acpi_os_get_thread_id();
404			}
405		}
406
407		/* Always increase acquisition depth */
408
409		obj_desc->method.mutex->mutex.acquisition_depth++;
410	}
411
412	/*
413	 * Allocate an Owner ID for this method, only if this is the first thread
414	 * to begin concurrent execution. We only need one owner_id, even if the
415	 * method is invoked recursively.
416	 */
417	if (!obj_desc->method.owner_id) {
418		status = acpi_ut_allocate_owner_id(&obj_desc->method.owner_id);
419		if (ACPI_FAILURE(status)) {
420			goto cleanup;
421		}
422	}
423
424	/*
425	 * Increment the method parse tree thread count since it has been
426	 * reentered one more time (even if it is the same thread)
427	 */
428	obj_desc->method.thread_count++;
429	acpi_method_count++;
430	return_ACPI_STATUS(status);
431
432cleanup:
433	/* On error, must release the method mutex (if present) */
434
435	if (obj_desc->method.mutex) {
436		acpi_os_release_mutex(obj_desc->method.mutex->mutex.os_mutex);
437	}
438	return_ACPI_STATUS(status);
439}
440
441/*******************************************************************************
442 *
443 * FUNCTION:    acpi_ds_call_control_method
444 *
445 * PARAMETERS:  thread              - Info for this thread
446 *              this_walk_state     - Current walk state
447 *              op                  - Current Op to be walked
448 *
449 * RETURN:      Status
450 *
451 * DESCRIPTION: Transfer execution to a called control method
452 *
453 ******************************************************************************/
454
455acpi_status
456acpi_ds_call_control_method(struct acpi_thread_state *thread,
457			    struct acpi_walk_state *this_walk_state,
458			    union acpi_parse_object *op)
459{
460	acpi_status status;
461	struct acpi_namespace_node *method_node;
462	struct acpi_walk_state *next_walk_state = NULL;
463	union acpi_operand_object *obj_desc;
464	struct acpi_evaluate_info *info;
465
466	ACPI_FUNCTION_TRACE_PTR(ds_call_control_method, this_walk_state);
467
468	ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
469			  "Calling method %p, currentstate=%p\n",
470			  this_walk_state->prev_op, this_walk_state));
471
472	/*
473	 * Get the namespace entry for the control method we are about to call
474	 */
475	method_node = this_walk_state->method_call_node;
476	if (!method_node) {
477		return_ACPI_STATUS(AE_NULL_ENTRY);
478	}
479
480	obj_desc = acpi_ns_get_attached_object(method_node);
481	if (!obj_desc) {
482		return_ACPI_STATUS(AE_NULL_OBJECT);
483	}
484
485	if (this_walk_state->num_operands < obj_desc->method.param_count) {
486		ACPI_ERROR((AE_INFO, "Missing argument(s) for method [%4.4s]",
487			    acpi_ut_get_node_name(method_node)));
488
489		return_ACPI_STATUS(AE_AML_TOO_FEW_ARGUMENTS);
490	}
491
492	else if (this_walk_state->num_operands > obj_desc->method.param_count) {
493		ACPI_ERROR((AE_INFO, "Too many arguments for method [%4.4s]",
494			    acpi_ut_get_node_name(method_node)));
495
496		return_ACPI_STATUS(AE_AML_TOO_MANY_ARGUMENTS);
497	}
498
499	/* Init for new method, possibly wait on method mutex */
500
501	status =
502	    acpi_ds_begin_method_execution(method_node, obj_desc,
503					   this_walk_state);
504	if (ACPI_FAILURE(status)) {
505		return_ACPI_STATUS(status);
506	}
507
508	/* Begin method parse/execution. Create a new walk state */
509
510	next_walk_state =
511	    acpi_ds_create_walk_state(obj_desc->method.owner_id, NULL, obj_desc,
512				      thread);
513	if (!next_walk_state) {
514		status = AE_NO_MEMORY;
515		goto cleanup;
516	}
517
518	/*
519	 * The resolved arguments were put on the previous walk state's operand
520	 * stack. Operands on the previous walk state stack always
521	 * start at index 0. Also, null terminate the list of arguments
522	 */
523	this_walk_state->operands[this_walk_state->num_operands] = NULL;
524
525	/*
526	 * Allocate and initialize the evaluation information block
527	 * TBD: this is somewhat inefficient, should change interface to
528	 * ds_init_aml_walk. For now, keeps this struct off the CPU stack
529	 */
530	info = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_evaluate_info));
531	if (!info) {
532		status = AE_NO_MEMORY;
533		goto pop_walk_state;
534	}
535
536	info->parameters = &this_walk_state->operands[0];
537
538	status = acpi_ds_init_aml_walk(next_walk_state, NULL, method_node,
539				       obj_desc->method.aml_start,
540				       obj_desc->method.aml_length, info,
541				       ACPI_IMODE_EXECUTE);
542
543	ACPI_FREE(info);
544	if (ACPI_FAILURE(status)) {
545		goto pop_walk_state;
546	}
547
548	next_walk_state->method_nesting_depth =
549	    this_walk_state->method_nesting_depth + 1;
550
551	/*
552	 * Delete the operands on the previous walkstate operand stack
553	 * (they were copied to new objects)
554	 */
555	acpi_ds_clear_operands(this_walk_state);
556
557	ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
558			  "**** Begin nested execution of [%4.4s] **** WalkState=%p\n",
559			  method_node->name.ascii, next_walk_state));
560
561	this_walk_state->method_pathname =
562	    acpi_ns_get_normalized_pathname(method_node, TRUE);
563	this_walk_state->method_is_nested = TRUE;
564
565	/* Optional object evaluation log */
566
567	ACPI_DEBUG_PRINT_RAW((ACPI_DB_EVALUATION,
568			      "%-26s:  %*s%s\n", "   Nested method call",
569			      next_walk_state->method_nesting_depth * 3, " ",
570			      &this_walk_state->method_pathname[1]));
571
572	/* Invoke an internal method if necessary */
573
574	if (obj_desc->method.info_flags & ACPI_METHOD_INTERNAL_ONLY) {
575		status =
576		    obj_desc->method.dispatch.implementation(next_walk_state);
577		if (status == AE_OK) {
578			status = AE_CTRL_TERMINATE;
579		}
580	}
581
582	return_ACPI_STATUS(status);
583
584pop_walk_state:
585
586	/* On error, pop the walk state to be deleted from thread */
587
588	acpi_ds_pop_walk_state(thread);
589
590cleanup:
591
592	/* On error, we must terminate the method properly */
593
594	acpi_ds_terminate_control_method(obj_desc, next_walk_state);
595	acpi_ds_delete_walk_state(next_walk_state);
596
597	return_ACPI_STATUS(status);
598}
599
600/*******************************************************************************
601 *
602 * FUNCTION:    acpi_ds_restart_control_method
603 *
604 * PARAMETERS:  walk_state          - State for preempted method (caller)
605 *              return_desc         - Return value from the called method
606 *
607 * RETURN:      Status
608 *
609 * DESCRIPTION: Restart a method that was preempted by another (nested) method
610 *              invocation. Handle the return value (if any) from the callee.
611 *
612 ******************************************************************************/
613
614acpi_status
615acpi_ds_restart_control_method(struct acpi_walk_state *walk_state,
616			       union acpi_operand_object *return_desc)
617{
618	acpi_status status;
619	int same_as_implicit_return;
620
621	ACPI_FUNCTION_TRACE_PTR(ds_restart_control_method, walk_state);
622
623	ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
624			  "****Restart [%4.4s] Op %p ReturnValueFromCallee %p\n",
625			  acpi_ut_get_node_name(walk_state->method_node),
626			  walk_state->method_call_op, return_desc));
627
628	ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
629			  "    ReturnFromThisMethodUsed?=%X ResStack %p Walk %p\n",
630			  walk_state->return_used,
631			  walk_state->results, walk_state));
632
633	/* Did the called method return a value? */
634
635	if (return_desc) {
636
637		/* Is the implicit return object the same as the return desc? */
638
639		same_as_implicit_return =
640		    (walk_state->implicit_return_obj == return_desc);
641
642		/* Are we actually going to use the return value? */
643
644		if (walk_state->return_used) {
645
646			/* Save the return value from the previous method */
647
648			status = acpi_ds_result_push(return_desc, walk_state);
649			if (ACPI_FAILURE(status)) {
650				acpi_ut_remove_reference(return_desc);
651				return_ACPI_STATUS(status);
652			}
653
654			/*
655			 * Save as THIS method's return value in case it is returned
656			 * immediately to yet another method
657			 */
658			walk_state->return_desc = return_desc;
659		}
660
661		/*
662		 * The following code is the optional support for the so-called
663		 * "implicit return". Some AML code assumes that the last value of the
664		 * method is "implicitly" returned to the caller, in the absence of an
665		 * explicit return value.
666		 *
667		 * Just save the last result of the method as the return value.
668		 *
669		 * NOTE: this is optional because the ASL language does not actually
670		 * support this behavior.
671		 */
672		else if (!acpi_ds_do_implicit_return
673			 (return_desc, walk_state, FALSE)
674			 || same_as_implicit_return) {
675			/*
676			 * Delete the return value if it will not be used by the
677			 * calling method or remove one reference if the explicit return
678			 * is the same as the implicit return value.
679			 */
680			acpi_ut_remove_reference(return_desc);
681		}
682	}
683
684	return_ACPI_STATUS(AE_OK);
685}
686
687/*******************************************************************************
688 *
689 * FUNCTION:    acpi_ds_terminate_control_method
690 *
691 * PARAMETERS:  method_desc         - Method object
692 *              walk_state          - State associated with the method
693 *
694 * RETURN:      None
695 *
696 * DESCRIPTION: Terminate a control method. Delete everything that the method
697 *              created, delete all locals and arguments, and delete the parse
698 *              tree if requested.
699 *
700 * MUTEX:       Interpreter is locked
701 *
702 ******************************************************************************/
703
704void
705acpi_ds_terminate_control_method(union acpi_operand_object *method_desc,
706				 struct acpi_walk_state *walk_state)
707{
708
709	ACPI_FUNCTION_TRACE_PTR(ds_terminate_control_method, walk_state);
710
711	/* method_desc is required, walk_state is optional */
712
713	if (!method_desc) {
714		return_VOID;
715	}
716
717	if (walk_state) {
718
719		/* Delete all arguments and locals */
720
721		acpi_ds_method_data_delete_all(walk_state);
722
723		/*
724		 * Delete any namespace objects created anywhere within the
725		 * namespace by the execution of this method. Unless:
726		 * 1) This method is a module-level executable code method, in which
727		 *    case we want make the objects permanent.
728		 * 2) There are other threads executing the method, in which case we
729		 *    will wait until the last thread has completed.
730		 */
731		if (!(method_desc->method.info_flags & ACPI_METHOD_MODULE_LEVEL)
732		    && (method_desc->method.thread_count == 1)) {
733
734			/* Delete any direct children of (created by) this method */
735
736			(void)acpi_ex_exit_interpreter();
737			acpi_ns_delete_namespace_subtree(walk_state->
738							 method_node);
739			(void)acpi_ex_enter_interpreter();
740
741			/*
742			 * Delete any objects that were created by this method
743			 * elsewhere in the namespace (if any were created).
744			 * Use of the ACPI_METHOD_MODIFIED_NAMESPACE optimizes the
745			 * deletion such that we don't have to perform an entire
746			 * namespace walk for every control method execution.
747			 */
748			if (method_desc->method.
749			    info_flags & ACPI_METHOD_MODIFIED_NAMESPACE) {
750				(void)acpi_ex_exit_interpreter();
751				acpi_ns_delete_namespace_by_owner(method_desc->
752								  method.
753								  owner_id);
754				(void)acpi_ex_enter_interpreter();
755				method_desc->method.info_flags &=
756				    ~ACPI_METHOD_MODIFIED_NAMESPACE;
757			}
758		}
759
760		/*
761		 * If method is serialized, release the mutex and restore the
762		 * current sync level for this thread
763		 */
764		if (method_desc->method.mutex) {
765
766			/* Acquisition Depth handles recursive calls */
767
768			method_desc->method.mutex->mutex.acquisition_depth--;
769			if (!method_desc->method.mutex->mutex.acquisition_depth) {
770				walk_state->thread->current_sync_level =
771				    method_desc->method.mutex->mutex.
772				    original_sync_level;
773
774				acpi_os_release_mutex(method_desc->method.
775						      mutex->mutex.os_mutex);
776				method_desc->method.mutex->mutex.thread_id = 0;
777			}
778		}
779	}
780
781	/* Decrement the thread count on the method */
782
783	if (method_desc->method.thread_count) {
784		method_desc->method.thread_count--;
785	} else {
786		ACPI_ERROR((AE_INFO, "Invalid zero thread count in method"));
787	}
788
789	/* Are there any other threads currently executing this method? */
790
791	if (method_desc->method.thread_count) {
792		/*
793		 * Additional threads. Do not release the owner_id in this case,
794		 * we immediately reuse it for the next thread executing this method
795		 */
796		ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
797				  "*** Completed execution of one thread, %u threads remaining\n",
798				  method_desc->method.thread_count));
799	} else {
800		/* This is the only executing thread for this method */
801
802		/*
803		 * Support to dynamically change a method from not_serialized to
804		 * Serialized if it appears that the method is incorrectly written and
805		 * does not support multiple thread execution. The best example of this
806		 * is if such a method creates namespace objects and blocks. A second
807		 * thread will fail with an AE_ALREADY_EXISTS exception.
808		 *
809		 * This code is here because we must wait until the last thread exits
810		 * before marking the method as serialized.
811		 */
812		if (method_desc->method.
813		    info_flags & ACPI_METHOD_SERIALIZED_PENDING) {
814			if (walk_state) {
815				ACPI_INFO(("Marking method %4.4s as Serialized "
816					   "because of AE_ALREADY_EXISTS error",
817					   walk_state->method_node->name.
818					   ascii));
819			}
820
821			/*
822			 * Method tried to create an object twice and was marked as
823			 * "pending serialized". The probable cause is that the method
824			 * cannot handle reentrancy.
825			 *
826			 * The method was created as not_serialized, but it tried to create
827			 * a named object and then blocked, causing the second thread
828			 * entrance to begin and then fail. Workaround this problem by
829			 * marking the method permanently as Serialized when the last
830			 * thread exits here.
831			 */
832			method_desc->method.info_flags &=
833			    ~ACPI_METHOD_SERIALIZED_PENDING;
834
835			method_desc->method.info_flags |=
836			    (ACPI_METHOD_SERIALIZED |
837			     ACPI_METHOD_IGNORE_SYNC_LEVEL);
838			method_desc->method.sync_level = 0;
839		}
840
841		/* No more threads, we can free the owner_id */
842
843		if (!
844		    (method_desc->method.
845		     info_flags & ACPI_METHOD_MODULE_LEVEL)) {
846			acpi_ut_release_owner_id(&method_desc->method.owner_id);
847		}
848	}
849
850	acpi_ex_stop_trace_method((struct acpi_namespace_node *)method_desc->
851				  method.node, method_desc, walk_state);
852
853	return_VOID;
854}