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 - 2021, 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 ******************************************************************************/ 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 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 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