1 /******************************************************************************
2  *
3  * Module Name: exconfig - Namespace reconfiguration (Load/Unload opcodes)
4  *
5  *****************************************************************************/
6 
7 /******************************************************************************
8  *
9  * 1. Copyright Notice
10  *
11  * Some or all of this work - Copyright (c) 1999 - 2018, Intel Corp.
12  * All rights reserved.
13  *
14  * 2. License
15  *
16  * 2.1. This is your license from Intel Corp. under its intellectual property
17  * rights. You may have additional license terms from the party that provided
18  * you this software, covering your right to use that party's intellectual
19  * property rights.
20  *
21  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
22  * copy of the source code appearing in this file ("Covered Code") an
23  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
24  * base code distributed originally by Intel ("Original Intel Code") to copy,
25  * make derivatives, distribute, use and display any portion of the Covered
26  * Code in any form, with the right to sublicense such rights; and
27  *
28  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
29  * license (with the right to sublicense), under only those claims of Intel
30  * patents that are infringed by the Original Intel Code, to make, use, sell,
31  * offer to sell, and import the Covered Code and derivative works thereof
32  * solely to the minimum extent necessary to exercise the above copyright
33  * license, and in no event shall the patent license extend to any additions
34  * to or modifications of the Original Intel Code. No other license or right
35  * is granted directly or by implication, estoppel or otherwise;
36  *
37  * The above copyright and patent license is granted only if the following
38  * conditions are met:
39  *
40  * 3. Conditions
41  *
42  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
43  * Redistribution of source code of any substantial portion of the Covered
44  * Code or modification with rights to further distribute source must include
45  * the above Copyright Notice, the above License, this list of Conditions,
46  * and the following Disclaimer and Export Compliance provision. In addition,
47  * Licensee must cause all Covered Code to which Licensee contributes to
48  * contain a file documenting the changes Licensee made to create that Covered
49  * Code and the date of any change. Licensee must include in that file the
50  * documentation of any changes made by any predecessor Licensee. Licensee
51  * must include a prominent statement that the modification is derived,
52  * directly or indirectly, from Original Intel Code.
53  *
54  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
55  * Redistribution of source code of any substantial portion of the Covered
56  * Code or modification without rights to further distribute source must
57  * include the following Disclaimer and Export Compliance provision in the
58  * documentation and/or other materials provided with distribution. In
59  * addition, Licensee may not authorize further sublicense of source of any
60  * portion of the Covered Code, and must include terms to the effect that the
61  * license from Licensee to its licensee is limited to the intellectual
62  * property embodied in the software Licensee provides to its licensee, and
63  * not to intellectual property embodied in modifications its licensee may
64  * make.
65  *
66  * 3.3. Redistribution of Executable. Redistribution in executable form of any
67  * substantial portion of the Covered Code or modification must reproduce the
68  * above Copyright Notice, and the following Disclaimer and Export Compliance
69  * provision in the documentation and/or other materials provided with the
70  * distribution.
71  *
72  * 3.4. Intel retains all right, title, and interest in and to the Original
73  * Intel Code.
74  *
75  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
76  * Intel shall be used in advertising or otherwise to promote the sale, use or
77  * other dealings in products derived from or relating to the Covered Code
78  * without prior written authorization from Intel.
79  *
80  * 4. Disclaimer and Export Compliance
81  *
82  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
83  * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
84  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
85  * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
86 
87  * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
88  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
89  * PARTICULAR PURPOSE.
90  *
91  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
92  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
93  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
94  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
95  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
96  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
97  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
98  * LIMITED REMEDY.
99  *
100  * 4.3. Licensee shall not export, either directly or indirectly, any of this
101  * software or system incorporating such software without first obtaining any
102  * required license or other approval from the U. S. Department of Commerce or
103  * any other agency or department of the United States Government. In the
104  * event Licensee exports any such software from the United States or
105  * re-exports any such software from a foreign destination, Licensee shall
106  * ensure that the distribution and export/re-export of the software is in
107  * compliance with all laws, regulations, orders, or other restrictions of the
108  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
109  * any of its subsidiaries will export/re-export any technical data, process,
110  * software, or service, directly or indirectly, to any country for which the
111  * United States government or any agency thereof requires an export license,
112  * other governmental approval, or letter of assurance, without first obtaining
113  * such license, approval or letter.
114  *
115  *****************************************************************************
116  *
117  * Alternatively, you may choose to be licensed under the terms of the
118  * following license:
119  *
120  * Redistribution and use in source and binary forms, with or without
121  * modification, are permitted provided that the following conditions
122  * are met:
123  * 1. Redistributions of source code must retain the above copyright
124  *    notice, this list of conditions, and the following disclaimer,
125  *    without modification.
126  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
127  *    substantially similar to the "NO WARRANTY" disclaimer below
128  *    ("Disclaimer") and any redistribution must be conditioned upon
129  *    including a substantially similar Disclaimer requirement for further
130  *    binary redistribution.
131  * 3. Neither the names of the above-listed copyright holders nor the names
132  *    of any contributors may be used to endorse or promote products derived
133  *    from this software without specific prior written permission.
134  *
135  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
136  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
137  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
138  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
139  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
140  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
141  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
142  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
143  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
144  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
145  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
146  *
147  * Alternatively, you may choose to be licensed under the terms of the
148  * GNU General Public License ("GPL") version 2 as published by the Free
149  * Software Foundation.
150  *
151  *****************************************************************************/
152 
153 #include "acpi.h"
154 #include "accommon.h"
155 #include "acinterp.h"
156 #include "acnamesp.h"
157 #include "actables.h"
158 #include "acdispat.h"
159 #include "acevents.h"
160 #include "amlcode.h"
161 
162 
163 #define _COMPONENT          ACPI_EXECUTER
164         ACPI_MODULE_NAME    ("exconfig")
165 
166 /* Local prototypes */
167 
168 static ACPI_STATUS
169 AcpiExAddTable (
170     UINT32                  TableIndex,
171     ACPI_OPERAND_OBJECT     **DdbHandle);
172 
173 static ACPI_STATUS
174 AcpiExRegionRead (
175     ACPI_OPERAND_OBJECT     *ObjDesc,
176     UINT32                  Length,
177     UINT8                   *Buffer);
178 
179 
180 /*******************************************************************************
181  *
182  * FUNCTION:    AcpiExAddTable
183  *
184  * PARAMETERS:  Table               - Pointer to raw table
185  *              ParentNode          - Where to load the table (scope)
186  *              DdbHandle           - Where to return the table handle.
187  *
188  * RETURN:      Status
189  *
190  * DESCRIPTION: Common function to Install and Load an ACPI table with a
191  *              returned table handle.
192  *
193  ******************************************************************************/
194 
195 static ACPI_STATUS
AcpiExAddTable(UINT32 TableIndex,ACPI_OPERAND_OBJECT ** DdbHandle)196 AcpiExAddTable (
197     UINT32                  TableIndex,
198     ACPI_OPERAND_OBJECT     **DdbHandle)
199 {
200     ACPI_OPERAND_OBJECT     *ObjDesc;
201 
202 
203     ACPI_FUNCTION_TRACE (ExAddTable);
204 
205 
206     /* Create an object to be the table handle */
207 
208     ObjDesc = AcpiUtCreateInternalObject (ACPI_TYPE_LOCAL_REFERENCE);
209     if (!ObjDesc)
210     {
211         return_ACPI_STATUS (AE_NO_MEMORY);
212     }
213 
214     /* Init the table handle */
215 
216     ObjDesc->Common.Flags |= AOPOBJ_DATA_VALID;
217     ObjDesc->Reference.Class = ACPI_REFCLASS_TABLE;
218     ObjDesc->Reference.Value = TableIndex;
219     *DdbHandle = ObjDesc;
220     return_ACPI_STATUS (AE_OK);
221 }
222 
223 
224 /*******************************************************************************
225  *
226  * FUNCTION:    AcpiExLoadTableOp
227  *
228  * PARAMETERS:  WalkState           - Current state with operands
229  *              ReturnDesc          - Where to store the return object
230  *
231  * RETURN:      Status
232  *
233  * DESCRIPTION: Load an ACPI table from the RSDT/XSDT
234  *
235  ******************************************************************************/
236 
237 ACPI_STATUS
AcpiExLoadTableOp(ACPI_WALK_STATE * WalkState,ACPI_OPERAND_OBJECT ** ReturnDesc)238 AcpiExLoadTableOp (
239     ACPI_WALK_STATE         *WalkState,
240     ACPI_OPERAND_OBJECT     **ReturnDesc)
241 {
242     ACPI_STATUS             Status;
243     ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];
244     ACPI_NAMESPACE_NODE     *ParentNode;
245     ACPI_NAMESPACE_NODE     *StartNode;
246     ACPI_NAMESPACE_NODE     *ParameterNode = NULL;
247     ACPI_OPERAND_OBJECT     *DdbHandle;
248     UINT32                  TableIndex;
249 
250 
251     ACPI_FUNCTION_TRACE (ExLoadTableOp);
252 
253 
254     /* Find the ACPI table in the RSDT/XSDT */
255 
256     AcpiExExitInterpreter ();
257     Status = AcpiTbFindTable (
258         Operand[0]->String.Pointer,
259         Operand[1]->String.Pointer,
260         Operand[2]->String.Pointer, &TableIndex);
261     AcpiExEnterInterpreter ();
262     if (ACPI_FAILURE (Status))
263     {
264         if (Status != AE_NOT_FOUND)
265         {
266             return_ACPI_STATUS (Status);
267         }
268 
269         /* Table not found, return an Integer=0 and AE_OK */
270 
271         DdbHandle = AcpiUtCreateIntegerObject ((UINT64) 0);
272         if (!DdbHandle)
273         {
274             return_ACPI_STATUS (AE_NO_MEMORY);
275         }
276 
277         *ReturnDesc = DdbHandle;
278         return_ACPI_STATUS (AE_OK);
279     }
280 
281     /* Default nodes */
282 
283     StartNode = WalkState->ScopeInfo->Scope.Node;
284     ParentNode = AcpiGbl_RootNode;
285 
286     /* RootPath (optional parameter) */
287 
288     if (Operand[3]->String.Length > 0)
289     {
290         /*
291          * Find the node referenced by the RootPathString. This is the
292          * location within the namespace where the table will be loaded.
293          */
294         Status = AcpiNsGetNodeUnlocked (StartNode,
295             Operand[3]->String.Pointer, ACPI_NS_SEARCH_PARENT,
296             &ParentNode);
297         if (ACPI_FAILURE (Status))
298         {
299             return_ACPI_STATUS (Status);
300         }
301     }
302 
303     /* ParameterPath (optional parameter) */
304 
305     if (Operand[4]->String.Length > 0)
306     {
307         if ((Operand[4]->String.Pointer[0] != AML_ROOT_PREFIX) &&
308             (Operand[4]->String.Pointer[0] != AML_PARENT_PREFIX))
309         {
310             /*
311              * Path is not absolute, so it will be relative to the node
312              * referenced by the RootPathString (or the NS root if omitted)
313              */
314             StartNode = ParentNode;
315         }
316 
317         /* Find the node referenced by the ParameterPathString */
318 
319         Status = AcpiNsGetNodeUnlocked (StartNode,
320             Operand[4]->String.Pointer, ACPI_NS_SEARCH_PARENT,
321             &ParameterNode);
322         if (ACPI_FAILURE (Status))
323         {
324             return_ACPI_STATUS (Status);
325         }
326     }
327 
328     /* Load the table into the namespace */
329 
330     ACPI_INFO (("Dynamic OEM Table Load:"));
331     AcpiExExitInterpreter ();
332     Status = AcpiTbLoadTable (TableIndex, ParentNode);
333     AcpiExEnterInterpreter ();
334     if (ACPI_FAILURE (Status))
335     {
336         return_ACPI_STATUS (Status);
337     }
338 
339     Status = AcpiExAddTable (TableIndex, &DdbHandle);
340     if (ACPI_FAILURE (Status))
341     {
342         return_ACPI_STATUS (Status);
343     }
344 
345     /* Complete the initialization/resolution of package objects */
346 
347     Status = AcpiNsWalkNamespace (ACPI_TYPE_PACKAGE, ACPI_ROOT_OBJECT,
348         ACPI_UINT32_MAX, 0, AcpiNsInitOnePackage, NULL, NULL, NULL);
349 
350     /* Parameter Data (optional) */
351 
352     if (ParameterNode)
353     {
354         /* Store the parameter data into the optional parameter object */
355 
356         Status = AcpiExStore (Operand[5],
357             ACPI_CAST_PTR (ACPI_OPERAND_OBJECT, ParameterNode), WalkState);
358         if (ACPI_FAILURE (Status))
359         {
360             (void) AcpiExUnloadTable (DdbHandle);
361 
362             AcpiUtRemoveReference (DdbHandle);
363             return_ACPI_STATUS (Status);
364         }
365     }
366 
367     *ReturnDesc = DdbHandle;
368     return_ACPI_STATUS (Status);
369 }
370 
371 
372 /*******************************************************************************
373  *
374  * FUNCTION:    AcpiExRegionRead
375  *
376  * PARAMETERS:  ObjDesc         - Region descriptor
377  *              Length          - Number of bytes to read
378  *              Buffer          - Pointer to where to put the data
379  *
380  * RETURN:      Status
381  *
382  * DESCRIPTION: Read data from an operation region. The read starts from the
383  *              beginning of the region.
384  *
385  ******************************************************************************/
386 
387 static ACPI_STATUS
AcpiExRegionRead(ACPI_OPERAND_OBJECT * ObjDesc,UINT32 Length,UINT8 * Buffer)388 AcpiExRegionRead (
389     ACPI_OPERAND_OBJECT     *ObjDesc,
390     UINT32                  Length,
391     UINT8                   *Buffer)
392 {
393     ACPI_STATUS             Status;
394     UINT64                  Value;
395     UINT32                  RegionOffset = 0;
396     UINT32                  i;
397 
398 
399     /* Bytewise reads */
400 
401     for (i = 0; i < Length; i++)
402     {
403         Status = AcpiEvAddressSpaceDispatch (ObjDesc, NULL, ACPI_READ,
404             RegionOffset, 8, &Value);
405         if (ACPI_FAILURE (Status))
406         {
407             return (Status);
408         }
409 
410         *Buffer = (UINT8) Value;
411         Buffer++;
412         RegionOffset++;
413     }
414 
415     return (AE_OK);
416 }
417 
418 
419 /*******************************************************************************
420  *
421  * FUNCTION:    AcpiExLoadOp
422  *
423  * PARAMETERS:  ObjDesc         - Region or Buffer/Field where the table will be
424  *                                obtained
425  *              Target          - Where a handle to the table will be stored
426  *              WalkState       - Current state
427  *
428  * RETURN:      Status
429  *
430  * DESCRIPTION: Load an ACPI table from a field or operation region
431  *
432  * NOTE: Region Fields (Field, BankField, IndexFields) are resolved to buffer
433  *       objects before this code is reached.
434  *
435  *       If source is an operation region, it must refer to SystemMemory, as
436  *       per the ACPI specification.
437  *
438  ******************************************************************************/
439 
440 ACPI_STATUS
AcpiExLoadOp(ACPI_OPERAND_OBJECT * ObjDesc,ACPI_OPERAND_OBJECT * Target,ACPI_WALK_STATE * WalkState)441 AcpiExLoadOp (
442     ACPI_OPERAND_OBJECT     *ObjDesc,
443     ACPI_OPERAND_OBJECT     *Target,
444     ACPI_WALK_STATE         *WalkState)
445 {
446     ACPI_OPERAND_OBJECT     *DdbHandle;
447     ACPI_TABLE_HEADER       *TableHeader;
448     ACPI_TABLE_HEADER       *Table;
449     UINT32                  TableIndex;
450     ACPI_STATUS             Status;
451     UINT32                  Length;
452 
453 
454     ACPI_FUNCTION_TRACE (ExLoadOp);
455 
456 
457     /* Source Object can be either an OpRegion or a Buffer/Field */
458 
459     switch (ObjDesc->Common.Type)
460     {
461     case ACPI_TYPE_REGION:
462 
463         ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
464             "Load table from Region %p\n", ObjDesc));
465 
466         /* Region must be SystemMemory (from ACPI spec) */
467 
468         if (ObjDesc->Region.SpaceId != ACPI_ADR_SPACE_SYSTEM_MEMORY)
469         {
470             return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
471         }
472 
473         /*
474          * If the Region Address and Length have not been previously
475          * evaluated, evaluate them now and save the results.
476          */
477         if (!(ObjDesc->Common.Flags & AOPOBJ_DATA_VALID))
478         {
479             Status = AcpiDsGetRegionArguments (ObjDesc);
480             if (ACPI_FAILURE (Status))
481             {
482                 return_ACPI_STATUS (Status);
483             }
484         }
485 
486         /* Get the table header first so we can get the table length */
487 
488         TableHeader = ACPI_ALLOCATE (sizeof (ACPI_TABLE_HEADER));
489         if (!TableHeader)
490         {
491             return_ACPI_STATUS (AE_NO_MEMORY);
492         }
493 
494         Status = AcpiExRegionRead (ObjDesc, sizeof (ACPI_TABLE_HEADER),
495             ACPI_CAST_PTR (UINT8, TableHeader));
496         Length = TableHeader->Length;
497         ACPI_FREE (TableHeader);
498 
499         if (ACPI_FAILURE (Status))
500         {
501             return_ACPI_STATUS (Status);
502         }
503 
504         /* Must have at least an ACPI table header */
505 
506         if (Length < sizeof (ACPI_TABLE_HEADER))
507         {
508             return_ACPI_STATUS (AE_INVALID_TABLE_LENGTH);
509         }
510 
511         /*
512          * The original implementation simply mapped the table, with no copy.
513          * However, the memory region is not guaranteed to remain stable and
514          * we must copy the table to a local buffer. For example, the memory
515          * region is corrupted after suspend on some machines. Dynamically
516          * loaded tables are usually small, so this overhead is minimal.
517          *
518          * The latest implementation (5/2009) does not use a mapping at all.
519          * We use the low-level operation region interface to read the table
520          * instead of the obvious optimization of using a direct mapping.
521          * This maintains a consistent use of operation regions across the
522          * entire subsystem. This is important if additional processing must
523          * be performed in the (possibly user-installed) operation region
524          * handler. For example, AcpiExec and ASLTS depend on this.
525          */
526 
527         /* Allocate a buffer for the table */
528 
529         Table = ACPI_ALLOCATE (Length);
530         if (!Table)
531         {
532             return_ACPI_STATUS (AE_NO_MEMORY);
533         }
534 
535         /* Read the entire table */
536 
537         Status = AcpiExRegionRead (ObjDesc, Length,
538             ACPI_CAST_PTR (UINT8, Table));
539         if (ACPI_FAILURE (Status))
540         {
541             ACPI_FREE (Table);
542             return_ACPI_STATUS (Status);
543         }
544         break;
545 
546     case ACPI_TYPE_BUFFER: /* Buffer or resolved RegionField */
547 
548         ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
549             "Load table from Buffer or Field %p\n", ObjDesc));
550 
551         /* Must have at least an ACPI table header */
552 
553         if (ObjDesc->Buffer.Length < sizeof (ACPI_TABLE_HEADER))
554         {
555             return_ACPI_STATUS (AE_INVALID_TABLE_LENGTH);
556         }
557 
558         /* Get the actual table length from the table header */
559 
560         TableHeader = ACPI_CAST_PTR (
561             ACPI_TABLE_HEADER, ObjDesc->Buffer.Pointer);
562         Length = TableHeader->Length;
563 
564         /* Table cannot extend beyond the buffer */
565 
566         if (Length > ObjDesc->Buffer.Length)
567         {
568             return_ACPI_STATUS (AE_AML_BUFFER_LIMIT);
569         }
570         if (Length < sizeof (ACPI_TABLE_HEADER))
571         {
572             return_ACPI_STATUS (AE_INVALID_TABLE_LENGTH);
573         }
574 
575         /*
576          * Copy the table from the buffer because the buffer could be
577          * modified or even deleted in the future
578          */
579         Table = ACPI_ALLOCATE (Length);
580         if (!Table)
581         {
582             return_ACPI_STATUS (AE_NO_MEMORY);
583         }
584 
585         memcpy (Table, TableHeader, Length);
586         break;
587 
588     default:
589 
590         return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
591     }
592 
593     /* Install the new table into the local data structures */
594 
595     ACPI_INFO (("Dynamic OEM Table Load:"));
596     AcpiExExitInterpreter ();
597     Status = AcpiTbInstallAndLoadTable (ACPI_PTR_TO_PHYSADDR (Table),
598         ACPI_TABLE_ORIGIN_INTERNAL_VIRTUAL, TRUE, &TableIndex);
599     AcpiExEnterInterpreter ();
600     if (ACPI_FAILURE (Status))
601     {
602         /* Delete allocated table buffer */
603 
604         ACPI_FREE (Table);
605         return_ACPI_STATUS (Status);
606     }
607 
608     /*
609      * Add the table to the namespace.
610      *
611      * Note: Load the table objects relative to the root of the namespace.
612      * This appears to go against the ACPI specification, but we do it for
613      * compatibility with other ACPI implementations.
614      */
615     Status = AcpiExAddTable (TableIndex, &DdbHandle);
616     if (ACPI_FAILURE (Status))
617     {
618         /* On error, TablePtr was deallocated above */
619 
620         return_ACPI_STATUS (Status);
621     }
622 
623     /* Complete the initialization/resolution of package objects */
624 
625     Status = AcpiNsWalkNamespace (ACPI_TYPE_PACKAGE, ACPI_ROOT_OBJECT,
626         ACPI_UINT32_MAX, 0, AcpiNsInitOnePackage, NULL, NULL, NULL);
627 
628     /* Store the DdbHandle into the Target operand */
629 
630     Status = AcpiExStore (DdbHandle, Target, WalkState);
631     if (ACPI_FAILURE (Status))
632     {
633         (void) AcpiExUnloadTable (DdbHandle);
634 
635         /* TablePtr was deallocated above */
636 
637         AcpiUtRemoveReference (DdbHandle);
638         return_ACPI_STATUS (Status);
639     }
640 
641     /* Remove the reference by added by AcpiExStore above */
642 
643     AcpiUtRemoveReference (DdbHandle);
644     return_ACPI_STATUS (Status);
645 }
646 
647 
648 /*******************************************************************************
649  *
650  * FUNCTION:    AcpiExUnloadTable
651  *
652  * PARAMETERS:  DdbHandle           - Handle to a previously loaded table
653  *
654  * RETURN:      Status
655  *
656  * DESCRIPTION: Unload an ACPI table
657  *
658  ******************************************************************************/
659 
660 ACPI_STATUS
AcpiExUnloadTable(ACPI_OPERAND_OBJECT * DdbHandle)661 AcpiExUnloadTable (
662     ACPI_OPERAND_OBJECT     *DdbHandle)
663 {
664     ACPI_STATUS             Status = AE_OK;
665     ACPI_OPERAND_OBJECT     *TableDesc = DdbHandle;
666     UINT32                  TableIndex;
667 
668 
669     ACPI_FUNCTION_TRACE (ExUnloadTable);
670 
671 
672     /*
673      * Temporarily emit a warning so that the ASL for the machine can be
674      * hopefully obtained. This is to say that the Unload() operator is
675      * extremely rare if not completely unused.
676      */
677     ACPI_WARNING ((AE_INFO,
678         "Received request to unload an ACPI table"));
679 
680     /*
681      * May 2018: Unload is no longer supported for the following reasons:
682      * 1) A correct implementation on some hosts may not be possible.
683      * 2) Other ACPI implementations do not correctly/fully support it.
684      * 3) It requires host device driver support which does not exist.
685      *    (To properly support namespace unload out from underneath.)
686      * 4) This AML operator has never been seen in the field.
687      */
688     ACPI_EXCEPTION ((AE_INFO, AE_NOT_IMPLEMENTED,
689         "AML Unload operator is not supported"));
690 
691     /*
692      * Validate the handle
693      * Although the handle is partially validated in AcpiExReconfiguration()
694      * when it calls AcpiExResolveOperands(), the handle is more completely
695      * validated here.
696      *
697      * Handle must be a valid operand object of type reference. Also, the
698      * DdbHandle must still be marked valid (table has not been previously
699      * unloaded)
700      */
701     if ((!DdbHandle) ||
702         (ACPI_GET_DESCRIPTOR_TYPE (DdbHandle) != ACPI_DESC_TYPE_OPERAND) ||
703         (DdbHandle->Common.Type != ACPI_TYPE_LOCAL_REFERENCE) ||
704         (!(DdbHandle->Common.Flags & AOPOBJ_DATA_VALID)))
705     {
706         return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
707     }
708 
709     /* Get the table index from the DdbHandle */
710 
711     TableIndex = TableDesc->Reference.Value;
712 
713     /*
714      * Release the interpreter lock so that the table lock won't have
715      * strict order requirement against it.
716      */
717     AcpiExExitInterpreter ();
718     Status = AcpiTbUnloadTable (TableIndex);
719     AcpiExEnterInterpreter ();
720 
721     /*
722      * Invalidate the handle. We do this because the handle may be stored
723      * in a named object and may not be actually deleted until much later.
724      */
725     if (ACPI_SUCCESS (Status))
726     {
727         DdbHandle->Common.Flags &= ~AOPOBJ_DATA_VALID;
728     }
729     return_ACPI_STATUS (Status);
730 }
731