]>
Commit | Line | Data |
---|---|---|
95857638 | 1 | // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0 |
29a241cc BM |
2 | /****************************************************************************** |
3 | * | |
4 | * Module Name: nsarguments - Validation of args for ACPI predefined methods | |
5 | * | |
800ba7c5 | 6 | * Copyright (C) 2000 - 2020, Intel Corp. |
29a241cc | 7 | * |
95857638 | 8 | *****************************************************************************/ |
29a241cc BM |
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 | ******************************************************************************/ | |
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 | ||
a62a7117 BM |
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)) { | |
29a241cc BM |
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 | ||
4d584037 BM |
58 | /* No typechecking for ACPI_TYPE_ANY */ |
59 | ||
60 | if ((user_arg_type != arg_type) && (arg_type != ACPI_TYPE_ANY)) { | |
29a241cc BM |
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))); | |
a62a7117 BM |
69 | |
70 | /* Prevent any additional typechecking for this method */ | |
71 | ||
72 | info->node->flags |= ANOBJ_EVALUATED; | |
29a241cc BM |
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 | |
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 | ||
a62a7117 | 101 | if (!predefined || (node->flags & ANOBJ_EVALUATED)) { |
29a241cc BM |
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 | |
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 | ||
a62a7117 BM |
195 | if (node->flags & ANOBJ_EVALUATED) { |
196 | return; | |
197 | } | |
198 | ||
29a241cc BM |
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 | } |