1 /****************************************************************************** 2 * 3 * Module Name: exconfig - Namespace reconfiguration (Load/Unload opcodes) 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2014, 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 "acinterp.h" 47 #include "acnamesp.h" 48 #include "actables.h" 49 #include "acdispat.h" 50 #include "acevents.h" 51 #include "amlcode.h" 52 53 #define _COMPONENT ACPI_EXECUTER 54 ACPI_MODULE_NAME("exconfig") 55 56 /* Local prototypes */ 57 static acpi_status 58 acpi_ex_add_table(u32 table_index, 59 struct acpi_namespace_node *parent_node, 60 union acpi_operand_object **ddb_handle); 61 62 static acpi_status 63 acpi_ex_region_read(union acpi_operand_object *obj_desc, 64 u32 length, u8 *buffer); 65 66 /******************************************************************************* 67 * 68 * FUNCTION: acpi_ex_add_table 69 * 70 * PARAMETERS: table - Pointer to raw table 71 * parent_node - Where to load the table (scope) 72 * ddb_handle - Where to return the table handle. 73 * 74 * RETURN: Status 75 * 76 * DESCRIPTION: Common function to Install and Load an ACPI table with a 77 * returned table handle. 78 * 79 ******************************************************************************/ 80 81 static acpi_status 82 acpi_ex_add_table(u32 table_index, 83 struct acpi_namespace_node *parent_node, 84 union acpi_operand_object **ddb_handle) 85 { 86 union acpi_operand_object *obj_desc; 87 acpi_status status; 88 acpi_owner_id owner_id; 89 90 ACPI_FUNCTION_TRACE(ex_add_table); 91 92 /* Create an object to be the table handle */ 93 94 obj_desc = acpi_ut_create_internal_object(ACPI_TYPE_LOCAL_REFERENCE); 95 if (!obj_desc) { 96 return_ACPI_STATUS(AE_NO_MEMORY); 97 } 98 99 /* Init the table handle */ 100 101 obj_desc->common.flags |= AOPOBJ_DATA_VALID; 102 obj_desc->reference.class = ACPI_REFCLASS_TABLE; 103 *ddb_handle = obj_desc; 104 105 /* Install the new table into the local data structures */ 106 107 obj_desc->reference.value = table_index; 108 109 /* Add the table to the namespace */ 110 111 status = acpi_ns_load_table(table_index, parent_node); 112 if (ACPI_FAILURE(status)) { 113 acpi_ut_remove_reference(obj_desc); 114 *ddb_handle = NULL; 115 return_ACPI_STATUS(status); 116 } 117 118 /* Execute any module-level code that was found in the table */ 119 120 acpi_ex_exit_interpreter(); 121 acpi_ns_exec_module_code_list(); 122 acpi_ex_enter_interpreter(); 123 124 /* 125 * Update GPEs for any new _Lxx/_Exx methods. Ignore errors. The host is 126 * responsible for discovering any new wake GPEs by running _PRW methods 127 * that may have been loaded by this table. 128 */ 129 status = acpi_tb_get_owner_id(table_index, &owner_id); 130 if (ACPI_SUCCESS(status)) { 131 acpi_ev_update_gpes(owner_id); 132 } 133 134 return_ACPI_STATUS(AE_OK); 135 } 136 137 /******************************************************************************* 138 * 139 * FUNCTION: acpi_ex_load_table_op 140 * 141 * PARAMETERS: walk_state - Current state with operands 142 * return_desc - Where to store the return object 143 * 144 * RETURN: Status 145 * 146 * DESCRIPTION: Load an ACPI table from the RSDT/XSDT 147 * 148 ******************************************************************************/ 149 150 acpi_status 151 acpi_ex_load_table_op(struct acpi_walk_state *walk_state, 152 union acpi_operand_object **return_desc) 153 { 154 acpi_status status; 155 union acpi_operand_object **operand = &walk_state->operands[0]; 156 struct acpi_namespace_node *parent_node; 157 struct acpi_namespace_node *start_node; 158 struct acpi_namespace_node *parameter_node = NULL; 159 union acpi_operand_object *ddb_handle; 160 struct acpi_table_header *table; 161 u32 table_index; 162 163 ACPI_FUNCTION_TRACE(ex_load_table_op); 164 165 /* Validate lengths for the Signature, oem_id, and oem_table_id strings */ 166 167 if ((operand[0]->string.length > ACPI_NAME_SIZE) || 168 (operand[1]->string.length > ACPI_OEM_ID_SIZE) || 169 (operand[2]->string.length > ACPI_OEM_TABLE_ID_SIZE)) { 170 return_ACPI_STATUS(AE_AML_STRING_LIMIT); 171 } 172 173 /* Find the ACPI table in the RSDT/XSDT */ 174 175 status = acpi_tb_find_table(operand[0]->string.pointer, 176 operand[1]->string.pointer, 177 operand[2]->string.pointer, &table_index); 178 if (ACPI_FAILURE(status)) { 179 if (status != AE_NOT_FOUND) { 180 return_ACPI_STATUS(status); 181 } 182 183 /* Table not found, return an Integer=0 and AE_OK */ 184 185 ddb_handle = acpi_ut_create_integer_object((u64) 0); 186 if (!ddb_handle) { 187 return_ACPI_STATUS(AE_NO_MEMORY); 188 } 189 190 *return_desc = ddb_handle; 191 return_ACPI_STATUS(AE_OK); 192 } 193 194 /* Default nodes */ 195 196 start_node = walk_state->scope_info->scope.node; 197 parent_node = acpi_gbl_root_node; 198 199 /* root_path (optional parameter) */ 200 201 if (operand[3]->string.length > 0) { 202 /* 203 * Find the node referenced by the root_path_string. This is the 204 * location within the namespace where the table will be loaded. 205 */ 206 status = 207 acpi_ns_get_node(start_node, operand[3]->string.pointer, 208 ACPI_NS_SEARCH_PARENT, &parent_node); 209 if (ACPI_FAILURE(status)) { 210 return_ACPI_STATUS(status); 211 } 212 } 213 214 /* parameter_path (optional parameter) */ 215 216 if (operand[4]->string.length > 0) { 217 if ((operand[4]->string.pointer[0] != AML_ROOT_PREFIX) && 218 (operand[4]->string.pointer[0] != AML_PARENT_PREFIX)) { 219 /* 220 * Path is not absolute, so it will be relative to the node 221 * referenced by the root_path_string (or the NS root if omitted) 222 */ 223 start_node = parent_node; 224 } 225 226 /* Find the node referenced by the parameter_path_string */ 227 228 status = 229 acpi_ns_get_node(start_node, operand[4]->string.pointer, 230 ACPI_NS_SEARCH_PARENT, ¶meter_node); 231 if (ACPI_FAILURE(status)) { 232 return_ACPI_STATUS(status); 233 } 234 } 235 236 /* Load the table into the namespace */ 237 238 status = acpi_ex_add_table(table_index, parent_node, &ddb_handle); 239 if (ACPI_FAILURE(status)) { 240 return_ACPI_STATUS(status); 241 } 242 243 /* Parameter Data (optional) */ 244 245 if (parameter_node) { 246 247 /* Store the parameter data into the optional parameter object */ 248 249 status = acpi_ex_store(operand[5], 250 ACPI_CAST_PTR(union acpi_operand_object, 251 parameter_node), 252 walk_state); 253 if (ACPI_FAILURE(status)) { 254 (void)acpi_ex_unload_table(ddb_handle); 255 256 acpi_ut_remove_reference(ddb_handle); 257 return_ACPI_STATUS(status); 258 } 259 } 260 261 status = acpi_get_table_by_index(table_index, &table); 262 if (ACPI_SUCCESS(status)) { 263 ACPI_INFO((AE_INFO, "Dynamic OEM Table Load:")); 264 acpi_tb_print_table_header(0, table); 265 } 266 267 /* Invoke table handler if present */ 268 269 if (acpi_gbl_table_handler) { 270 (void)acpi_gbl_table_handler(ACPI_TABLE_EVENT_LOAD, table, 271 acpi_gbl_table_handler_context); 272 } 273 274 *return_desc = ddb_handle; 275 return_ACPI_STATUS(status); 276 } 277 278 /******************************************************************************* 279 * 280 * FUNCTION: acpi_ex_region_read 281 * 282 * PARAMETERS: obj_desc - Region descriptor 283 * length - Number of bytes to read 284 * buffer - Pointer to where to put the data 285 * 286 * RETURN: Status 287 * 288 * DESCRIPTION: Read data from an operation region. The read starts from the 289 * beginning of the region. 290 * 291 ******************************************************************************/ 292 293 static acpi_status 294 acpi_ex_region_read(union acpi_operand_object *obj_desc, u32 length, u8 *buffer) 295 { 296 acpi_status status; 297 u64 value; 298 u32 region_offset = 0; 299 u32 i; 300 301 /* Bytewise reads */ 302 303 for (i = 0; i < length; i++) { 304 status = 305 acpi_ev_address_space_dispatch(obj_desc, NULL, ACPI_READ, 306 region_offset, 8, &value); 307 if (ACPI_FAILURE(status)) { 308 return (status); 309 } 310 311 *buffer = (u8)value; 312 buffer++; 313 region_offset++; 314 } 315 316 return (AE_OK); 317 } 318 319 /******************************************************************************* 320 * 321 * FUNCTION: acpi_ex_load_op 322 * 323 * PARAMETERS: obj_desc - Region or Buffer/Field where the table will be 324 * obtained 325 * target - Where a handle to the table will be stored 326 * walk_state - Current state 327 * 328 * RETURN: Status 329 * 330 * DESCRIPTION: Load an ACPI table from a field or operation region 331 * 332 * NOTE: Region Fields (Field, bank_field, index_fields) are resolved to buffer 333 * objects before this code is reached. 334 * 335 * If source is an operation region, it must refer to system_memory, as 336 * per the ACPI specification. 337 * 338 ******************************************************************************/ 339 340 acpi_status 341 acpi_ex_load_op(union acpi_operand_object *obj_desc, 342 union acpi_operand_object *target, 343 struct acpi_walk_state *walk_state) 344 { 345 union acpi_operand_object *ddb_handle; 346 struct acpi_table_header *table_header; 347 struct acpi_table_header *table; 348 u32 table_index; 349 acpi_status status; 350 u32 length; 351 352 ACPI_FUNCTION_TRACE(ex_load_op); 353 354 /* Source Object can be either an op_region or a Buffer/Field */ 355 356 switch (obj_desc->common.type) { 357 case ACPI_TYPE_REGION: 358 359 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, 360 "Load table from Region %p\n", obj_desc)); 361 362 /* Region must be system_memory (from ACPI spec) */ 363 364 if (obj_desc->region.space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY) { 365 return_ACPI_STATUS(AE_AML_OPERAND_TYPE); 366 } 367 368 /* 369 * If the Region Address and Length have not been previously evaluated, 370 * evaluate them now and save the results. 371 */ 372 if (!(obj_desc->common.flags & AOPOBJ_DATA_VALID)) { 373 status = acpi_ds_get_region_arguments(obj_desc); 374 if (ACPI_FAILURE(status)) { 375 return_ACPI_STATUS(status); 376 } 377 } 378 379 /* Get the table header first so we can get the table length */ 380 381 table_header = ACPI_ALLOCATE(sizeof(struct acpi_table_header)); 382 if (!table_header) { 383 return_ACPI_STATUS(AE_NO_MEMORY); 384 } 385 386 status = 387 acpi_ex_region_read(obj_desc, 388 sizeof(struct acpi_table_header), 389 ACPI_CAST_PTR(u8, table_header)); 390 length = table_header->length; 391 ACPI_FREE(table_header); 392 393 if (ACPI_FAILURE(status)) { 394 return_ACPI_STATUS(status); 395 } 396 397 /* Must have at least an ACPI table header */ 398 399 if (length < sizeof(struct acpi_table_header)) { 400 return_ACPI_STATUS(AE_INVALID_TABLE_LENGTH); 401 } 402 403 /* 404 * The original implementation simply mapped the table, with no copy. 405 * However, the memory region is not guaranteed to remain stable and 406 * we must copy the table to a local buffer. For example, the memory 407 * region is corrupted after suspend on some machines. Dynamically 408 * loaded tables are usually small, so this overhead is minimal. 409 * 410 * The latest implementation (5/2009) does not use a mapping at all. 411 * We use the low-level operation region interface to read the table 412 * instead of the obvious optimization of using a direct mapping. 413 * This maintains a consistent use of operation regions across the 414 * entire subsystem. This is important if additional processing must 415 * be performed in the (possibly user-installed) operation region 416 * handler. For example, acpi_exec and ASLTS depend on this. 417 */ 418 419 /* Allocate a buffer for the table */ 420 421 table = ACPI_ALLOCATE(length); 422 if (!table) { 423 return_ACPI_STATUS(AE_NO_MEMORY); 424 } 425 426 /* Read the entire table */ 427 428 status = acpi_ex_region_read(obj_desc, length, 429 ACPI_CAST_PTR(u8, table)); 430 if (ACPI_FAILURE(status)) { 431 ACPI_FREE(table); 432 return_ACPI_STATUS(status); 433 } 434 break; 435 436 case ACPI_TYPE_BUFFER: /* Buffer or resolved region_field */ 437 438 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, 439 "Load table from Buffer or Field %p\n", 440 obj_desc)); 441 442 /* Must have at least an ACPI table header */ 443 444 if (obj_desc->buffer.length < sizeof(struct acpi_table_header)) { 445 return_ACPI_STATUS(AE_INVALID_TABLE_LENGTH); 446 } 447 448 /* Get the actual table length from the table header */ 449 450 table_header = 451 ACPI_CAST_PTR(struct acpi_table_header, 452 obj_desc->buffer.pointer); 453 length = table_header->length; 454 455 /* Table cannot extend beyond the buffer */ 456 457 if (length > obj_desc->buffer.length) { 458 return_ACPI_STATUS(AE_AML_BUFFER_LIMIT); 459 } 460 if (length < sizeof(struct acpi_table_header)) { 461 return_ACPI_STATUS(AE_INVALID_TABLE_LENGTH); 462 } 463 464 /* 465 * Copy the table from the buffer because the buffer could be modified 466 * or even deleted in the future 467 */ 468 table = ACPI_ALLOCATE(length); 469 if (!table) { 470 return_ACPI_STATUS(AE_NO_MEMORY); 471 } 472 473 ACPI_MEMCPY(table, table_header, length); 474 break; 475 476 default: 477 478 return_ACPI_STATUS(AE_AML_OPERAND_TYPE); 479 } 480 481 /* Install the new table into the local data structures */ 482 483 ACPI_INFO((AE_INFO, "Dynamic OEM Table Load:")); 484 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES); 485 486 status = acpi_tb_install_standard_table(ACPI_PTR_TO_PHYSADDR(table), 487 ACPI_TABLE_ORIGIN_INTERNAL_VIRTUAL, 488 TRUE, TRUE, &table_index); 489 490 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES); 491 if (ACPI_FAILURE(status)) { 492 493 /* Delete allocated table buffer */ 494 495 ACPI_FREE(table); 496 return_ACPI_STATUS(status); 497 } 498 499 /* 500 * Note: Now table is "INSTALLED", it must be validated before 501 * loading. 502 */ 503 status = 504 acpi_tb_validate_table(&acpi_gbl_root_table_list. 505 tables[table_index]); 506 if (ACPI_FAILURE(status)) { 507 return_ACPI_STATUS(status); 508 } 509 510 /* 511 * Add the table to the namespace. 512 * 513 * Note: Load the table objects relative to the root of the namespace. 514 * This appears to go against the ACPI specification, but we do it for 515 * compatibility with other ACPI implementations. 516 */ 517 status = 518 acpi_ex_add_table(table_index, acpi_gbl_root_node, &ddb_handle); 519 if (ACPI_FAILURE(status)) { 520 521 /* On error, table_ptr was deallocated above */ 522 523 return_ACPI_STATUS(status); 524 } 525 526 /* Store the ddb_handle into the Target operand */ 527 528 status = acpi_ex_store(ddb_handle, target, walk_state); 529 if (ACPI_FAILURE(status)) { 530 (void)acpi_ex_unload_table(ddb_handle); 531 532 /* table_ptr was deallocated above */ 533 534 acpi_ut_remove_reference(ddb_handle); 535 return_ACPI_STATUS(status); 536 } 537 538 /* Remove the reference by added by acpi_ex_store above */ 539 540 acpi_ut_remove_reference(ddb_handle); 541 542 /* Invoke table handler if present */ 543 544 if (acpi_gbl_table_handler) { 545 (void)acpi_gbl_table_handler(ACPI_TABLE_EVENT_LOAD, table, 546 acpi_gbl_table_handler_context); 547 } 548 549 return_ACPI_STATUS(status); 550 } 551 552 /******************************************************************************* 553 * 554 * FUNCTION: acpi_ex_unload_table 555 * 556 * PARAMETERS: ddb_handle - Handle to a previously loaded table 557 * 558 * RETURN: Status 559 * 560 * DESCRIPTION: Unload an ACPI table 561 * 562 ******************************************************************************/ 563 564 acpi_status acpi_ex_unload_table(union acpi_operand_object *ddb_handle) 565 { 566 acpi_status status = AE_OK; 567 union acpi_operand_object *table_desc = ddb_handle; 568 u32 table_index; 569 struct acpi_table_header *table; 570 571 ACPI_FUNCTION_TRACE(ex_unload_table); 572 573 /* 574 * Temporarily emit a warning so that the ASL for the machine can be 575 * hopefully obtained. This is to say that the Unload() operator is 576 * extremely rare if not completely unused. 577 */ 578 ACPI_WARNING((AE_INFO, "Received request to unload an ACPI table")); 579 580 /* 581 * Validate the handle 582 * Although the handle is partially validated in acpi_ex_reconfiguration() 583 * when it calls acpi_ex_resolve_operands(), the handle is more completely 584 * validated here. 585 * 586 * Handle must be a valid operand object of type reference. Also, the 587 * ddb_handle must still be marked valid (table has not been previously 588 * unloaded) 589 */ 590 if ((!ddb_handle) || 591 (ACPI_GET_DESCRIPTOR_TYPE(ddb_handle) != ACPI_DESC_TYPE_OPERAND) || 592 (ddb_handle->common.type != ACPI_TYPE_LOCAL_REFERENCE) || 593 (!(ddb_handle->common.flags & AOPOBJ_DATA_VALID))) { 594 return_ACPI_STATUS(AE_AML_OPERAND_TYPE); 595 } 596 597 /* Get the table index from the ddb_handle */ 598 599 table_index = table_desc->reference.value; 600 601 /* Ensure the table is still loaded */ 602 603 if (!acpi_tb_is_table_loaded(table_index)) { 604 return_ACPI_STATUS(AE_NOT_EXIST); 605 } 606 607 /* Invoke table handler if present */ 608 609 if (acpi_gbl_table_handler) { 610 status = acpi_get_table_by_index(table_index, &table); 611 if (ACPI_SUCCESS(status)) { 612 (void)acpi_gbl_table_handler(ACPI_TABLE_EVENT_UNLOAD, 613 table, 614 acpi_gbl_table_handler_context); 615 } 616 } 617 618 /* Delete the portion of the namespace owned by this table */ 619 620 status = acpi_tb_delete_namespace_by_owner(table_index); 621 if (ACPI_FAILURE(status)) { 622 return_ACPI_STATUS(status); 623 } 624 625 (void)acpi_tb_release_owner_id(table_index); 626 acpi_tb_set_table_loaded_flag(table_index, FALSE); 627 628 /* 629 * Invalidate the handle. We do this because the handle may be stored 630 * in a named object and may not be actually deleted until much later. 631 */ 632 ddb_handle->common.flags &= ~AOPOBJ_DATA_VALID; 633 return_ACPI_STATUS(AE_OK); 634 } 635