1// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
2/******************************************************************************
3 *
4 * Module Name: psparse - Parser top level AML parse routines
5 *
6 * Copyright (C) 2000 - 2023, Intel Corp.
7 *
8 *****************************************************************************/
9
10/*
11 * Parse the AML and build an operation tree as most interpreters,
12 * like Perl, do. Parsing is done by hand rather than with a YACC
13 * generated parser to tightly constrain stack and dynamic memory
14 * usage. At the same time, parsing is kept flexible and the code
15 * fairly compact by parsing based on a list of AML opcode
16 * templates in aml_op_info[]
17 */
18
19#include <acpi/acpi.h>
20#include "accommon.h"
21#include "acparser.h"
22#include "acdispat.h"
23#include "amlcode.h"
24#include "acinterp.h"
25#include "acnamesp.h"
26
27#define _COMPONENT          ACPI_PARSER
28ACPI_MODULE_NAME("psparse")
29
30/*******************************************************************************
31 *
32 * FUNCTION:    acpi_ps_get_opcode_size
33 *
34 * PARAMETERS:  opcode          - An AML opcode
35 *
36 * RETURN:      Size of the opcode, in bytes (1 or 2)
37 *
38 * DESCRIPTION: Get the size of the current opcode.
39 *
40 ******************************************************************************/
41u32 acpi_ps_get_opcode_size(u32 opcode)
42{
43
44	/* Extended (2-byte) opcode if > 255 */
45
46	if (opcode > 0x00FF) {
47		return (2);
48	}
49
50	/* Otherwise, just a single byte opcode */
51
52	return (1);
53}
54
55/*******************************************************************************
56 *
57 * FUNCTION:    acpi_ps_peek_opcode
58 *
59 * PARAMETERS:  parser_state        - A parser state object
60 *
61 * RETURN:      Next AML opcode
62 *
63 * DESCRIPTION: Get next AML opcode (without incrementing AML pointer)
64 *
65 ******************************************************************************/
66
67u16 acpi_ps_peek_opcode(struct acpi_parse_state * parser_state)
68{
69	u8 *aml;
70	u16 opcode;
71
72	aml = parser_state->aml;
73	opcode = (u16) ACPI_GET8(aml);
74
75	if (opcode == AML_EXTENDED_PREFIX) {
76
77		/* Extended opcode, get the second opcode byte */
78
79		aml++;
80		opcode = (u16) ((opcode << 8) | ACPI_GET8(aml));
81	}
82
83	return (opcode);
84}
85
86/*******************************************************************************
87 *
88 * FUNCTION:    acpi_ps_complete_this_op
89 *
90 * PARAMETERS:  walk_state      - Current State
91 *              op              - Op to complete
92 *
93 * RETURN:      Status
94 *
95 * DESCRIPTION: Perform any cleanup at the completion of an Op.
96 *
97 ******************************************************************************/
98
99acpi_status
100acpi_ps_complete_this_op(struct acpi_walk_state *walk_state,
101			 union acpi_parse_object *op)
102{
103	union acpi_parse_object *prev;
104	union acpi_parse_object *next;
105	const struct acpi_opcode_info *parent_info;
106	union acpi_parse_object *replacement_op = NULL;
107	acpi_status status = AE_OK;
108
109	ACPI_FUNCTION_TRACE_PTR(ps_complete_this_op, op);
110
111	/* Check for null Op, can happen if AML code is corrupt */
112
113	if (!op) {
114		return_ACPI_STATUS(AE_OK);	/* OK for now */
115	}
116
117	acpi_ex_stop_trace_opcode(op, walk_state);
118
119	/* Delete this op and the subtree below it if asked to */
120
121	if (((walk_state->parse_flags & ACPI_PARSE_TREE_MASK) !=
122	     ACPI_PARSE_DELETE_TREE)
123	    || (walk_state->op_info->class == AML_CLASS_ARGUMENT)) {
124		return_ACPI_STATUS(AE_OK);
125	}
126
127	/* Make sure that we only delete this subtree */
128
129	if (op->common.parent) {
130		prev = op->common.parent->common.value.arg;
131		if (!prev) {
132
133			/* Nothing more to do */
134
135			goto cleanup;
136		}
137
138		/*
139		 * Check if we need to replace the operator and its subtree
140		 * with a return value op (placeholder op)
141		 */
142		parent_info =
143		    acpi_ps_get_opcode_info(op->common.parent->common.
144					    aml_opcode);
145
146		switch (parent_info->class) {
147		case AML_CLASS_CONTROL:
148
149			break;
150
151		case AML_CLASS_CREATE:
152			/*
153			 * These opcodes contain term_arg operands. The current
154			 * op must be replaced by a placeholder return op
155			 */
156			replacement_op =
157			    acpi_ps_alloc_op(AML_INT_RETURN_VALUE_OP,
158					     op->common.aml);
159			if (!replacement_op) {
160				status = AE_NO_MEMORY;
161			}
162			break;
163
164		case AML_CLASS_NAMED_OBJECT:
165			/*
166			 * These opcodes contain term_arg operands. The current
167			 * op must be replaced by a placeholder return op
168			 */
169			if ((op->common.parent->common.aml_opcode ==
170			     AML_REGION_OP)
171			    || (op->common.parent->common.aml_opcode ==
172				AML_DATA_REGION_OP)
173			    || (op->common.parent->common.aml_opcode ==
174				AML_BUFFER_OP)
175			    || (op->common.parent->common.aml_opcode ==
176				AML_PACKAGE_OP)
177			    || (op->common.parent->common.aml_opcode ==
178				AML_BANK_FIELD_OP)
179			    || (op->common.parent->common.aml_opcode ==
180				AML_VARIABLE_PACKAGE_OP)) {
181				replacement_op =
182				    acpi_ps_alloc_op(AML_INT_RETURN_VALUE_OP,
183						     op->common.aml);
184				if (!replacement_op) {
185					status = AE_NO_MEMORY;
186				}
187			} else
188			    if ((op->common.parent->common.aml_opcode ==
189				 AML_NAME_OP)
190				&& (walk_state->pass_number <=
191				    ACPI_IMODE_LOAD_PASS2)) {
192				if ((op->common.aml_opcode == AML_BUFFER_OP)
193				    || (op->common.aml_opcode == AML_PACKAGE_OP)
194				    || (op->common.aml_opcode ==
195					AML_VARIABLE_PACKAGE_OP)) {
196					replacement_op =
197					    acpi_ps_alloc_op(op->common.
198							     aml_opcode,
199							     op->common.aml);
200					if (!replacement_op) {
201						status = AE_NO_MEMORY;
202					} else {
203						replacement_op->named.data =
204						    op->named.data;
205						replacement_op->named.length =
206						    op->named.length;
207					}
208				}
209			}
210			break;
211
212		default:
213
214			replacement_op =
215			    acpi_ps_alloc_op(AML_INT_RETURN_VALUE_OP,
216					     op->common.aml);
217			if (!replacement_op) {
218				status = AE_NO_MEMORY;
219			}
220		}
221
222		/* We must unlink this op from the parent tree */
223
224		if (prev == op) {
225
226			/* This op is the first in the list */
227
228			if (replacement_op) {
229				replacement_op->common.parent =
230				    op->common.parent;
231				replacement_op->common.value.arg = NULL;
232				replacement_op->common.node = op->common.node;
233				op->common.parent->common.value.arg =
234				    replacement_op;
235				replacement_op->common.next = op->common.next;
236			} else {
237				op->common.parent->common.value.arg =
238				    op->common.next;
239			}
240		}
241
242		/* Search the parent list */
243
244		else
245			while (prev) {
246
247				/* Traverse all siblings in the parent's argument list */
248
249				next = prev->common.next;
250				if (next == op) {
251					if (replacement_op) {
252						replacement_op->common.parent =
253						    op->common.parent;
254						replacement_op->common.value.
255						    arg = NULL;
256						replacement_op->common.node =
257						    op->common.node;
258						prev->common.next =
259						    replacement_op;
260						replacement_op->common.next =
261						    op->common.next;
262						next = NULL;
263					} else {
264						prev->common.next =
265						    op->common.next;
266						next = NULL;
267					}
268				}
269				prev = next;
270			}
271	}
272
273cleanup:
274
275	/* Now we can actually delete the subtree rooted at Op */
276
277	acpi_ps_delete_parse_tree(op);
278	return_ACPI_STATUS(status);
279}
280
281/*******************************************************************************
282 *
283 * FUNCTION:    acpi_ps_next_parse_state
284 *
285 * PARAMETERS:  walk_state          - Current state
286 *              op                  - Current parse op
287 *              callback_status     - Status from previous operation
288 *
289 * RETURN:      Status
290 *
291 * DESCRIPTION: Update the parser state based upon the return exception from
292 *              the parser callback.
293 *
294 ******************************************************************************/
295
296acpi_status
297acpi_ps_next_parse_state(struct acpi_walk_state *walk_state,
298			 union acpi_parse_object *op,
299			 acpi_status callback_status)
300{
301	struct acpi_parse_state *parser_state = &walk_state->parser_state;
302	acpi_status status = AE_CTRL_PENDING;
303
304	ACPI_FUNCTION_TRACE_PTR(ps_next_parse_state, op);
305
306	switch (callback_status) {
307	case AE_CTRL_TERMINATE:
308		/*
309		 * A control method was terminated via a RETURN statement.
310		 * The walk of this method is complete.
311		 */
312		parser_state->aml = parser_state->aml_end;
313		status = AE_CTRL_TERMINATE;
314		break;
315
316	case AE_CTRL_BREAK:
317
318		parser_state->aml = walk_state->aml_last_while;
319		walk_state->control_state->common.value = FALSE;
320		status = AE_CTRL_BREAK;
321		break;
322
323	case AE_CTRL_CONTINUE:
324
325		parser_state->aml = walk_state->aml_last_while;
326		status = AE_CTRL_CONTINUE;
327		break;
328
329	case AE_CTRL_PENDING:
330
331		parser_state->aml = walk_state->aml_last_while;
332		break;
333
334#if 0
335	case AE_CTRL_SKIP:
336
337		parser_state->aml = parser_state->scope->parse_scope.pkg_end;
338		status = AE_OK;
339		break;
340#endif
341
342	case AE_CTRL_TRUE:
343		/*
344		 * Predicate of an IF was true, and we are at the matching ELSE.
345		 * Just close out this package
346		 */
347		parser_state->aml = acpi_ps_get_next_package_end(parser_state);
348		status = AE_CTRL_PENDING;
349		break;
350
351	case AE_CTRL_FALSE:
352		/*
353		 * Either an IF/WHILE Predicate was false or we encountered a BREAK
354		 * opcode. In both cases, we do not execute the rest of the
355		 * package;  We simply close out the parent (finishing the walk of
356		 * this branch of the tree) and continue execution at the parent
357		 * level.
358		 */
359		parser_state->aml = parser_state->scope->parse_scope.pkg_end;
360
361		/* In the case of a BREAK, just force a predicate (if any) to FALSE */
362
363		walk_state->control_state->common.value = FALSE;
364		status = AE_CTRL_END;
365		break;
366
367	case AE_CTRL_TRANSFER:
368
369		/* A method call (invocation) -- transfer control */
370
371		status = AE_CTRL_TRANSFER;
372		walk_state->prev_op = op;
373		walk_state->method_call_op = op;
374		walk_state->method_call_node =
375		    (op->common.value.arg)->common.node;
376
377		/* Will return value (if any) be used by the caller? */
378
379		walk_state->return_used =
380		    acpi_ds_is_result_used(op, walk_state);
381		break;
382
383	default:
384
385		status = callback_status;
386		if (ACPI_CNTL_EXCEPTION(callback_status)) {
387			status = AE_OK;
388		}
389		break;
390	}
391
392	return_ACPI_STATUS(status);
393}
394
395/*******************************************************************************
396 *
397 * FUNCTION:    acpi_ps_parse_aml
398 *
399 * PARAMETERS:  walk_state      - Current state
400 *
401 *
402 * RETURN:      Status
403 *
404 * DESCRIPTION: Parse raw AML and return a tree of ops
405 *
406 ******************************************************************************/
407
408acpi_status acpi_ps_parse_aml(struct acpi_walk_state *walk_state)
409{
410	acpi_status status;
411	struct acpi_thread_state *thread;
412	struct acpi_thread_state *prev_walk_list = acpi_gbl_current_walk_list;
413	struct acpi_walk_state *previous_walk_state;
414
415	ACPI_FUNCTION_TRACE(ps_parse_aml);
416
417	ACPI_DEBUG_PRINT((ACPI_DB_PARSE,
418			  "Entered with WalkState=%p Aml=%p size=%X\n",
419			  walk_state, walk_state->parser_state.aml,
420			  walk_state->parser_state.aml_size));
421
422	if (!walk_state->parser_state.aml) {
423		return_ACPI_STATUS(AE_BAD_ADDRESS);
424	}
425
426	/* Create and initialize a new thread state */
427
428	thread = acpi_ut_create_thread_state();
429	if (!thread) {
430		if (walk_state->method_desc) {
431
432			/* Executing a control method - additional cleanup */
433
434			acpi_ds_terminate_control_method(walk_state->
435							 method_desc,
436							 walk_state);
437		}
438
439		acpi_ds_delete_walk_state(walk_state);
440		return_ACPI_STATUS(AE_NO_MEMORY);
441	}
442
443	walk_state->thread = thread;
444
445	/*
446	 * If executing a method, the starting sync_level is this method's
447	 * sync_level
448	 */
449	if (walk_state->method_desc) {
450		walk_state->thread->current_sync_level =
451		    walk_state->method_desc->method.sync_level;
452	}
453
454	acpi_ds_push_walk_state(walk_state, thread);
455
456	/*
457	 * This global allows the AML debugger to get a handle to the currently
458	 * executing control method.
459	 */
460	acpi_gbl_current_walk_list = thread;
461
462	/*
463	 * Execute the walk loop as long as there is a valid Walk State. This
464	 * handles nested control method invocations without recursion.
465	 */
466	ACPI_DEBUG_PRINT((ACPI_DB_PARSE, "State=%p\n", walk_state));
467
468	status = AE_OK;
469	while (walk_state) {
470		if (ACPI_SUCCESS(status)) {
471			/*
472			 * The parse_loop executes AML until the method terminates
473			 * or calls another method.
474			 */
475			status = acpi_ps_parse_loop(walk_state);
476		}
477
478		ACPI_DEBUG_PRINT((ACPI_DB_PARSE,
479				  "Completed one call to walk loop, %s State=%p\n",
480				  acpi_format_exception(status), walk_state));
481
482		if (walk_state->method_pathname && walk_state->method_is_nested) {
483
484			/* Optional object evaluation log */
485
486			ACPI_DEBUG_PRINT_RAW((ACPI_DB_EVALUATION,
487					      "%-26s:  %*s%s\n",
488					      "   Exit nested method",
489					      (walk_state->
490					       method_nesting_depth + 1) * 3,
491					      " ",
492					      &walk_state->method_pathname[1]));
493
494			ACPI_FREE(walk_state->method_pathname);
495			walk_state->method_is_nested = FALSE;
496		}
497		if (status == AE_CTRL_TRANSFER) {
498			/*
499			 * A method call was detected.
500			 * Transfer control to the called control method
501			 */
502			status =
503			    acpi_ds_call_control_method(thread, walk_state,
504							NULL);
505			if (ACPI_FAILURE(status)) {
506				status =
507				    acpi_ds_method_error(status, walk_state);
508			}
509
510			/*
511			 * If the transfer to the new method method call worked,
512			 * a new walk state was created -- get it
513			 */
514			walk_state = acpi_ds_get_current_walk_state(thread);
515			continue;
516		} else if (status == AE_CTRL_TERMINATE) {
517			status = AE_OK;
518		} else if ((status != AE_OK) && (walk_state->method_desc)) {
519
520			/* Either the method parse or actual execution failed */
521
522			acpi_ex_exit_interpreter();
523			if (status == AE_ABORT_METHOD) {
524				acpi_ns_print_node_pathname(walk_state->
525							    method_node,
526							    "Aborting method");
527				acpi_os_printf("\n");
528			} else {
529				ACPI_ERROR_METHOD("Aborting method",
530						  walk_state->method_node, NULL,
531						  status);
532			}
533			acpi_ex_enter_interpreter();
534
535			/* Check for possible multi-thread reentrancy problem */
536
537			if ((status == AE_ALREADY_EXISTS) &&
538			    (!(walk_state->method_desc->method.info_flags &
539			       ACPI_METHOD_SERIALIZED))) {
540				/*
541				 * Method is not serialized and tried to create an object
542				 * twice. The probable cause is that the method cannot
543				 * handle reentrancy. Mark as "pending serialized" now, and
544				 * then mark "serialized" when the last thread exits.
545				 */
546				walk_state->method_desc->method.info_flags |=
547				    ACPI_METHOD_SERIALIZED_PENDING;
548			}
549		}
550
551		/* We are done with this walk, move on to the parent if any */
552
553		walk_state = acpi_ds_pop_walk_state(thread);
554
555		/* Reset the current scope to the beginning of scope stack */
556
557		acpi_ds_scope_stack_clear(walk_state);
558
559		/*
560		 * If we just returned from the execution of a control method or if we
561		 * encountered an error during the method parse phase, there's lots of
562		 * cleanup to do
563		 */
564		if (((walk_state->parse_flags & ACPI_PARSE_MODE_MASK) ==
565		     ACPI_PARSE_EXECUTE &&
566		     !(walk_state->parse_flags & ACPI_PARSE_MODULE_LEVEL)) ||
567		    (ACPI_FAILURE(status))) {
568			acpi_ds_terminate_control_method(walk_state->
569							 method_desc,
570							 walk_state);
571		}
572
573		/* Delete this walk state and all linked control states */
574
575		acpi_ps_cleanup_scope(&walk_state->parser_state);
576		previous_walk_state = walk_state;
577
578		ACPI_DEBUG_PRINT((ACPI_DB_PARSE,
579				  "ReturnValue=%p, ImplicitValue=%p State=%p\n",
580				  walk_state->return_desc,
581				  walk_state->implicit_return_obj, walk_state));
582
583		/* Check if we have restarted a preempted walk */
584
585		walk_state = acpi_ds_get_current_walk_state(thread);
586		if (walk_state) {
587			if (ACPI_SUCCESS(status)) {
588				/*
589				 * There is another walk state, restart it.
590				 * If the method return value is not used by the parent,
591				 * The object is deleted
592				 */
593				if (!previous_walk_state->return_desc) {
594					/*
595					 * In slack mode execution, if there is no return value
596					 * we should implicitly return zero (0) as a default value.
597					 */
598					if (acpi_gbl_enable_interpreter_slack &&
599					    !previous_walk_state->
600					    implicit_return_obj) {
601						previous_walk_state->
602						    implicit_return_obj =
603						    acpi_ut_create_integer_object
604						    ((u64) 0);
605						if (!previous_walk_state->
606						    implicit_return_obj) {
607							return_ACPI_STATUS
608							    (AE_NO_MEMORY);
609						}
610					}
611
612					/* Restart the calling control method */
613
614					status =
615					    acpi_ds_restart_control_method
616					    (walk_state,
617					     previous_walk_state->
618					     implicit_return_obj);
619				} else {
620					/*
621					 * We have a valid return value, delete any implicit
622					 * return value.
623					 */
624					acpi_ds_clear_implicit_return
625					    (previous_walk_state);
626
627					status =
628					    acpi_ds_restart_control_method
629					    (walk_state,
630					     previous_walk_state->return_desc);
631				}
632				if (ACPI_SUCCESS(status)) {
633					walk_state->walk_type |=
634					    ACPI_WALK_METHOD_RESTART;
635				}
636			} else {
637				/* On error, delete any return object or implicit return */
638
639				acpi_ut_remove_reference(previous_walk_state->
640							 return_desc);
641				acpi_ds_clear_implicit_return
642				    (previous_walk_state);
643			}
644		}
645
646		/*
647		 * Just completed a 1st-level method, save the final internal return
648		 * value (if any)
649		 */
650		else if (previous_walk_state->caller_return_desc) {
651			if (previous_walk_state->implicit_return_obj) {
652				*(previous_walk_state->caller_return_desc) =
653				    previous_walk_state->implicit_return_obj;
654			} else {
655				/* NULL if no return value */
656
657				*(previous_walk_state->caller_return_desc) =
658				    previous_walk_state->return_desc;
659			}
660		} else {
661			if (previous_walk_state->return_desc) {
662
663				/* Caller doesn't want it, must delete it */
664
665				acpi_ut_remove_reference(previous_walk_state->
666							 return_desc);
667			}
668			if (previous_walk_state->implicit_return_obj) {
669
670				/* Caller doesn't want it, must delete it */
671
672				acpi_ut_remove_reference(previous_walk_state->
673							 implicit_return_obj);
674			}
675		}
676
677		acpi_ds_delete_walk_state(previous_walk_state);
678	}
679
680	/* Normal exit */
681
682	acpi_ex_release_all_mutexes(thread);
683	acpi_ut_delete_generic_state(ACPI_CAST_PTR
684				     (union acpi_generic_state, thread));
685	acpi_gbl_current_walk_list = prev_walk_list;
686	return_ACPI_STATUS(status);
687}
688