drivers/acpi/acpica/nsparse.c

   1 /******************************************************************************
   2  *
   3  * Module Name: nsparse - namespace interface to AML parser
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2016, Intel Corp.
   9  * All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions, and the following disclaimer,
  16  *    without modification.
  17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  18  *    substantially similar to the "NO WARRANTY" disclaimer below
  19  *    ("Disclaimer") and any redistribution must be conditioned upon
  20  *    including a substantially similar Disclaimer requirement for further
  21  *    binary redistribution.
  22  * 3. Neither the names of the above-listed copyright holders nor the names
  23  *    of any contributors may be used to endorse or promote products derived
  24  *    from this software without specific prior written permission.
  25  *
  26  * Alternatively, this software may be distributed under the terms of the
  27  * GNU General Public License ("GPL") version 2 as published by the Free
  28  * Software Foundation.
  29  *
  30  * NO WARRANTY
  31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  41  * POSSIBILITY OF SUCH DAMAGES.
  42  */
  43
  44 #include <acpi/acpi.h>
  45 #include "accommon.h"
  46 #include "acnamesp.h"
  47 #include "acparser.h"
  48 #include "acdispat.h"
  49 #include "actables.h"
  50 #include "acinterp.h"
  51
  52 #define _COMPONENT          ACPI_NAMESPACE
  53 ACPI_MODULE_NAME("nsparse")
  54
  55 /*******************************************************************************
  56  *
  57  * FUNCTION:    ns_execute_table
  58  *
  59  * PARAMETERS:  table_desc      - An ACPI table descriptor for table to parse
  60  *              start_node      - Where to enter the table into the namespace
  61  *
  62  * RETURN:      Status
  63  *
  64  * DESCRIPTION: Load ACPI/AML table by executing the entire table as a
  65  *              term_list.
  66  *
  67  ******************************************************************************/
  68 acpi_status
  69 acpi_ns_execute_table(u32 table_index, struct acpi_namespace_node *start_node)
  70 {
  71         acpi_status status;
  72         struct acpi_table_header *table;
  73         acpi_owner_id owner_id;
  74         struct acpi_evaluate_info *info = NULL;
  75         u32 aml_length;
  76         u8 *aml_start;
  77         union acpi_operand_object *method_obj = NULL;
  78
  79         ACPI_FUNCTION_TRACE(ns_execute_table);
  80
  81         status = acpi_get_table_by_index(table_index, &table);
  82         if (ACPI_FAILURE(status)) {
  83                 return_ACPI_STATUS(status);
  84         }
  85
  86         /* Table must consist of at least a complete header */
  87
  88         if (table->length < sizeof(struct acpi_table_header)) {
  89                 return_ACPI_STATUS(AE_BAD_HEADER);
  90         }
  91
  92         aml_start = (u8 *)table + sizeof(struct acpi_table_header);
  93         aml_length = table->length - sizeof(struct acpi_table_header);
  94
  95         status = acpi_tb_get_owner_id(table_index, &owner_id);
  96         if (ACPI_FAILURE(status)) {
  97                 return_ACPI_STATUS(status);
  98         }
  99
 100         /* Create, initialize, and link a new temporary method object */
 101
 102         method_obj = acpi_ut_create_internal_object(ACPI_TYPE_METHOD);
 103         if (!method_obj) {
 104                 return_ACPI_STATUS(AE_NO_MEMORY);
 105         }
 106
 107         /* Allocate the evaluation information block */
 108
 109         info = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_evaluate_info));
 110         if (!info) {
 111                 status = AE_NO_MEMORY;
 112                 goto cleanup;
 113         }
 114
 115         ACPI_DEBUG_PRINT((ACPI_DB_PARSE,
 116                           "Create table code block: %p\n", method_obj));
 117
 118         method_obj->method.aml_start = aml_start;
 119         method_obj->method.aml_length = aml_length;
 120         method_obj->method.owner_id = owner_id;
 121         method_obj->method.info_flags |= ACPI_METHOD_MODULE_LEVEL;
 122
 123         info->pass_number = ACPI_IMODE_EXECUTE;
 124         info->node = start_node;
 125         info->obj_desc = method_obj;
 126         info->node_flags = info->node->flags;
 127         info->full_pathname = acpi_ns_get_normalized_pathname(info->node, TRUE);
 128         if (!info->full_pathname) {
 129                 status = AE_NO_MEMORY;
 130                 goto cleanup;
 131         }
 132
 133         status = acpi_ps_execute_table(info);
 134
 135 cleanup:
 136         if (info) {
 137                 ACPI_FREE(info->full_pathname);
 138                 info->full_pathname = NULL;
 139         }
 140         ACPI_FREE(info);
 141         acpi_ut_remove_reference(method_obj);
 142         return_ACPI_STATUS(status);
 143 }
 144
 145 /*******************************************************************************
 146  *
 147  * FUNCTION:    ns_one_complete_parse
 148  *
 149  * PARAMETERS:  pass_number             - 1 or 2
 150  *              table_desc              - The table to be parsed.
 151  *
 152  * RETURN:      Status
 153  *
 154  * DESCRIPTION: Perform one complete parse of an ACPI/AML table.
 155  *
 156  ******************************************************************************/
 157
 158 acpi_status
 159 acpi_ns_one_complete_parse(u32 pass_number,
 160                            u32 table_index,
 161                            struct acpi_namespace_node *start_node)
 162 {
 163         union acpi_parse_object *parse_root;
 164         acpi_status status;
 165         u32 aml_length;
 166         u8 *aml_start;
 167         struct acpi_walk_state *walk_state;
 168         struct acpi_table_header *table;
 169         acpi_owner_id owner_id;
 170
 171         ACPI_FUNCTION_TRACE(ns_one_complete_parse);
 172
 173         status = acpi_get_table_by_index(table_index, &table);
 174         if (ACPI_FAILURE(status)) {
 175                 return_ACPI_STATUS(status);
 176         }
 177
 178         /* Table must consist of at least a complete header */
 179
 180         if (table->length < sizeof(struct acpi_table_header)) {
 181                 return_ACPI_STATUS(AE_BAD_HEADER);
 182         }
 183
 184         aml_start = (u8 *)table + sizeof(struct acpi_table_header);
 185         aml_length = table->length - sizeof(struct acpi_table_header);
 186
 187         status = acpi_tb_get_owner_id(table_index, &owner_id);
 188         if (ACPI_FAILURE(status)) {
 189                 return_ACPI_STATUS(status);
 190         }
 191
 192         /* Create and init a Root Node */
 193
 194         parse_root = acpi_ps_create_scope_op(aml_start);
 195         if (!parse_root) {
 196                 return_ACPI_STATUS(AE_NO_MEMORY);
 197         }
 198
 199         /* Create and initialize a new walk state */
 200
 201         walk_state = acpi_ds_create_walk_state(owner_id, NULL, NULL, NULL);
 202         if (!walk_state) {
 203                 acpi_ps_free_op(parse_root);
 204                 return_ACPI_STATUS(AE_NO_MEMORY);
 205         }
 206
 207         status = acpi_ds_init_aml_walk(walk_state, parse_root, NULL,
 208                                        aml_start, aml_length, NULL,
 209                                        (u8)pass_number);
 210         if (ACPI_FAILURE(status)) {
 211                 acpi_ds_delete_walk_state(walk_state);
 212                 goto cleanup;
 213         }
 214
 215         /* Found OSDT table, enable the namespace override feature */
 216
 217         if (ACPI_COMPARE_NAME(table->signature, ACPI_SIG_OSDT) &&
 218             pass_number == ACPI_IMODE_LOAD_PASS1) {
 219                 walk_state->namespace_override = TRUE;
 220         }
 221
 222         /* start_node is the default location to load the table */
 223
 224         if (start_node && start_node != acpi_gbl_root_node) {
 225                 status =
 226                     acpi_ds_scope_stack_push(start_node, ACPI_TYPE_METHOD,
 227                                              walk_state);
 228                 if (ACPI_FAILURE(status)) {
 229                         acpi_ds_delete_walk_state(walk_state);
 230                         goto cleanup;
 231                 }
 232         }
 233
 234         /* Parse the AML */
 235
 236         ACPI_DEBUG_PRINT((ACPI_DB_PARSE,
 237                           "*PARSE* pass %u parse\n", pass_number));
 238         acpi_ex_enter_interpreter();
 239         status = acpi_ps_parse_aml(walk_state);
 240         acpi_ex_exit_interpreter();
 241
 242 cleanup:
 243         acpi_ps_delete_parse_tree(parse_root);
 244         return_ACPI_STATUS(status);
 245 }
 246
 247 /*******************************************************************************
 248  *
 249  * FUNCTION:    acpi_ns_parse_table
 250  *
 251  * PARAMETERS:  table_desc      - An ACPI table descriptor for table to parse
 252  *              start_node      - Where to enter the table into the namespace
 253  *
 254  * RETURN:      Status
 255  *
 256  * DESCRIPTION: Parse AML within an ACPI table and return a tree of ops
 257  *
 258  ******************************************************************************/
 259
 260 acpi_status
 261 acpi_ns_parse_table(u32 table_index, struct acpi_namespace_node *start_node)
 262 {
 263         acpi_status status;
 264
 265         ACPI_FUNCTION_TRACE(ns_parse_table);
 266
 267         if (acpi_gbl_parse_table_as_term_list) {
 268                 ACPI_DEBUG_PRINT((ACPI_DB_PARSE, "**** Start load pass\n"));
 269
 270                 status = acpi_ns_execute_table(table_index, start_node);
 271                 if (ACPI_FAILURE(status)) {
 272                         return_ACPI_STATUS(status);
 273                 }
 274         } else {
 275                 /*
 276                  * AML Parse, pass 1
 277                  *
 278                  * In this pass, we load most of the namespace. Control methods
 279                  * are not parsed until later. A parse tree is not created.
 280                  * Instead, each Parser Op subtree is deleted when it is finished.
 281                  * This saves a great deal of memory, and allows a small cache of
 282                  * parse objects to service the entire parse. The second pass of
 283                  * the parse then performs another complete parse of the AML.
 284                  */
 285                 ACPI_DEBUG_PRINT((ACPI_DB_PARSE, "**** Start pass 1\n"));
 286
 287                 status = acpi_ns_one_complete_parse(ACPI_IMODE_LOAD_PASS1,
 288                                                     table_index, start_node);
 289                 if (ACPI_FAILURE(status)) {
 290                         return_ACPI_STATUS(status);
 291                 }
 292
 293                 /*
 294                  * AML Parse, pass 2
 295                  *
 296                  * In this pass, we resolve forward references and other things
 297                  * that could not be completed during the first pass.
 298                  * Another complete parse of the AML is performed, but the
 299                  * overhead of this is compensated for by the fact that the
 300                  * parse objects are all cached.
 301                  */
 302                 ACPI_DEBUG_PRINT((ACPI_DB_PARSE, "**** Start pass 2\n"));
 303                 status = acpi_ns_one_complete_parse(ACPI_IMODE_LOAD_PASS2,
 304                                                     table_index, start_node);
 305                 if (ACPI_FAILURE(status)) {
 306                         return_ACPI_STATUS(status);
 307                 }
 308         }
 309
 310         return_ACPI_STATUS(status);
 311 }