xref: /linux/drivers/acpi/acpica/nsarguments.c (revision 1ac731c529cd4d6adbce134754b51ff7d822b145)
1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
2 /******************************************************************************
3  *
4  * Module Name: nsarguments - Validation of args for ACPI predefined methods
5  *
6  * Copyright (C) 2000 - 2023, Intel Corp.
7  *
8  *****************************************************************************/
9 
10 #include <acpi/acpi.h>
11 #include "accommon.h"
12 #include "acnamesp.h"
13 #include "acpredef.h"
14 
15 #define _COMPONENT          ACPI_NAMESPACE
16 ACPI_MODULE_NAME("nsarguments")
17 
18 /*******************************************************************************
19  *
20  * FUNCTION:    acpi_ns_check_argument_types
21  *
22  * PARAMETERS:  info            - Method execution information block
23  *
24  * RETURN:      None
25  *
26  * DESCRIPTION: Check the incoming argument count and all argument types
27  *              against the argument type list for a predefined name.
28  *
29  ******************************************************************************/
acpi_ns_check_argument_types(struct acpi_evaluate_info * info)30 void acpi_ns_check_argument_types(struct acpi_evaluate_info *info)
31 {
32 	u16 arg_type_list;
33 	u8 arg_count;
34 	u8 arg_type;
35 	u8 user_arg_type;
36 	u32 i;
37 
38 	/*
39 	 * If not a predefined name, cannot typecheck args, because
40 	 * we have no idea what argument types are expected.
41 	 * Also, ignore typecheck if warnings/errors if this method
42 	 * has already been evaluated at least once -- in order
43 	 * to suppress repetitive messages.
44 	 */
45 	if (!info->predefined || (info->node->flags & ANOBJ_EVALUATED)) {
46 		return;
47 	}
48 
49 	arg_type_list = info->predefined->info.argument_list;
50 	arg_count = METHOD_GET_ARG_COUNT(arg_type_list);
51 
52 	/* Typecheck all arguments */
53 
54 	for (i = 0; ((i < arg_count) && (i < info->param_count)); i++) {
55 		arg_type = METHOD_GET_NEXT_TYPE(arg_type_list);
56 		user_arg_type = info->parameters[i]->common.type;
57 
58 		/* No typechecking for ACPI_TYPE_ANY */
59 
60 		if ((user_arg_type != arg_type) && (arg_type != ACPI_TYPE_ANY)) {
61 			ACPI_WARN_PREDEFINED((AE_INFO, info->full_pathname,
62 					      ACPI_WARN_ALWAYS,
63 					      "Argument #%u type mismatch - "
64 					      "Found [%s], ACPI requires [%s]",
65 					      (i + 1),
66 					      acpi_ut_get_type_name
67 					      (user_arg_type),
68 					      acpi_ut_get_type_name(arg_type)));
69 
70 			/* Prevent any additional typechecking for this method */
71 
72 			info->node->flags |= ANOBJ_EVALUATED;
73 		}
74 	}
75 }
76 
77 /*******************************************************************************
78  *
79  * FUNCTION:    acpi_ns_check_acpi_compliance
80  *
81  * PARAMETERS:  pathname        - Full pathname to the node (for error msgs)
82  *              node            - Namespace node for the method/object
83  *              predefined      - Pointer to entry in predefined name table
84  *
85  * RETURN:      None
86  *
87  * DESCRIPTION: Check that the declared parameter count (in ASL/AML) for a
88  *              predefined name is what is expected (matches what is defined in
89  *              the ACPI specification for this predefined name.)
90  *
91  ******************************************************************************/
92 
93 void
acpi_ns_check_acpi_compliance(char * pathname,struct acpi_namespace_node * node,const union acpi_predefined_info * predefined)94 acpi_ns_check_acpi_compliance(char *pathname,
95 			      struct acpi_namespace_node *node,
96 			      const union acpi_predefined_info *predefined)
97 {
98 	u32 aml_param_count;
99 	u32 required_param_count;
100 
101 	if (!predefined || (node->flags & ANOBJ_EVALUATED)) {
102 		return;
103 	}
104 
105 	/* Get the ACPI-required arg count from the predefined info table */
106 
107 	required_param_count =
108 	    METHOD_GET_ARG_COUNT(predefined->info.argument_list);
109 
110 	/*
111 	 * If this object is not a control method, we can check if the ACPI
112 	 * spec requires that it be a method.
113 	 */
114 	if (node->type != ACPI_TYPE_METHOD) {
115 		if (required_param_count > 0) {
116 
117 			/* Object requires args, must be implemented as a method */
118 
119 			ACPI_BIOS_ERROR_PREDEFINED((AE_INFO, pathname,
120 						    ACPI_WARN_ALWAYS,
121 						    "Object (%s) must be a control method with %u arguments",
122 						    acpi_ut_get_type_name(node->
123 									  type),
124 						    required_param_count));
125 		} else if (!required_param_count
126 			   && !predefined->info.expected_btypes) {
127 
128 			/* Object requires no args and no return value, must be a method */
129 
130 			ACPI_BIOS_ERROR_PREDEFINED((AE_INFO, pathname,
131 						    ACPI_WARN_ALWAYS,
132 						    "Object (%s) must be a control method "
133 						    "with no arguments and no return value",
134 						    acpi_ut_get_type_name(node->
135 									  type)));
136 		}
137 
138 		return;
139 	}
140 
141 	/*
142 	 * This is a control method.
143 	 * Check that the ASL/AML-defined parameter count for this method
144 	 * matches the ACPI-required parameter count
145 	 *
146 	 * Some methods are allowed to have a "minimum" number of args (_SCP)
147 	 * because their definition in ACPI has changed over time.
148 	 *
149 	 * Note: These are BIOS errors in the declaration of the object
150 	 */
151 	aml_param_count = node->object->method.param_count;
152 
153 	if (aml_param_count < required_param_count) {
154 		ACPI_BIOS_ERROR_PREDEFINED((AE_INFO, pathname, ACPI_WARN_ALWAYS,
155 					    "Insufficient arguments - "
156 					    "ASL declared %u, ACPI requires %u",
157 					    aml_param_count,
158 					    required_param_count));
159 	} else if ((aml_param_count > required_param_count)
160 		   && !(predefined->info.
161 			argument_list & ARG_COUNT_IS_MINIMUM)) {
162 		ACPI_BIOS_ERROR_PREDEFINED((AE_INFO, pathname, ACPI_WARN_ALWAYS,
163 					    "Excess arguments - "
164 					    "ASL declared %u, ACPI requires %u",
165 					    aml_param_count,
166 					    required_param_count));
167 	}
168 }
169 
170 /*******************************************************************************
171  *
172  * FUNCTION:    acpi_ns_check_argument_count
173  *
174  * PARAMETERS:  pathname        - Full pathname to the node (for error msgs)
175  *              node            - Namespace node for the method/object
176  *              user_param_count - Number of args passed in by the caller
177  *              predefined      - Pointer to entry in predefined name table
178  *
179  * RETURN:      None
180  *
181  * DESCRIPTION: Check that incoming argument count matches the declared
182  *              parameter count (in the ASL/AML) for an object.
183  *
184  ******************************************************************************/
185 
186 void
acpi_ns_check_argument_count(char * pathname,struct acpi_namespace_node * node,u32 user_param_count,const union acpi_predefined_info * predefined)187 acpi_ns_check_argument_count(char *pathname,
188 			     struct acpi_namespace_node *node,
189 			     u32 user_param_count,
190 			     const union acpi_predefined_info *predefined)
191 {
192 	u32 aml_param_count;
193 	u32 required_param_count;
194 
195 	if (node->flags & ANOBJ_EVALUATED) {
196 		return;
197 	}
198 
199 	if (!predefined) {
200 		/*
201 		 * Not a predefined name. Check the incoming user argument count
202 		 * against the count that is specified in the method/object.
203 		 */
204 		if (node->type != ACPI_TYPE_METHOD) {
205 			if (user_param_count) {
206 				ACPI_INFO_PREDEFINED((AE_INFO, pathname,
207 						      ACPI_WARN_ALWAYS,
208 						      "%u arguments were passed to a non-method ACPI object (%s)",
209 						      user_param_count,
210 						      acpi_ut_get_type_name
211 						      (node->type)));
212 			}
213 
214 			return;
215 		}
216 
217 		/*
218 		 * This is a control method. Check the parameter count.
219 		 * We can only check the incoming argument count against the
220 		 * argument count declared for the method in the ASL/AML.
221 		 *
222 		 * Emit a message if too few or too many arguments have been passed
223 		 * by the caller.
224 		 *
225 		 * Note: Too many arguments will not cause the method to
226 		 * fail. However, the method will fail if there are too few
227 		 * arguments and the method attempts to use one of the missing ones.
228 		 */
229 		aml_param_count = node->object->method.param_count;
230 
231 		if (user_param_count < aml_param_count) {
232 			ACPI_WARN_PREDEFINED((AE_INFO, pathname,
233 					      ACPI_WARN_ALWAYS,
234 					      "Insufficient arguments - "
235 					      "Caller passed %u, method requires %u",
236 					      user_param_count,
237 					      aml_param_count));
238 		} else if (user_param_count > aml_param_count) {
239 			ACPI_INFO_PREDEFINED((AE_INFO, pathname,
240 					      ACPI_WARN_ALWAYS,
241 					      "Excess arguments - "
242 					      "Caller passed %u, method requires %u",
243 					      user_param_count,
244 					      aml_param_count));
245 		}
246 
247 		return;
248 	}
249 
250 	/*
251 	 * This is a predefined name. Validate the user-supplied parameter
252 	 * count against the ACPI specification. We don't validate against
253 	 * the method itself because what is important here is that the
254 	 * caller is in conformance with the spec. (The arg count for the
255 	 * method was checked against the ACPI spec earlier.)
256 	 *
257 	 * Some methods are allowed to have a "minimum" number of args (_SCP)
258 	 * because their definition in ACPI has changed over time.
259 	 */
260 	required_param_count =
261 	    METHOD_GET_ARG_COUNT(predefined->info.argument_list);
262 
263 	if (user_param_count < required_param_count) {
264 		ACPI_WARN_PREDEFINED((AE_INFO, pathname, ACPI_WARN_ALWAYS,
265 				      "Insufficient arguments - "
266 				      "Caller passed %u, ACPI requires %u",
267 				      user_param_count, required_param_count));
268 	} else if ((user_param_count > required_param_count) &&
269 		   !(predefined->info.argument_list & ARG_COUNT_IS_MINIMUM)) {
270 		ACPI_INFO_PREDEFINED((AE_INFO, pathname, ACPI_WARN_ALWAYS,
271 				      "Excess arguments - "
272 				      "Caller passed %u, ACPI requires %u",
273 				      user_param_count, required_param_count));
274 	}
275 }
276