blob: 81a78ba843112d335613fc55a2d0d2ae39e6bc3f [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/******************************************************************************
2 *
3 * Module Name: dsmethod - Parser/Interpreter interface - control method parsing
4 *
5 *****************************************************************************/
6
7/*
Bob Moore25f044e2013-01-25 05:38:56 +00008 * Copyright (C) 2000 - 2013, Intel Corp.
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 * 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
Linus Torvalds1da177e2005-04-16 15:20:36 -070044#include <acpi/acpi.h>
Len Browne2f7a772009-01-09 00:30:03 -050045#include "accommon.h"
Len Browne2f7a772009-01-09 00:30:03 -050046#include "acdispat.h"
47#include "acinterp.h"
48#include "acnamesp.h"
Len Brown5b929aa2009-01-08 23:44:17 -050049#ifdef ACPI_DISASSEMBLER
Lv Zheng56324c12012-12-19 05:37:03 +000050#include "acdisasm.h"
Len Brown5b929aa2009-01-08 23:44:17 -050051#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070052
Linus Torvalds1da177e2005-04-16 15:20:36 -070053#define _COMPONENT ACPI_DISPATCHER
Len Brown4be44fc2005-08-05 00:44:28 -040054ACPI_MODULE_NAME("dsmethod")
Linus Torvalds1da177e2005-04-16 15:20:36 -070055
Bob Moore967440e32006-06-23 17:04:00 -040056/* Local prototypes */
57static acpi_status
58acpi_ds_create_method_mutex(union acpi_operand_object *method_desc);
59
Linus Torvalds1da177e2005-04-16 15:20:36 -070060/*******************************************************************************
61 *
Bob Mooredefba1d2005-12-16 17:05:00 -050062 * FUNCTION: acpi_ds_method_error
63 *
Bob Mooreba494be2012-07-12 09:40:10 +080064 * PARAMETERS: status - Execution status
Bob Mooredefba1d2005-12-16 17:05:00 -050065 * walk_state - Current state
66 *
67 * RETURN: Status
68 *
69 * DESCRIPTION: Called on method error. Invoke the global exception handler if
70 * present, dump the method data if the disassembler is configured
71 *
72 * Note: Allows the exception handler to change the status code
73 *
74 ******************************************************************************/
Bob Moore967440e32006-06-23 17:04:00 -040075
Bob Mooredefba1d2005-12-16 17:05:00 -050076acpi_status
77acpi_ds_method_error(acpi_status status, struct acpi_walk_state *walk_state)
78{
79 ACPI_FUNCTION_ENTRY();
80
81 /* Ignore AE_OK and control exception codes */
82
83 if (ACPI_SUCCESS(status) || (status & AE_CODE_CONTROL)) {
84 return (status);
85 }
86
87 /* Invoke the global exception handler */
88
89 if (acpi_gbl_exception_handler) {
Bob Moore52fc0b02006-10-02 00:00:00 -040090
Bob Mooredefba1d2005-12-16 17:05:00 -050091 /* Exit the interpreter, allow handler to execute methods */
92
93 acpi_ex_exit_interpreter();
94
95 /*
96 * Handler can map the exception code to anything it wants, including
97 * AE_OK, in which case the executing method will not be aborted.
98 */
99 status = acpi_gbl_exception_handler(status,
100 walk_state->method_node ?
101 walk_state->method_node->
102 name.integer : 0,
103 walk_state->opcode,
104 walk_state->aml_offset,
105 NULL);
Bob Mooreb7f9f042008-04-10 19:06:40 +0400106 acpi_ex_enter_interpreter();
Bob Mooredefba1d2005-12-16 17:05:00 -0500107 }
Lin Mingd8a0ec92008-09-27 11:50:24 +0800108
109 acpi_ds_clear_implicit_return(walk_state);
110
Bob Mooredefba1d2005-12-16 17:05:00 -0500111#ifdef ACPI_DISASSEMBLER
112 if (ACPI_FAILURE(status)) {
Bob Moore52fc0b02006-10-02 00:00:00 -0400113
Bob Mooredefba1d2005-12-16 17:05:00 -0500114 /* Display method locals/args if disassembler is present */
115
116 acpi_dm_dump_method_info(status, walk_state, walk_state->op);
117 }
118#endif
119
120 return (status);
121}
122
123/*******************************************************************************
124 *
Bob Moore967440e32006-06-23 17:04:00 -0400125 * FUNCTION: acpi_ds_create_method_mutex
126 *
127 * PARAMETERS: obj_desc - The method object
128 *
129 * RETURN: Status
130 *
131 * DESCRIPTION: Create a mutex object for a serialized control method
132 *
133 ******************************************************************************/
134
135static acpi_status
136acpi_ds_create_method_mutex(union acpi_operand_object *method_desc)
137{
138 union acpi_operand_object *mutex_desc;
139 acpi_status status;
140
Bob Mooref6dd9222006-07-07 20:44:38 -0400141 ACPI_FUNCTION_TRACE(ds_create_method_mutex);
Bob Moore967440e32006-06-23 17:04:00 -0400142
143 /* Create the new mutex object */
144
145 mutex_desc = acpi_ut_create_internal_object(ACPI_TYPE_MUTEX);
146 if (!mutex_desc) {
147 return_ACPI_STATUS(AE_NO_MEMORY);
148 }
149
150 /* Create the actual OS Mutex */
151
152 status = acpi_os_create_mutex(&mutex_desc->mutex.os_mutex);
153 if (ACPI_FAILURE(status)) {
Tim Gardner78d025e2012-12-31 00:06:56 +0000154 acpi_ut_delete_object_desc(mutex_desc);
Bob Moore967440e32006-06-23 17:04:00 -0400155 return_ACPI_STATUS(status);
156 }
157
158 mutex_desc->mutex.sync_level = method_desc->method.sync_level;
159 method_desc->method.mutex = mutex_desc;
160 return_ACPI_STATUS(AE_OK);
161}
162
163/*******************************************************************************
164 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165 * FUNCTION: acpi_ds_begin_method_execution
166 *
167 * PARAMETERS: method_node - Node of the method
168 * obj_desc - The method object
Bob Moore967440e32006-06-23 17:04:00 -0400169 * walk_state - current state, NULL if not yet executing
170 * a method.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 *
172 * RETURN: Status
173 *
Bob Moore73a30902012-10-31 02:26:55 +0000174 * DESCRIPTION: Prepare a method for execution. Parses the method if necessary,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175 * increments the thread count, and waits at the method semaphore
176 * for clearance to execute.
177 *
178 ******************************************************************************/
Bob Mooredefba1d2005-12-16 17:05:00 -0500179
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180acpi_status
Bob Moore967440e32006-06-23 17:04:00 -0400181acpi_ds_begin_method_execution(struct acpi_namespace_node *method_node,
182 union acpi_operand_object *obj_desc,
183 struct acpi_walk_state *walk_state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184{
Len Brown4be44fc2005-08-05 00:44:28 -0400185 acpi_status status = AE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186
Bob Mooreb229cf92006-04-21 17:15:00 -0400187 ACPI_FUNCTION_TRACE_PTR(ds_begin_method_execution, method_node);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188
189 if (!method_node) {
Len Brown4be44fc2005-08-05 00:44:28 -0400190 return_ACPI_STATUS(AE_NULL_ENTRY);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191 }
192
Robert Mooreaff8c272005-09-02 17:24:17 -0400193 /* Prevent wraparound of thread count */
194
195 if (obj_desc->method.thread_count == ACPI_UINT8_MAX) {
Bob Mooreb8e4d892006-01-27 16:43:00 -0500196 ACPI_ERROR((AE_INFO,
197 "Method reached maximum reentrancy limit (255)"));
Robert Mooreaff8c272005-09-02 17:24:17 -0400198 return_ACPI_STATUS(AE_AML_METHOD_LIMIT);
199 }
200
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201 /*
Bob Moore967440e32006-06-23 17:04:00 -0400202 * If this method is serialized, we need to acquire the method mutex.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 */
Lin Ming26294842011-01-12 09:19:43 +0800204 if (obj_desc->method.info_flags & ACPI_METHOD_SERIALIZED) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 /*
Bob Moore967440e32006-06-23 17:04:00 -0400206 * Create a mutex for the method if it is defined to be Serialized
207 * and a mutex has not already been created. We defer the mutex creation
208 * until a method is actually executed, to minimize the object count
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 */
Bob Moore967440e32006-06-23 17:04:00 -0400210 if (!obj_desc->method.mutex) {
211 status = acpi_ds_create_method_mutex(obj_desc);
212 if (ACPI_FAILURE(status)) {
213 return_ACPI_STATUS(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214 }
215 }
216
217 /*
Bob Moore967440e32006-06-23 17:04:00 -0400218 * The current_sync_level (per-thread) must be less than or equal to
219 * the sync level of the method. This mechanism provides some
220 * deadlock prevention
221 *
222 * Top-level method invocation has no walk state at this point
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223 */
Bob Moore967440e32006-06-23 17:04:00 -0400224 if (walk_state &&
225 (walk_state->thread->current_sync_level >
226 obj_desc->method.mutex->mutex.sync_level)) {
227 ACPI_ERROR((AE_INFO,
Bob Mooref6a22b02010-03-05 17:56:40 +0800228 "Cannot acquire Mutex for method [%4.4s], current SyncLevel is too large (%u)",
Bob Moore967440e32006-06-23 17:04:00 -0400229 acpi_ut_get_node_name(method_node),
230 walk_state->thread->current_sync_level));
231
232 return_ACPI_STATUS(AE_AML_MUTEX_ORDER);
Bob Mooreb229cf92006-04-21 17:15:00 -0400233 }
Bob Moore967440e32006-06-23 17:04:00 -0400234
235 /*
236 * Obtain the method mutex if necessary. Do not acquire mutex for a
237 * recursive call.
238 */
Len Brown262a7a22007-05-09 23:01:59 -0400239 if (!walk_state ||
Bob Mooreba886cd2008-04-10 19:06:37 +0400240 !obj_desc->method.mutex->mutex.thread_id ||
241 (walk_state->thread->thread_id !=
242 obj_desc->method.mutex->mutex.thread_id)) {
Bob Moore967440e32006-06-23 17:04:00 -0400243 /*
244 * Acquire the method mutex. This releases the interpreter if we
245 * block (and reacquires it before it returns)
246 */
247 status =
248 acpi_ex_system_wait_mutex(obj_desc->method.mutex->
249 mutex.os_mutex,
250 ACPI_WAIT_FOREVER);
251 if (ACPI_FAILURE(status)) {
252 return_ACPI_STATUS(status);
253 }
254
255 /* Update the mutex and walk info and save the original sync_level */
256
257 if (walk_state) {
258 obj_desc->method.mutex->mutex.
259 original_sync_level =
260 walk_state->thread->current_sync_level;
261
Bob Mooreba886cd2008-04-10 19:06:37 +0400262 obj_desc->method.mutex->mutex.thread_id =
263 walk_state->thread->thread_id;
Bob Moore967440e32006-06-23 17:04:00 -0400264 walk_state->thread->current_sync_level =
265 obj_desc->method.sync_level;
266 } else {
267 obj_desc->method.mutex->mutex.
268 original_sync_level =
269 obj_desc->method.mutex->mutex.sync_level;
270 }
271 }
272
273 /* Always increase acquisition depth */
274
275 obj_desc->method.mutex->mutex.acquisition_depth++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 }
277
278 /*
Robert Mooreaff8c272005-09-02 17:24:17 -0400279 * Allocate an Owner ID for this method, only if this is the first thread
280 * to begin concurrent execution. We only need one owner_id, even if the
281 * method is invoked recursively.
282 */
283 if (!obj_desc->method.owner_id) {
284 status = acpi_ut_allocate_owner_id(&obj_desc->method.owner_id);
285 if (ACPI_FAILURE(status)) {
Bob Mooreb229cf92006-04-21 17:15:00 -0400286 goto cleanup;
Robert Mooreaff8c272005-09-02 17:24:17 -0400287 }
288 }
289
290 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 * Increment the method parse tree thread count since it has been
292 * reentered one more time (even if it is the same thread)
293 */
294 obj_desc->method.thread_count++;
Lv Zheng9187a412013-10-31 09:30:28 +0800295 acpi_method_count++;
Len Brown4be44fc2005-08-05 00:44:28 -0400296 return_ACPI_STATUS(status);
Bob Mooreb229cf92006-04-21 17:15:00 -0400297
Lv Zheng10622bf2013-10-29 09:30:02 +0800298cleanup:
Bob Moore967440e32006-06-23 17:04:00 -0400299 /* On error, must release the method mutex (if present) */
Bob Mooreb229cf92006-04-21 17:15:00 -0400300
Bob Moore967440e32006-06-23 17:04:00 -0400301 if (obj_desc->method.mutex) {
302 acpi_os_release_mutex(obj_desc->method.mutex->mutex.os_mutex);
Bob Mooreb229cf92006-04-21 17:15:00 -0400303 }
304 return_ACPI_STATUS(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305}
306
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307/*******************************************************************************
308 *
309 * FUNCTION: acpi_ds_call_control_method
310 *
Bob Mooreba494be2012-07-12 09:40:10 +0800311 * PARAMETERS: thread - Info for this thread
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312 * this_walk_state - Current walk state
Bob Mooreba494be2012-07-12 09:40:10 +0800313 * op - Current Op to be walked
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 *
315 * RETURN: Status
316 *
317 * DESCRIPTION: Transfer execution to a called control method
318 *
319 ******************************************************************************/
320
321acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400322acpi_ds_call_control_method(struct acpi_thread_state *thread,
323 struct acpi_walk_state *this_walk_state,
324 union acpi_parse_object *op)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325{
Len Brown4be44fc2005-08-05 00:44:28 -0400326 acpi_status status;
327 struct acpi_namespace_node *method_node;
328 struct acpi_walk_state *next_walk_state = NULL;
329 union acpi_operand_object *obj_desc;
Bob Moore41195322006-05-26 16:36:00 -0400330 struct acpi_evaluate_info *info;
Len Brown4be44fc2005-08-05 00:44:28 -0400331 u32 i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332
Bob Mooreb229cf92006-04-21 17:15:00 -0400333 ACPI_FUNCTION_TRACE_PTR(ds_call_control_method, this_walk_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334
Len Brown4be44fc2005-08-05 00:44:28 -0400335 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
Valery Podrezov9bc75cf2007-02-02 19:48:21 +0300336 "Calling method %p, currentstate=%p\n",
Len Brown4be44fc2005-08-05 00:44:28 -0400337 this_walk_state->prev_op, this_walk_state));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338
339 /*
340 * Get the namespace entry for the control method we are about to call
341 */
342 method_node = this_walk_state->method_call_node;
343 if (!method_node) {
Len Brown4be44fc2005-08-05 00:44:28 -0400344 return_ACPI_STATUS(AE_NULL_ENTRY);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 }
346
Len Brown4be44fc2005-08-05 00:44:28 -0400347 obj_desc = acpi_ns_get_attached_object(method_node);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348 if (!obj_desc) {
Len Brown4be44fc2005-08-05 00:44:28 -0400349 return_ACPI_STATUS(AE_NULL_OBJECT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350 }
351
Bob Moore967440e32006-06-23 17:04:00 -0400352 /* Init for new method, possibly wait on method mutex */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353
Len Brown4be44fc2005-08-05 00:44:28 -0400354 status = acpi_ds_begin_method_execution(method_node, obj_desc,
Bob Moore967440e32006-06-23 17:04:00 -0400355 this_walk_state);
Len Brown4be44fc2005-08-05 00:44:28 -0400356 if (ACPI_FAILURE(status)) {
Bob Mooreb229cf92006-04-21 17:15:00 -0400357 return_ACPI_STATUS(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 }
359
Valery Podrezov9bc75cf2007-02-02 19:48:21 +0300360 /* Begin method parse/execution. Create a new walk state */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361
Len Brown4be44fc2005-08-05 00:44:28 -0400362 next_walk_state = acpi_ds_create_walk_state(obj_desc->method.owner_id,
363 NULL, obj_desc, thread);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 if (!next_walk_state) {
365 status = AE_NO_MEMORY;
366 goto cleanup;
367 }
Bob Mooreb229cf92006-04-21 17:15:00 -0400368
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 /*
370 * The resolved arguments were put on the previous walk state's operand
Robert Mooreaff8c272005-09-02 17:24:17 -0400371 * stack. Operands on the previous walk state stack always
372 * start at index 0. Also, null terminate the list of arguments
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373 */
Len Brown4be44fc2005-08-05 00:44:28 -0400374 this_walk_state->operands[this_walk_state->num_operands] = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375
Bob Moore41195322006-05-26 16:36:00 -0400376 /*
377 * Allocate and initialize the evaluation information block
378 * TBD: this is somewhat inefficient, should change interface to
379 * ds_init_aml_walk. For now, keeps this struct off the CPU stack
380 */
381 info = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_evaluate_info));
382 if (!info) {
Jesper Juhl22715822012-12-19 05:37:47 +0000383 status = AE_NO_MEMORY;
384 goto cleanup;
Bob Moore41195322006-05-26 16:36:00 -0400385 }
386
387 info->parameters = &this_walk_state->operands[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388
Len Brown4be44fc2005-08-05 00:44:28 -0400389 status = acpi_ds_init_aml_walk(next_walk_state, NULL, method_node,
390 obj_desc->method.aml_start,
Bob Mooreec3153f2007-02-02 19:48:21 +0300391 obj_desc->method.aml_length, info,
392 ACPI_IMODE_EXECUTE);
Bob Moore41195322006-05-26 16:36:00 -0400393
394 ACPI_FREE(info);
Len Brown4be44fc2005-08-05 00:44:28 -0400395 if (ACPI_FAILURE(status)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 goto cleanup;
397 }
398
399 /*
400 * Delete the operands on the previous walkstate operand stack
401 * (they were copied to new objects)
402 */
403 for (i = 0; i < obj_desc->method.param_count; i++) {
Len Brown4be44fc2005-08-05 00:44:28 -0400404 acpi_ut_remove_reference(this_walk_state->operands[i]);
405 this_walk_state->operands[i] = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 }
407
408 /* Clear the operand stack */
409
410 this_walk_state->num_operands = 0;
411
Len Brown4be44fc2005-08-05 00:44:28 -0400412 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
Valery Podrezov9bc75cf2007-02-02 19:48:21 +0300413 "**** Begin nested execution of [%4.4s] **** WalkState=%p\n",
414 method_node->name.ascii, next_walk_state));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415
Bob Mooreb229cf92006-04-21 17:15:00 -0400416 /* Invoke an internal method if necessary */
417
Lin Ming26294842011-01-12 09:19:43 +0800418 if (obj_desc->method.info_flags & ACPI_METHOD_INTERNAL_ONLY) {
419 status =
420 obj_desc->method.dispatch.implementation(next_walk_state);
Bob Moorea8fadc92008-11-13 09:45:35 +0800421 if (status == AE_OK) {
422 status = AE_CTRL_TERMINATE;
423 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 }
425
Robert Mooreaff8c272005-09-02 17:24:17 -0400426 return_ACPI_STATUS(status);
427
Lv Zheng10622bf2013-10-29 09:30:02 +0800428cleanup:
Robert Mooreaff8c272005-09-02 17:24:17 -0400429
Bob Mooreb229cf92006-04-21 17:15:00 -0400430 /* On error, we must terminate the method properly */
431
432 acpi_ds_terminate_control_method(obj_desc, next_walk_state);
433 if (next_walk_state) {
434 acpi_ds_delete_walk_state(next_walk_state);
Robert Mooreaff8c272005-09-02 17:24:17 -0400435 }
Len Browna94f1882005-09-03 00:09:12 -0400436
Len Brown4be44fc2005-08-05 00:44:28 -0400437 return_ACPI_STATUS(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438}
439
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440/*******************************************************************************
441 *
442 * FUNCTION: acpi_ds_restart_control_method
443 *
444 * PARAMETERS: walk_state - State for preempted method (caller)
445 * return_desc - Return value from the called method
446 *
447 * RETURN: Status
448 *
449 * DESCRIPTION: Restart a method that was preempted by another (nested) method
Bob Moore73a30902012-10-31 02:26:55 +0000450 * invocation. Handle the return value (if any) from the callee.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 *
452 ******************************************************************************/
453
454acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400455acpi_ds_restart_control_method(struct acpi_walk_state *walk_state,
456 union acpi_operand_object *return_desc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457{
Len Brown4be44fc2005-08-05 00:44:28 -0400458 acpi_status status;
Bob Moore958dd242006-05-12 17:12:00 -0400459 int same_as_implicit_return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460
Bob Mooreb229cf92006-04-21 17:15:00 -0400461 ACPI_FUNCTION_TRACE_PTR(ds_restart_control_method, walk_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462
Len Brown4be44fc2005-08-05 00:44:28 -0400463 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
Bob Mooreb229cf92006-04-21 17:15:00 -0400464 "****Restart [%4.4s] Op %p ReturnValueFromCallee %p\n",
Bob Mooref6dd9222006-07-07 20:44:38 -0400465 acpi_ut_get_node_name(walk_state->method_node),
Len Brown4be44fc2005-08-05 00:44:28 -0400466 walk_state->method_call_op, return_desc));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467
Len Brown4be44fc2005-08-05 00:44:28 -0400468 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
Bob Mooreb229cf92006-04-21 17:15:00 -0400469 " ReturnFromThisMethodUsed?=%X ResStack %p Walk %p\n",
Len Brown4be44fc2005-08-05 00:44:28 -0400470 walk_state->return_used,
471 walk_state->results, walk_state));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472
473 /* Did the called method return a value? */
474
475 if (return_desc) {
Bob Moore52fc0b02006-10-02 00:00:00 -0400476
Bob Moore958dd242006-05-12 17:12:00 -0400477 /* Is the implicit return object the same as the return desc? */
478
479 same_as_implicit_return =
480 (walk_state->implicit_return_obj == return_desc);
481
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482 /* Are we actually going to use the return value? */
483
484 if (walk_state->return_used) {
Bob Moore52fc0b02006-10-02 00:00:00 -0400485
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486 /* Save the return value from the previous method */
487
Len Brown4be44fc2005-08-05 00:44:28 -0400488 status = acpi_ds_result_push(return_desc, walk_state);
489 if (ACPI_FAILURE(status)) {
490 acpi_ut_remove_reference(return_desc);
491 return_ACPI_STATUS(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492 }
493
494 /*
495 * Save as THIS method's return value in case it is returned
496 * immediately to yet another method
497 */
498 walk_state->return_desc = return_desc;
499 }
500
501 /*
Bob Moore958dd242006-05-12 17:12:00 -0400502 * The following code is the optional support for the so-called
503 * "implicit return". Some AML code assumes that the last value of the
504 * method is "implicitly" returned to the caller, in the absence of an
505 * explicit return value.
506 *
507 * Just save the last result of the method as the return value.
508 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 * NOTE: this is optional because the ASL language does not actually
510 * support this behavior.
511 */
Len Brown4be44fc2005-08-05 00:44:28 -0400512 else if (!acpi_ds_do_implicit_return
Bob Moore958dd242006-05-12 17:12:00 -0400513 (return_desc, walk_state, FALSE)
514 || same_as_implicit_return) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515 /*
516 * Delete the return value if it will not be used by the
Bob Moore958dd242006-05-12 17:12:00 -0400517 * calling method or remove one reference if the explicit return
518 * is the same as the implicit return value.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519 */
Len Brown4be44fc2005-08-05 00:44:28 -0400520 acpi_ut_remove_reference(return_desc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 }
522 }
523
Len Brown4be44fc2005-08-05 00:44:28 -0400524 return_ACPI_STATUS(AE_OK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525}
526
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527/*******************************************************************************
528 *
529 * FUNCTION: acpi_ds_terminate_control_method
530 *
Bob Mooreb229cf92006-04-21 17:15:00 -0400531 * PARAMETERS: method_desc - Method object
532 * walk_state - State associated with the method
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533 *
Robert Mooreaff8c272005-09-02 17:24:17 -0400534 * RETURN: None
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535 *
Bob Moore73a30902012-10-31 02:26:55 +0000536 * DESCRIPTION: Terminate a control method. Delete everything that the method
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537 * created, delete all locals and arguments, and delete the parse
538 * tree if requested.
539 *
Bob Moore967440e32006-06-23 17:04:00 -0400540 * MUTEX: Interpreter is locked
541 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 ******************************************************************************/
543
Bob Mooreb229cf92006-04-21 17:15:00 -0400544void
545acpi_ds_terminate_control_method(union acpi_operand_object *method_desc,
546 struct acpi_walk_state *walk_state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548
Bob Mooreb229cf92006-04-21 17:15:00 -0400549 ACPI_FUNCTION_TRACE_PTR(ds_terminate_control_method, walk_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550
Bob Mooreb229cf92006-04-21 17:15:00 -0400551 /* method_desc is required, walk_state is optional */
552
553 if (!method_desc) {
Robert Mooreaff8c272005-09-02 17:24:17 -0400554 return_VOID;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555 }
556
Bob Mooreb229cf92006-04-21 17:15:00 -0400557 if (walk_state) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558
Bob Mooreb229cf92006-04-21 17:15:00 -0400559 /* Delete all arguments and locals */
560
561 acpi_ds_method_data_delete_all(walk_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562
Bob Mooreb7f9f042008-04-10 19:06:40 +0400563 /*
564 * If method is serialized, release the mutex and restore the
565 * current sync level for this thread
566 */
567 if (method_desc->method.mutex) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568
Bob Mooreb7f9f042008-04-10 19:06:40 +0400569 /* Acquisition Depth handles recursive calls */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570
Bob Mooreb7f9f042008-04-10 19:06:40 +0400571 method_desc->method.mutex->mutex.acquisition_depth--;
572 if (!method_desc->method.mutex->mutex.acquisition_depth) {
573 walk_state->thread->current_sync_level =
574 method_desc->method.mutex->mutex.
575 original_sync_level;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576
Bob Mooreb7f9f042008-04-10 19:06:40 +0400577 acpi_os_release_mutex(method_desc->method.
578 mutex->mutex.os_mutex);
Lin Ming28eb3fc2010-09-15 13:55:13 +0800579 method_desc->method.mutex->mutex.thread_id = 0;
Bob Mooreb7f9f042008-04-10 19:06:40 +0400580 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582
Bob Mooreb229cf92006-04-21 17:15:00 -0400583 /*
Lin Ming7f0c8262009-08-13 14:03:15 +0800584 * Delete any namespace objects created anywhere within the
Lin Ming26294842011-01-12 09:19:43 +0800585 * namespace by the execution of this method. Unless:
586 * 1) This method is a module-level executable code method, in which
587 * case we want make the objects permanent.
588 * 2) There are other threads executing the method, in which case we
589 * will wait until the last thread has completed.
Bob Mooreb229cf92006-04-21 17:15:00 -0400590 */
Lin Ming26294842011-01-12 09:19:43 +0800591 if (!(method_desc->method.info_flags & ACPI_METHOD_MODULE_LEVEL)
592 && (method_desc->method.thread_count == 1)) {
Alexey Starikovskiya9fc0312010-05-26 13:59:51 +0800593
594 /* Delete any direct children of (created by) this method */
595
596 acpi_ns_delete_namespace_subtree(walk_state->
597 method_node);
598
599 /*
600 * Delete any objects that were created by this method
601 * elsewhere in the namespace (if any were created).
Lin Ming26294842011-01-12 09:19:43 +0800602 * Use of the ACPI_METHOD_MODIFIED_NAMESPACE optimizes the
603 * deletion such that we don't have to perform an entire
604 * namespace walk for every control method execution.
Alexey Starikovskiya9fc0312010-05-26 13:59:51 +0800605 */
606 if (method_desc->method.
Lin Ming26294842011-01-12 09:19:43 +0800607 info_flags & ACPI_METHOD_MODIFIED_NAMESPACE) {
Alexey Starikovskiya9fc0312010-05-26 13:59:51 +0800608 acpi_ns_delete_namespace_by_owner(method_desc->
609 method.
610 owner_id);
Lin Ming26294842011-01-12 09:19:43 +0800611 method_desc->method.info_flags &=
612 ~ACPI_METHOD_MODIFIED_NAMESPACE;
Alexey Starikovskiya9fc0312010-05-26 13:59:51 +0800613 }
Lin Ming7f0c8262009-08-13 14:03:15 +0800614 }
Bob Moore28f55eb2005-12-02 18:27:00 -0500615 }
616
Bob Mooreb229cf92006-04-21 17:15:00 -0400617 /* Decrement the thread count on the method */
Bob Moore28f55eb2005-12-02 18:27:00 -0500618
Bob Mooreb229cf92006-04-21 17:15:00 -0400619 if (method_desc->method.thread_count) {
620 method_desc->method.thread_count--;
621 } else {
622 ACPI_ERROR((AE_INFO, "Invalid zero thread count in method"));
623 }
Bob Moore28f55eb2005-12-02 18:27:00 -0500624
625 /* Are there any other threads currently executing this method? */
626
Bob Mooreb229cf92006-04-21 17:15:00 -0400627 if (method_desc->method.thread_count) {
Bob Moore28f55eb2005-12-02 18:27:00 -0500628 /*
629 * Additional threads. Do not release the owner_id in this case,
630 * we immediately reuse it for the next thread executing this method
631 */
Len Brown4be44fc2005-08-05 00:44:28 -0400632 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
Bob Mooreb27d6592010-05-26 11:47:13 +0800633 "*** Completed execution of one thread, %u threads remaining\n",
Bob Mooreb229cf92006-04-21 17:15:00 -0400634 method_desc->method.thread_count));
Bob Moore28f55eb2005-12-02 18:27:00 -0500635 } else {
636 /* This is the only executing thread for this method */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638 /*
639 * Support to dynamically change a method from not_serialized to
Bob Moore28f55eb2005-12-02 18:27:00 -0500640 * Serialized if it appears that the method is incorrectly written and
Bob Moore967440e32006-06-23 17:04:00 -0400641 * does not support multiple thread execution. The best example of this
642 * is if such a method creates namespace objects and blocks. A second
Lin Ming26294842011-01-12 09:19:43 +0800643 * thread will fail with an AE_ALREADY_EXISTS exception.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644 *
645 * This code is here because we must wait until the last thread exits
Lin Ming26294842011-01-12 09:19:43 +0800646 * before marking the method as serialized.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647 */
Lin Ming26294842011-01-12 09:19:43 +0800648 if (method_desc->method.
649 info_flags & ACPI_METHOD_SERIALIZED_PENDING) {
650 if (walk_state) {
651 ACPI_INFO((AE_INFO,
652 "Marking method %4.4s as Serialized because of AE_ALREADY_EXISTS error",
653 walk_state->method_node->name.
654 ascii));
655 }
656
657 /*
658 * Method tried to create an object twice and was marked as
659 * "pending serialized". The probable cause is that the method
660 * cannot handle reentrancy.
661 *
662 * The method was created as not_serialized, but it tried to create
663 * a named object and then blocked, causing the second thread
664 * entrance to begin and then fail. Workaround this problem by
665 * marking the method permanently as Serialized when the last
666 * thread exits here.
667 */
668 method_desc->method.info_flags &=
669 ~ACPI_METHOD_SERIALIZED_PENDING;
670 method_desc->method.info_flags |=
671 ACPI_METHOD_SERIALIZED;
672 method_desc->method.sync_level = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673 }
674
Bob Moore28f55eb2005-12-02 18:27:00 -0500675 /* No more threads, we can free the owner_id */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676
Lin Ming26294842011-01-12 09:19:43 +0800677 if (!
678 (method_desc->method.
679 info_flags & ACPI_METHOD_MODULE_LEVEL)) {
Lin Ming7f0c8262009-08-13 14:03:15 +0800680 acpi_ut_release_owner_id(&method_desc->method.owner_id);
681 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682 }
Len Browna94f1882005-09-03 00:09:12 -0400683
Robert Mooreaff8c272005-09-02 17:24:17 -0400684 return_VOID;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685}