Diff markup
1 /********************************************* 1 /******************************************************************************
2 * 2 *
3 * Module Name: dsmethod - Parser/Interpreter 3 * Module Name: dsmethod - Parser/Interpreter interface - control method parsing
4 * 4 *
5 ********************************************* 5 *****************************************************************************/
6 6
7 /* 7 /*
8 * Copyright (C) 2000 - 2007, R. Byron Moore 8 * Copyright (C) 2000 - 2007, R. Byron Moore
9 * All rights reserved. 9 * All rights reserved.
10 * 10 *
11 * Redistribution and use in source and binary 11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that t 12 * modification, are permitted provided that the following conditions
13 * are met: 13 * are met:
14 * 1. Redistributions of source code must reta 14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions, and the 15 * notice, this list of conditions, and the following disclaimer,
16 * without modification. 16 * without modification.
17 * 2. Redistributions in binary form must repr 17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18 * substantially similar to the "NO WARRANT 18 * substantially similar to the "NO WARRANTY" disclaimer below
19 * ("Disclaimer") and any redistribution mu 19 * ("Disclaimer") and any redistribution must be conditioned upon
20 * including a substantially similar Discla 20 * including a substantially similar Disclaimer requirement for further
21 * binary redistribution. 21 * binary redistribution.
22 * 3. Neither the names of the above-listed co 22 * 3. Neither the names of the above-listed copyright holders nor the names
23 * of any contributors may be used to endor 23 * of any contributors may be used to endorse or promote products derived
24 * from this software without specific prio 24 * from this software without specific prior written permission.
25 * 25 *
26 * Alternatively, this software may be distrib 26 * Alternatively, this software may be distributed under the terms of the
27 * GNU General Public License ("GPL") version 27 * GNU General Public License ("GPL") version 2 as published by the Free
28 * Software Foundation. 28 * Software Foundation.
29 * 29 *
30 * NO WARRANTY 30 * NO WARRANTY
31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT 31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTI 32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCH 33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO 34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECI 35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PRO 36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILI 38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIG 39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, 40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 * POSSIBILITY OF SUCH DAMAGES. 41 * POSSIBILITY OF SUCH DAMAGES.
42 */ 42 */
43 43
44 #include <acpi/acpi.h> 44 #include <acpi/acpi.h>
45 #include <acpi/acparser.h> 45 #include <acpi/acparser.h>
46 #include <acpi/amlcode.h> 46 #include <acpi/amlcode.h>
47 #include <acpi/acdispat.h> 47 #include <acpi/acdispat.h>
48 #include <acpi/acinterp.h> 48 #include <acpi/acinterp.h>
49 #include <acpi/acnamesp.h> 49 #include <acpi/acnamesp.h>
50 #include <acpi/acdisasm.h> 50 #include <acpi/acdisasm.h>
51 51
52 #define _COMPONENT ACPI_DISPATCHER 52 #define _COMPONENT ACPI_DISPATCHER
53 ACPI_MODULE_NAME("dsmethod") 53 ACPI_MODULE_NAME("dsmethod")
54 54
55 /* Local prototypes */ 55 /* Local prototypes */
56 static acpi_status 56 static acpi_status
57 acpi_ds_create_method_mutex(union acpi_operand 57 acpi_ds_create_method_mutex(union acpi_operand_object *method_desc);
58 58
59 /********************************************* 59 /*******************************************************************************
60 * 60 *
61 * FUNCTION: acpi_ds_method_error 61 * FUNCTION: acpi_ds_method_error
62 * 62 *
63 * PARAMETERS: Status - Execution st 63 * PARAMETERS: Status - Execution status
64 * walk_state - Current stat 64 * walk_state - Current state
65 * 65 *
66 * RETURN: Status 66 * RETURN: Status
67 * 67 *
68 * DESCRIPTION: Called on method error. Invoke 68 * DESCRIPTION: Called on method error. Invoke the global exception handler if
69 * present, dump the method data 69 * present, dump the method data if the disassembler is configured
70 * 70 *
71 * Note: Allows the exception han 71 * Note: Allows the exception handler to change the status code
72 * 72 *
73 ********************************************* 73 ******************************************************************************/
74 74
75 acpi_status 75 acpi_status
76 acpi_ds_method_error(acpi_status status, struc 76 acpi_ds_method_error(acpi_status status, struct acpi_walk_state *walk_state)
77 { 77 {
78 ACPI_FUNCTION_ENTRY(); 78 ACPI_FUNCTION_ENTRY();
79 79
80 /* Ignore AE_OK and control exception 80 /* Ignore AE_OK and control exception codes */
81 81
82 if (ACPI_SUCCESS(status) || (status & 82 if (ACPI_SUCCESS(status) || (status & AE_CODE_CONTROL)) {
83 return (status); 83 return (status);
84 } 84 }
85 85
86 /* Invoke the global exception handler 86 /* Invoke the global exception handler */
87 87
88 if (acpi_gbl_exception_handler) { 88 if (acpi_gbl_exception_handler) {
89 89
90 /* Exit the interpreter, allow 90 /* Exit the interpreter, allow handler to execute methods */
91 91
92 acpi_ex_exit_interpreter(); 92 acpi_ex_exit_interpreter();
93 93
94 /* 94 /*
95 * Handler can map the excepti 95 * Handler can map the exception code to anything it wants, including
96 * AE_OK, in which case the ex 96 * AE_OK, in which case the executing method will not be aborted.
97 */ 97 */
98 status = acpi_gbl_exception_ha 98 status = acpi_gbl_exception_handler(status,
99 99 walk_state->method_node ?
100 100 walk_state->method_node->
101 101 name.integer : 0,
102 102 walk_state->opcode,
103 103 walk_state->aml_offset,
104 104 NULL);
105 (void)acpi_ex_enter_interprete 105 (void)acpi_ex_enter_interpreter();
106 } 106 }
107 #ifdef ACPI_DISASSEMBLER 107 #ifdef ACPI_DISASSEMBLER
108 if (ACPI_FAILURE(status)) { 108 if (ACPI_FAILURE(status)) {
109 109
110 /* Display method locals/args 110 /* Display method locals/args if disassembler is present */
111 111
112 acpi_dm_dump_method_info(statu 112 acpi_dm_dump_method_info(status, walk_state, walk_state->op);
113 } 113 }
114 #endif 114 #endif
115 115
116 return (status); 116 return (status);
117 } 117 }
118 118
119 /********************************************* 119 /*******************************************************************************
120 * 120 *
121 * FUNCTION: acpi_ds_create_method_mutex 121 * FUNCTION: acpi_ds_create_method_mutex
122 * 122 *
123 * PARAMETERS: obj_desc - The meth 123 * PARAMETERS: obj_desc - The method object
124 * 124 *
125 * RETURN: Status 125 * RETURN: Status
126 * 126 *
127 * DESCRIPTION: Create a mutex object for a se 127 * DESCRIPTION: Create a mutex object for a serialized control method
128 * 128 *
129 ********************************************* 129 ******************************************************************************/
130 130
131 static acpi_status 131 static acpi_status
132 acpi_ds_create_method_mutex(union acpi_operand 132 acpi_ds_create_method_mutex(union acpi_operand_object *method_desc)
133 { 133 {
134 union acpi_operand_object *mutex_desc; 134 union acpi_operand_object *mutex_desc;
135 acpi_status status; 135 acpi_status status;
136 136
137 ACPI_FUNCTION_TRACE(ds_create_method_m 137 ACPI_FUNCTION_TRACE(ds_create_method_mutex);
138 138
139 /* Create the new mutex object */ 139 /* Create the new mutex object */
140 140
141 mutex_desc = acpi_ut_create_internal_o 141 mutex_desc = acpi_ut_create_internal_object(ACPI_TYPE_MUTEX);
142 if (!mutex_desc) { 142 if (!mutex_desc) {
143 return_ACPI_STATUS(AE_NO_MEMOR 143 return_ACPI_STATUS(AE_NO_MEMORY);
144 } 144 }
145 145
146 /* Create the actual OS Mutex */ 146 /* Create the actual OS Mutex */
147 147
148 status = acpi_os_create_mutex(&mutex_d 148 status = acpi_os_create_mutex(&mutex_desc->mutex.os_mutex);
149 if (ACPI_FAILURE(status)) { 149 if (ACPI_FAILURE(status)) {
150 return_ACPI_STATUS(status); 150 return_ACPI_STATUS(status);
151 } 151 }
152 152
153 mutex_desc->mutex.sync_level = method_ 153 mutex_desc->mutex.sync_level = method_desc->method.sync_level;
154 method_desc->method.mutex = mutex_desc 154 method_desc->method.mutex = mutex_desc;
155 return_ACPI_STATUS(AE_OK); 155 return_ACPI_STATUS(AE_OK);
156 } 156 }
157 157
158 /********************************************* 158 /*******************************************************************************
159 * 159 *
160 * FUNCTION: acpi_ds_begin_method_execution 160 * FUNCTION: acpi_ds_begin_method_execution
161 * 161 *
162 * PARAMETERS: method_node - Node of 162 * PARAMETERS: method_node - Node of the method
163 * obj_desc - The meth 163 * obj_desc - The method object
164 * walk_state - current 164 * walk_state - current state, NULL if not yet executing
165 * a method 165 * a method.
166 * 166 *
167 * RETURN: Status 167 * RETURN: Status
168 * 168 *
169 * DESCRIPTION: Prepare a method for execution 169 * DESCRIPTION: Prepare a method for execution. Parses the method if necessary,
170 * increments the thread count, a 170 * increments the thread count, and waits at the method semaphore
171 * for clearance to execute. 171 * for clearance to execute.
172 * 172 *
173 ********************************************* 173 ******************************************************************************/
174 174
175 acpi_status 175 acpi_status
176 acpi_ds_begin_method_execution(struct acpi_nam 176 acpi_ds_begin_method_execution(struct acpi_namespace_node *method_node,
177 union acpi_oper 177 union acpi_operand_object *obj_desc,
178 struct acpi_wal 178 struct acpi_walk_state *walk_state)
179 { 179 {
180 acpi_status status = AE_OK; 180 acpi_status status = AE_OK;
181 181
182 ACPI_FUNCTION_TRACE_PTR(ds_begin_metho 182 ACPI_FUNCTION_TRACE_PTR(ds_begin_method_execution, method_node);
183 183
184 if (!method_node) { 184 if (!method_node) {
185 return_ACPI_STATUS(AE_NULL_ENT 185 return_ACPI_STATUS(AE_NULL_ENTRY);
186 } 186 }
187 187
188 /* Prevent wraparound of thread count 188 /* Prevent wraparound of thread count */
189 189
190 if (obj_desc->method.thread_count == A 190 if (obj_desc->method.thread_count == ACPI_UINT8_MAX) {
191 ACPI_ERROR((AE_INFO, 191 ACPI_ERROR((AE_INFO,
192 "Method reached ma 192 "Method reached maximum reentrancy limit (255)"));
193 return_ACPI_STATUS(AE_AML_METH 193 return_ACPI_STATUS(AE_AML_METHOD_LIMIT);
194 } 194 }
195 195
196 /* 196 /*
197 * If this method is serialized, we ne 197 * If this method is serialized, we need to acquire the method mutex.
198 */ 198 */
199 if (obj_desc->method.method_flags & AM 199 if (obj_desc->method.method_flags & AML_METHOD_SERIALIZED) {
200 /* 200 /*
201 * Create a mutex for the meth 201 * Create a mutex for the method if it is defined to be Serialized
202 * and a mutex has not already 202 * and a mutex has not already been created. We defer the mutex creation
203 * until a method is actually 203 * until a method is actually executed, to minimize the object count
204 */ 204 */
205 if (!obj_desc->method.mutex) { 205 if (!obj_desc->method.mutex) {
206 status = acpi_ds_creat 206 status = acpi_ds_create_method_mutex(obj_desc);
207 if (ACPI_FAILURE(statu 207 if (ACPI_FAILURE(status)) {
208 return_ACPI_ST 208 return_ACPI_STATUS(status);
209 } 209 }
210 } 210 }
211 211
212 /* 212 /*
213 * The current_sync_level (per 213 * The current_sync_level (per-thread) must be less than or equal to
214 * the sync level of the metho 214 * the sync level of the method. This mechanism provides some
215 * deadlock prevention 215 * deadlock prevention
216 * 216 *
217 * Top-level method invocation 217 * Top-level method invocation has no walk state at this point
218 */ 218 */
219 if (walk_state && 219 if (walk_state &&
220 (walk_state->thread->curre 220 (walk_state->thread->current_sync_level >
221 obj_desc->method.mutex->m 221 obj_desc->method.mutex->mutex.sync_level)) {
222 ACPI_ERROR((AE_INFO, 222 ACPI_ERROR((AE_INFO,
223 "Cannot ac 223 "Cannot acquire Mutex for method [%4.4s], current SyncLevel is too large (%d)",
224 acpi_ut_ge 224 acpi_ut_get_node_name(method_node),
225 walk_state 225 walk_state->thread->current_sync_level));
226 226
227 return_ACPI_STATUS(AE_ 227 return_ACPI_STATUS(AE_AML_MUTEX_ORDER);
228 } 228 }
229 229
230 /* 230 /*
231 * Obtain the method mutex if 231 * Obtain the method mutex if necessary. Do not acquire mutex for a
232 * recursive call. 232 * recursive call.
233 */ 233 */
234 if (!walk_state || 234 if (!walk_state ||
235 !obj_desc->method.mutex->m 235 !obj_desc->method.mutex->mutex.owner_thread ||
236 (walk_state->thread != 236 (walk_state->thread !=
237 obj_desc->method.mutex->m 237 obj_desc->method.mutex->mutex.owner_thread)) {
238 /* 238 /*
239 * Acquire the method 239 * Acquire the method mutex. This releases the interpreter if we
240 * block (and reacquir 240 * block (and reacquires it before it returns)
241 */ 241 */
242 status = 242 status =
243 acpi_ex_system_wai 243 acpi_ex_system_wait_mutex(obj_desc->method.mutex->
244 244 mutex.os_mutex,
245 245 ACPI_WAIT_FOREVER);
246 if (ACPI_FAILURE(statu 246 if (ACPI_FAILURE(status)) {
247 return_ACPI_ST 247 return_ACPI_STATUS(status);
248 } 248 }
249 249
250 /* Update the mutex an 250 /* Update the mutex and walk info and save the original sync_level */
251 251
252 if (walk_state) { 252 if (walk_state) {
253 obj_desc->meth 253 obj_desc->method.mutex->mutex.
254 original_s 254 original_sync_level =
255 walk_state 255 walk_state->thread->current_sync_level;
256 256
257 obj_desc->meth 257 obj_desc->method.mutex->mutex.owner_thread =
258 walk_state 258 walk_state->thread;
259 walk_state->th 259 walk_state->thread->current_sync_level =
260 obj_desc-> 260 obj_desc->method.sync_level;
261 } else { 261 } else {
262 obj_desc->meth 262 obj_desc->method.mutex->mutex.
263 original_s 263 original_sync_level =
264 obj_desc-> 264 obj_desc->method.mutex->mutex.sync_level;
265 } 265 }
266 } 266 }
267 267
268 /* Always increase acquisition 268 /* Always increase acquisition depth */
269 269
270 obj_desc->method.mutex->mutex. 270 obj_desc->method.mutex->mutex.acquisition_depth++;
271 } 271 }
272 272
273 /* 273 /*
274 * Allocate an Owner ID for this metho 274 * Allocate an Owner ID for this method, only if this is the first thread
275 * to begin concurrent execution. We o 275 * to begin concurrent execution. We only need one owner_id, even if the
276 * method is invoked recursively. 276 * method is invoked recursively.
277 */ 277 */
278 if (!obj_desc->method.owner_id) { 278 if (!obj_desc->method.owner_id) {
279 status = acpi_ut_allocate_owne 279 status = acpi_ut_allocate_owner_id(&obj_desc->method.owner_id);
280 if (ACPI_FAILURE(status)) { 280 if (ACPI_FAILURE(status)) {
281 goto cleanup; 281 goto cleanup;
282 } 282 }
283 } 283 }
284 284
285 /* 285 /*
286 * Increment the method parse tree thr 286 * Increment the method parse tree thread count since it has been
287 * reentered one more time (even if it 287 * reentered one more time (even if it is the same thread)
288 */ 288 */
289 obj_desc->method.thread_count++; 289 obj_desc->method.thread_count++;
290 return_ACPI_STATUS(status); 290 return_ACPI_STATUS(status);
291 291
292 cleanup: 292 cleanup:
293 /* On error, must release the method m 293 /* On error, must release the method mutex (if present) */
294 294
295 if (obj_desc->method.mutex) { 295 if (obj_desc->method.mutex) {
296 acpi_os_release_mutex(obj_desc 296 acpi_os_release_mutex(obj_desc->method.mutex->mutex.os_mutex);
297 } 297 }
298 return_ACPI_STATUS(status); 298 return_ACPI_STATUS(status);
299 } 299 }
300 300
301 /********************************************* 301 /*******************************************************************************
302 * 302 *
303 * FUNCTION: acpi_ds_call_control_method 303 * FUNCTION: acpi_ds_call_control_method
304 * 304 *
305 * PARAMETERS: Thread - Info for 305 * PARAMETERS: Thread - Info for this thread
306 * this_walk_state - Current 306 * this_walk_state - Current walk state
307 * Op - Current 307 * Op - Current Op to be walked
308 * 308 *
309 * RETURN: Status 309 * RETURN: Status
310 * 310 *
311 * DESCRIPTION: Transfer execution to a called 311 * DESCRIPTION: Transfer execution to a called control method
312 * 312 *
313 ********************************************* 313 ******************************************************************************/
314 314
315 acpi_status 315 acpi_status
316 acpi_ds_call_control_method(struct acpi_thread 316 acpi_ds_call_control_method(struct acpi_thread_state *thread,
317 struct acpi_walk_s 317 struct acpi_walk_state *this_walk_state,
318 union acpi_parse_o 318 union acpi_parse_object *op)
319 { 319 {
320 acpi_status status; 320 acpi_status status;
321 struct acpi_namespace_node *method_nod 321 struct acpi_namespace_node *method_node;
322 struct acpi_walk_state *next_walk_stat 322 struct acpi_walk_state *next_walk_state = NULL;
323 union acpi_operand_object *obj_desc; 323 union acpi_operand_object *obj_desc;
324 struct acpi_evaluate_info *info; 324 struct acpi_evaluate_info *info;
325 u32 i; 325 u32 i;
326 326
327 ACPI_FUNCTION_TRACE_PTR(ds_call_contro 327 ACPI_FUNCTION_TRACE_PTR(ds_call_control_method, this_walk_state);
328 328
329 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH, 329 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
330 "Calling method %p, 330 "Calling method %p, currentstate=%p\n",
331 this_walk_state->pre 331 this_walk_state->prev_op, this_walk_state));
332 332
333 /* 333 /*
334 * Get the namespace entry for the con 334 * Get the namespace entry for the control method we are about to call
335 */ 335 */
336 method_node = this_walk_state->method_ 336 method_node = this_walk_state->method_call_node;
337 if (!method_node) { 337 if (!method_node) {
338 return_ACPI_STATUS(AE_NULL_ENT 338 return_ACPI_STATUS(AE_NULL_ENTRY);
339 } 339 }
340 340
341 obj_desc = acpi_ns_get_attached_object 341 obj_desc = acpi_ns_get_attached_object(method_node);
342 if (!obj_desc) { 342 if (!obj_desc) {
343 return_ACPI_STATUS(AE_NULL_OBJ 343 return_ACPI_STATUS(AE_NULL_OBJECT);
344 } 344 }
345 345
346 /* Init for new method, possibly wait 346 /* Init for new method, possibly wait on method mutex */
347 347
348 status = acpi_ds_begin_method_executio 348 status = acpi_ds_begin_method_execution(method_node, obj_desc,
349 349 this_walk_state);
350 if (ACPI_FAILURE(status)) { 350 if (ACPI_FAILURE(status)) {
351 return_ACPI_STATUS(status); 351 return_ACPI_STATUS(status);
352 } 352 }
353 353
354 /* Begin method parse/execution. Creat 354 /* Begin method parse/execution. Create a new walk state */
355 355
356 next_walk_state = acpi_ds_create_walk_ 356 next_walk_state = acpi_ds_create_walk_state(obj_desc->method.owner_id,
357 357 NULL, obj_desc, thread);
358 if (!next_walk_state) { 358 if (!next_walk_state) {
359 status = AE_NO_MEMORY; 359 status = AE_NO_MEMORY;
360 goto cleanup; 360 goto cleanup;
361 } 361 }
362 362
363 /* 363 /*
364 * The resolved arguments were put on 364 * The resolved arguments were put on the previous walk state's operand
365 * stack. Operands on the previous wal 365 * stack. Operands on the previous walk state stack always
366 * start at index 0. Also, null termin 366 * start at index 0. Also, null terminate the list of arguments
367 */ 367 */
368 this_walk_state->operands[this_walk_st 368 this_walk_state->operands[this_walk_state->num_operands] = NULL;
369 369
370 /* 370 /*
371 * Allocate and initialize the evaluat 371 * Allocate and initialize the evaluation information block
372 * TBD: this is somewhat inefficient, 372 * TBD: this is somewhat inefficient, should change interface to
373 * ds_init_aml_walk. For now, keeps th 373 * ds_init_aml_walk. For now, keeps this struct off the CPU stack
374 */ 374 */
375 info = ACPI_ALLOCATE_ZEROED(sizeof(str 375 info = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_evaluate_info));
376 if (!info) { 376 if (!info) {
377 return_ACPI_STATUS(AE_NO_MEMOR 377 return_ACPI_STATUS(AE_NO_MEMORY);
378 } 378 }
379 379
380 info->parameters = &this_walk_state->o 380 info->parameters = &this_walk_state->operands[0];
381 info->parameter_type = ACPI_PARAM_ARGS 381 info->parameter_type = ACPI_PARAM_ARGS;
382 382
383 status = acpi_ds_init_aml_walk(next_wa 383 status = acpi_ds_init_aml_walk(next_walk_state, NULL, method_node,
384 obj_des 384 obj_desc->method.aml_start,
385 obj_des 385 obj_desc->method.aml_length, info,
386 ACPI_IM 386 ACPI_IMODE_EXECUTE);
387 387
388 ACPI_FREE(info); 388 ACPI_FREE(info);
389 if (ACPI_FAILURE(status)) { 389 if (ACPI_FAILURE(status)) {
390 goto cleanup; 390 goto cleanup;
391 } 391 }
392 392
393 /* 393 /*
394 * Delete the operands on the previous 394 * Delete the operands on the previous walkstate operand stack
395 * (they were copied to new objects) 395 * (they were copied to new objects)
396 */ 396 */
397 for (i = 0; i < obj_desc->method.param 397 for (i = 0; i < obj_desc->method.param_count; i++) {
398 acpi_ut_remove_reference(this_ 398 acpi_ut_remove_reference(this_walk_state->operands[i]);
399 this_walk_state->operands[i] = 399 this_walk_state->operands[i] = NULL;
400 } 400 }
401 401
402 /* Clear the operand stack */ 402 /* Clear the operand stack */
403 403
404 this_walk_state->num_operands = 0; 404 this_walk_state->num_operands = 0;
405 405
406 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH, 406 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
407 "**** Begin nested e 407 "**** Begin nested execution of [%4.4s] **** WalkState=%p\n",
408 method_node->name.as 408 method_node->name.ascii, next_walk_state));
409 409
410 /* Invoke an internal method if necess 410 /* Invoke an internal method if necessary */
411 411
412 if (obj_desc->method.method_flags & AM 412 if (obj_desc->method.method_flags & AML_METHOD_INTERNAL_ONLY) {
413 status = obj_desc->method.impl 413 status = obj_desc->method.implementation(next_walk_state);
414 } 414 }
415 415
416 return_ACPI_STATUS(status); 416 return_ACPI_STATUS(status);
417 417
418 cleanup: 418 cleanup:
419 419
420 /* On error, we must terminate the met 420 /* On error, we must terminate the method properly */
421 421
422 acpi_ds_terminate_control_method(obj_d 422 acpi_ds_terminate_control_method(obj_desc, next_walk_state);
423 if (next_walk_state) { 423 if (next_walk_state) {
424 acpi_ds_delete_walk_state(next 424 acpi_ds_delete_walk_state(next_walk_state);
425 } 425 }
426 426
427 return_ACPI_STATUS(status); 427 return_ACPI_STATUS(status);
428 } 428 }
429 429
430 /********************************************* 430 /*******************************************************************************
431 * 431 *
432 * FUNCTION: acpi_ds_restart_control_method 432 * FUNCTION: acpi_ds_restart_control_method
433 * 433 *
434 * PARAMETERS: walk_state - State fo 434 * PARAMETERS: walk_state - State for preempted method (caller)
435 * return_desc - Return v 435 * return_desc - Return value from the called method
436 * 436 *
437 * RETURN: Status 437 * RETURN: Status
438 * 438 *
439 * DESCRIPTION: Restart a method that was pree 439 * DESCRIPTION: Restart a method that was preempted by another (nested) method
440 * invocation. Handle the return 440 * invocation. Handle the return value (if any) from the callee.
441 * 441 *
442 ********************************************* 442 ******************************************************************************/
443 443
444 acpi_status 444 acpi_status
445 acpi_ds_restart_control_method(struct acpi_wal 445 acpi_ds_restart_control_method(struct acpi_walk_state *walk_state,
446 union acpi_oper 446 union acpi_operand_object *return_desc)
447 { 447 {
448 acpi_status status; 448 acpi_status status;
449 int same_as_implicit_return; 449 int same_as_implicit_return;
450 450
451 ACPI_FUNCTION_TRACE_PTR(ds_restart_con 451 ACPI_FUNCTION_TRACE_PTR(ds_restart_control_method, walk_state);
452 452
453 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH, 453 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
454 "****Restart [%4.4s] 454 "****Restart [%4.4s] Op %p ReturnValueFromCallee %p\n",
455 acpi_ut_get_node_nam 455 acpi_ut_get_node_name(walk_state->method_node),
456 walk_state->method_c 456 walk_state->method_call_op, return_desc));
457 457
458 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH, 458 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
459 " ReturnFromThisM 459 " ReturnFromThisMethodUsed?=%X ResStack %p Walk %p\n",
460 walk_state->return_u 460 walk_state->return_used,
461 walk_state->results, 461 walk_state->results, walk_state));
462 462
463 /* Did the called method return a valu 463 /* Did the called method return a value? */
464 464
465 if (return_desc) { 465 if (return_desc) {
466 466
467 /* Is the implicit return obje 467 /* Is the implicit return object the same as the return desc? */
468 468
469 same_as_implicit_return = 469 same_as_implicit_return =
470 (walk_state->implicit_retu 470 (walk_state->implicit_return_obj == return_desc);
471 471
472 /* Are we actually going to us 472 /* Are we actually going to use the return value? */
473 473
474 if (walk_state->return_used) { 474 if (walk_state->return_used) {
475 475
476 /* Save the return val 476 /* Save the return value from the previous method */
477 477
478 status = acpi_ds_resul 478 status = acpi_ds_result_push(return_desc, walk_state);
479 if (ACPI_FAILURE(statu 479 if (ACPI_FAILURE(status)) {
480 acpi_ut_remove 480 acpi_ut_remove_reference(return_desc);
481 return_ACPI_ST 481 return_ACPI_STATUS(status);
482 } 482 }
483 483
484 /* 484 /*
485 * Save as THIS method 485 * Save as THIS method's return value in case it is returned
486 * immediately to yet 486 * immediately to yet another method
487 */ 487 */
488 walk_state->return_des 488 walk_state->return_desc = return_desc;
489 } 489 }
490 490
491 /* 491 /*
492 * The following code is the o 492 * The following code is the optional support for the so-called
493 * "implicit return". Some AML 493 * "implicit return". Some AML code assumes that the last value of the
494 * method is "implicitly" retu 494 * method is "implicitly" returned to the caller, in the absence of an
495 * explicit return value. 495 * explicit return value.
496 * 496 *
497 * Just save the last result o 497 * Just save the last result of the method as the return value.
498 * 498 *
499 * NOTE: this is optional beca 499 * NOTE: this is optional because the ASL language does not actually
500 * support this behavior. 500 * support this behavior.
501 */ 501 */
502 else if (!acpi_ds_do_implicit_ 502 else if (!acpi_ds_do_implicit_return
503 (return_desc, walk_st 503 (return_desc, walk_state, FALSE)
504 || same_as_implicit_r 504 || same_as_implicit_return) {
505 /* 505 /*
506 * Delete the return v 506 * Delete the return value if it will not be used by the
507 * calling method or r 507 * calling method or remove one reference if the explicit return
508 * is the same as the 508 * is the same as the implicit return value.
509 */ 509 */
510 acpi_ut_remove_referen 510 acpi_ut_remove_reference(return_desc);
511 } 511 }
512 } 512 }
513 513
514 return_ACPI_STATUS(AE_OK); 514 return_ACPI_STATUS(AE_OK);
515 } 515 }
516 516
517 /********************************************* 517 /*******************************************************************************
518 * 518 *
519 * FUNCTION: acpi_ds_terminate_control_meth 519 * FUNCTION: acpi_ds_terminate_control_method
520 * 520 *
521 * PARAMETERS: method_desc - Method o 521 * PARAMETERS: method_desc - Method object
522 * walk_state - State as 522 * walk_state - State associated with the method
523 * 523 *
524 * RETURN: None 524 * RETURN: None
525 * 525 *
526 * DESCRIPTION: Terminate a control method. D 526 * DESCRIPTION: Terminate a control method. Delete everything that the method
527 * created, delete all locals and 527 * created, delete all locals and arguments, and delete the parse
528 * tree if requested. 528 * tree if requested.
529 * 529 *
530 * MUTEX: Interpreter is locked 530 * MUTEX: Interpreter is locked
531 * 531 *
532 ********************************************* 532 ******************************************************************************/
533 533
534 void 534 void
535 acpi_ds_terminate_control_method(union acpi_op 535 acpi_ds_terminate_control_method(union acpi_operand_object *method_desc,
536 struct acpi_w 536 struct acpi_walk_state *walk_state)
537 { 537 {
538 struct acpi_namespace_node *method_nod 538 struct acpi_namespace_node *method_node;
539 acpi_status status; 539 acpi_status status;
540 540
541 ACPI_FUNCTION_TRACE_PTR(ds_terminate_c 541 ACPI_FUNCTION_TRACE_PTR(ds_terminate_control_method, walk_state);
542 542
543 /* method_desc is required, walk_state 543 /* method_desc is required, walk_state is optional */
544 544
545 if (!method_desc) { 545 if (!method_desc) {
546 return_VOID; 546 return_VOID;
547 } 547 }
548 548
549 if (walk_state) { 549 if (walk_state) {
550 550
551 /* Delete all arguments and lo 551 /* Delete all arguments and locals */
552 552
553 acpi_ds_method_data_delete_all 553 acpi_ds_method_data_delete_all(walk_state);
554 } 554 }
555 555
556 /* 556 /*
557 * If method is serialized, release th 557 * If method is serialized, release the mutex and restore the
558 * current sync level for this thread 558 * current sync level for this thread
559 */ 559 */
560 if (method_desc->method.mutex) { 560 if (method_desc->method.mutex) {
561 561
562 /* Acquisition Depth handles r 562 /* Acquisition Depth handles recursive calls */
563 563
564 method_desc->method.mutex->mut 564 method_desc->method.mutex->mutex.acquisition_depth--;
565 if (!method_desc->method.mutex 565 if (!method_desc->method.mutex->mutex.acquisition_depth) {
566 walk_state->thread->cu 566 walk_state->thread->current_sync_level =
567 method_desc->metho 567 method_desc->method.mutex->mutex.
568 original_sync_leve 568 original_sync_level;
569 569
570 acpi_os_release_mutex( 570 acpi_os_release_mutex(method_desc->method.mutex->mutex.
571 571 os_mutex);
572 method_desc->method.mu 572 method_desc->method.mutex->mutex.owner_thread = NULL;
573 } 573 }
574 } 574 }
575 575
576 if (walk_state) { 576 if (walk_state) {
577 /* 577 /*
578 * Delete any objects created 578 * Delete any objects created by this method during execution.
579 * The method Node is stored i 579 * The method Node is stored in the walk state
580 */ 580 */
581 method_node = walk_state->meth 581 method_node = walk_state->method_node;
582 582
583 /* 583 /*
584 * Delete any namespace object 584 * Delete any namespace objects created anywhere within
585 * the namespace by the execut 585 * the namespace by the execution of this method
586 */ 586 */
587 acpi_ns_delete_namespace_by_ow 587 acpi_ns_delete_namespace_by_owner(method_desc->method.owner_id);
588 } 588 }
589 589
590 /* Decrement the thread count on the m 590 /* Decrement the thread count on the method */
591 591
592 if (method_desc->method.thread_count) 592 if (method_desc->method.thread_count) {
593 method_desc->method.thread_cou 593 method_desc->method.thread_count--;
594 } else { 594 } else {
595 ACPI_ERROR((AE_INFO, "Invalid 595 ACPI_ERROR((AE_INFO, "Invalid zero thread count in method"));
596 } 596 }
597 597
598 /* Are there any other threads current 598 /* Are there any other threads currently executing this method? */
599 599
600 if (method_desc->method.thread_count) 600 if (method_desc->method.thread_count) {
601 /* 601 /*
602 * Additional threads. Do not 602 * Additional threads. Do not release the owner_id in this case,
603 * we immediately reuse it for 603 * we immediately reuse it for the next thread executing this method
604 */ 604 */
605 ACPI_DEBUG_PRINT((ACPI_DB_DISP 605 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
606 "*** Complet 606 "*** Completed execution of one thread, %d threads remaining\n",
607 method_desc- 607 method_desc->method.thread_count));
608 } else { 608 } else {
609 /* This is the only executing 609 /* This is the only executing thread for this method */
610 610
611 /* 611 /*
612 * Support to dynamically chan 612 * Support to dynamically change a method from not_serialized to
613 * Serialized if it appears th 613 * Serialized if it appears that the method is incorrectly written and
614 * does not support multiple t 614 * does not support multiple thread execution. The best example of this
615 * is if such a method creates 615 * is if such a method creates namespace objects and blocks. A second
616 * thread will fail with an AE 616 * thread will fail with an AE_ALREADY_EXISTS exception
617 * 617 *
618 * This code is here because w 618 * This code is here because we must wait until the last thread exits
619 * before creating the synchro 619 * before creating the synchronization semaphore.
620 */ 620 */
621 if ((method_desc->method.metho 621 if ((method_desc->method.method_flags & AML_METHOD_SERIALIZED)
622 && (!method_desc->method.m 622 && (!method_desc->method.mutex)) {
623 status = acpi_ds_creat 623 status = acpi_ds_create_method_mutex(method_desc);
624 } 624 }
625 625
626 /* No more threads, we can fre 626 /* No more threads, we can free the owner_id */
627 627
628 acpi_ut_release_owner_id(&meth 628 acpi_ut_release_owner_id(&method_desc->method.owner_id);
629 } 629 }
630 630
631 return_VOID; 631 return_VOID;
632 } 632 }
633 633
|
This page was automatically generated by the
LXR engine.
|