xref: /titanic_41/usr/src/uts/intel/io/acpica/parser/psparse.c (revision de5d74c22760a6d2cefd94d0e7f0fd87214fb71f)
1 /******************************************************************************
2  *
3  * Module Name: psparse - Parser top level AML parse routines
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 /*
45  * Parse the AML and build an operation tree as most interpreters,
46  * like Perl, do. Parsing is done by hand rather than with a YACC
47  * generated parser to tightly constrain stack and dynamic memory
48  * usage. At the same time, parsing is kept flexible and the code
49  * fairly compact by parsing based on a list of AML opcode
50  * templates in AmlOpInfo[]
51  */
52 
53 #include "acpi.h"
54 #include "accommon.h"
55 #include "acparser.h"
56 #include "acdispat.h"
57 #include "amlcode.h"
58 #include "acinterp.h"
59 
60 #define _COMPONENT          ACPI_PARSER
61         ACPI_MODULE_NAME    ("psparse")
62 
63 
64 /*******************************************************************************
65  *
66  * FUNCTION:    AcpiPsGetOpcodeSize
67  *
68  * PARAMETERS:  Opcode          - An AML opcode
69  *
70  * RETURN:      Size of the opcode, in bytes (1 or 2)
71  *
72  * DESCRIPTION: Get the size of the current opcode.
73  *
74  ******************************************************************************/
75 
76 UINT32
AcpiPsGetOpcodeSize(UINT32 Opcode)77 AcpiPsGetOpcodeSize (
78     UINT32                  Opcode)
79 {
80 
81     /* Extended (2-byte) opcode if > 255 */
82 
83     if (Opcode > 0x00FF)
84     {
85         return (2);
86     }
87 
88     /* Otherwise, just a single byte opcode */
89 
90     return (1);
91 }
92 
93 
94 /*******************************************************************************
95  *
96  * FUNCTION:    AcpiPsPeekOpcode
97  *
98  * PARAMETERS:  ParserState         - A parser state object
99  *
100  * RETURN:      Next AML opcode
101  *
102  * DESCRIPTION: Get next AML opcode (without incrementing AML pointer)
103  *
104  ******************************************************************************/
105 
106 UINT16
AcpiPsPeekOpcode(ACPI_PARSE_STATE * ParserState)107 AcpiPsPeekOpcode (
108     ACPI_PARSE_STATE        *ParserState)
109 {
110     UINT8                   *Aml;
111     UINT16                  Opcode;
112 
113 
114     Aml = ParserState->Aml;
115     Opcode = (UINT16) ACPI_GET8 (Aml);
116 
117     if (Opcode == AML_EXTENDED_OP_PREFIX)
118     {
119         /* Extended opcode, get the second opcode byte */
120 
121         Aml++;
122         Opcode = (UINT16) ((Opcode << 8) | ACPI_GET8 (Aml));
123     }
124 
125     return (Opcode);
126 }
127 
128 
129 /*******************************************************************************
130  *
131  * FUNCTION:    AcpiPsCompleteThisOp
132  *
133  * PARAMETERS:  WalkState       - Current State
134  *              Op              - Op to complete
135  *
136  * RETURN:      Status
137  *
138  * DESCRIPTION: Perform any cleanup at the completion of an Op.
139  *
140  ******************************************************************************/
141 
142 ACPI_STATUS
AcpiPsCompleteThisOp(ACPI_WALK_STATE * WalkState,ACPI_PARSE_OBJECT * Op)143 AcpiPsCompleteThisOp (
144     ACPI_WALK_STATE         *WalkState,
145     ACPI_PARSE_OBJECT       *Op)
146 {
147     ACPI_PARSE_OBJECT       *Prev;
148     ACPI_PARSE_OBJECT       *Next;
149     const ACPI_OPCODE_INFO  *ParentInfo;
150     ACPI_PARSE_OBJECT       *ReplacementOp = NULL;
151     ACPI_STATUS             Status = AE_OK;
152 
153 
154     ACPI_FUNCTION_TRACE_PTR (PsCompleteThisOp, Op);
155 
156 
157     /* Check for null Op, can happen if AML code is corrupt */
158 
159     if (!Op)
160     {
161         return_ACPI_STATUS (AE_OK);  /* OK for now */
162     }
163 
164     AcpiExStopTraceOpcode (Op, WalkState);
165 
166     /* Delete this op and the subtree below it if asked to */
167 
168     if (((WalkState->ParseFlags & ACPI_PARSE_TREE_MASK) != ACPI_PARSE_DELETE_TREE) ||
169          (WalkState->OpInfo->Class == AML_CLASS_ARGUMENT))
170     {
171         return_ACPI_STATUS (AE_OK);
172     }
173 
174     /* Make sure that we only delete this subtree */
175 
176     if (Op->Common.Parent)
177     {
178         Prev = Op->Common.Parent->Common.Value.Arg;
179         if (!Prev)
180         {
181             /* Nothing more to do */
182 
183             goto Cleanup;
184         }
185 
186         /*
187          * Check if we need to replace the operator and its subtree
188          * with a return value op (placeholder op)
189          */
190         ParentInfo = AcpiPsGetOpcodeInfo (Op->Common.Parent->Common.AmlOpcode);
191 
192         switch (ParentInfo->Class)
193         {
194         case AML_CLASS_CONTROL:
195 
196             break;
197 
198         case AML_CLASS_CREATE:
199             /*
200              * These opcodes contain TermArg operands. The current
201              * op must be replaced by a placeholder return op
202              */
203             ReplacementOp = AcpiPsAllocOp (
204                 AML_INT_RETURN_VALUE_OP, Op->Common.Aml);
205             if (!ReplacementOp)
206             {
207                 Status = AE_NO_MEMORY;
208             }
209             break;
210 
211         case AML_CLASS_NAMED_OBJECT:
212             /*
213              * These opcodes contain TermArg operands. The current
214              * op must be replaced by a placeholder return op
215              */
216             if ((Op->Common.Parent->Common.AmlOpcode == AML_REGION_OP)       ||
217                 (Op->Common.Parent->Common.AmlOpcode == AML_DATA_REGION_OP)  ||
218                 (Op->Common.Parent->Common.AmlOpcode == AML_BUFFER_OP)       ||
219                 (Op->Common.Parent->Common.AmlOpcode == AML_PACKAGE_OP)      ||
220                 (Op->Common.Parent->Common.AmlOpcode == AML_BANK_FIELD_OP)   ||
221                 (Op->Common.Parent->Common.AmlOpcode == AML_VAR_PACKAGE_OP))
222             {
223                 ReplacementOp = AcpiPsAllocOp (
224                     AML_INT_RETURN_VALUE_OP, Op->Common.Aml);
225                 if (!ReplacementOp)
226                 {
227                     Status = AE_NO_MEMORY;
228                 }
229             }
230             else if ((Op->Common.Parent->Common.AmlOpcode == AML_NAME_OP) &&
231                      (WalkState->PassNumber <= ACPI_IMODE_LOAD_PASS2))
232             {
233                 if ((Op->Common.AmlOpcode == AML_BUFFER_OP) ||
234                     (Op->Common.AmlOpcode == AML_PACKAGE_OP) ||
235                     (Op->Common.AmlOpcode == AML_VAR_PACKAGE_OP))
236                 {
237                     ReplacementOp = AcpiPsAllocOp (Op->Common.AmlOpcode,
238                         Op->Common.Aml);
239                     if (!ReplacementOp)
240                     {
241                         Status = AE_NO_MEMORY;
242                     }
243                     else
244                     {
245                         ReplacementOp->Named.Data = Op->Named.Data;
246                         ReplacementOp->Named.Length = Op->Named.Length;
247                     }
248                 }
249             }
250             break;
251 
252         default:
253 
254             ReplacementOp = AcpiPsAllocOp (
255                 AML_INT_RETURN_VALUE_OP, Op->Common.Aml);
256             if (!ReplacementOp)
257             {
258                 Status = AE_NO_MEMORY;
259             }
260         }
261 
262         /* We must unlink this op from the parent tree */
263 
264         if (Prev == Op)
265         {
266             /* This op is the first in the list */
267 
268             if (ReplacementOp)
269             {
270                 ReplacementOp->Common.Parent = Op->Common.Parent;
271                 ReplacementOp->Common.Value.Arg = NULL;
272                 ReplacementOp->Common.Node = Op->Common.Node;
273                 Op->Common.Parent->Common.Value.Arg = ReplacementOp;
274                 ReplacementOp->Common.Next = Op->Common.Next;
275             }
276             else
277             {
278                 Op->Common.Parent->Common.Value.Arg = Op->Common.Next;
279             }
280         }
281 
282         /* Search the parent list */
283 
284         else while (Prev)
285         {
286             /* Traverse all siblings in the parent's argument list */
287 
288             Next = Prev->Common.Next;
289             if (Next == Op)
290             {
291                 if (ReplacementOp)
292                 {
293                     ReplacementOp->Common.Parent = Op->Common.Parent;
294                     ReplacementOp->Common.Value.Arg = NULL;
295                     ReplacementOp->Common.Node = Op->Common.Node;
296                     Prev->Common.Next = ReplacementOp;
297                     ReplacementOp->Common.Next = Op->Common.Next;
298                     Next = NULL;
299                 }
300                 else
301                 {
302                     Prev->Common.Next = Op->Common.Next;
303                     Next = NULL;
304                 }
305             }
306             Prev = Next;
307         }
308     }
309 
310 
311 Cleanup:
312 
313     /* Now we can actually delete the subtree rooted at Op */
314 
315     AcpiPsDeleteParseTree (Op);
316     return_ACPI_STATUS (Status);
317 }
318 
319 
320 /*******************************************************************************
321  *
322  * FUNCTION:    AcpiPsNextParseState
323  *
324  * PARAMETERS:  WalkState           - Current state
325  *              Op                  - Current parse op
326  *              CallbackStatus      - Status from previous operation
327  *
328  * RETURN:      Status
329  *
330  * DESCRIPTION: Update the parser state based upon the return exception from
331  *              the parser callback.
332  *
333  ******************************************************************************/
334 
335 ACPI_STATUS
AcpiPsNextParseState(ACPI_WALK_STATE * WalkState,ACPI_PARSE_OBJECT * Op,ACPI_STATUS CallbackStatus)336 AcpiPsNextParseState (
337     ACPI_WALK_STATE         *WalkState,
338     ACPI_PARSE_OBJECT       *Op,
339     ACPI_STATUS             CallbackStatus)
340 {
341     ACPI_PARSE_STATE        *ParserState = &WalkState->ParserState;
342     ACPI_STATUS             Status = AE_CTRL_PENDING;
343 
344 
345     ACPI_FUNCTION_TRACE_PTR (PsNextParseState, Op);
346 
347 
348     switch (CallbackStatus)
349     {
350     case AE_CTRL_TERMINATE:
351         /*
352          * A control method was terminated via a RETURN statement.
353          * The walk of this method is complete.
354          */
355         ParserState->Aml = ParserState->AmlEnd;
356         Status = AE_CTRL_TERMINATE;
357         break;
358 
359     case AE_CTRL_BREAK:
360 
361         ParserState->Aml = WalkState->AmlLastWhile;
362         WalkState->ControlState->Common.Value = FALSE;
363         Status = AE_CTRL_BREAK;
364         break;
365 
366     case AE_CTRL_CONTINUE:
367 
368         ParserState->Aml = WalkState->AmlLastWhile;
369         Status = AE_CTRL_CONTINUE;
370         break;
371 
372     case AE_CTRL_PENDING:
373 
374         ParserState->Aml = WalkState->AmlLastWhile;
375         break;
376 
377 #if 0
378     case AE_CTRL_SKIP:
379 
380         ParserState->Aml = ParserState->Scope->ParseScope.PkgEnd;
381         Status = AE_OK;
382         break;
383 #endif
384 
385     case AE_CTRL_TRUE:
386         /*
387          * Predicate of an IF was true, and we are at the matching ELSE.
388          * Just close out this package
389          */
390         ParserState->Aml = AcpiPsGetNextPackageEnd (ParserState);
391         Status = AE_CTRL_PENDING;
392         break;
393 
394     case AE_CTRL_FALSE:
395         /*
396          * Either an IF/WHILE Predicate was false or we encountered a BREAK
397          * opcode. In both cases, we do not execute the rest of the
398          * package;  We simply close out the parent (finishing the walk of
399          * this branch of the tree) and continue execution at the parent
400          * level.
401          */
402         ParserState->Aml = ParserState->Scope->ParseScope.PkgEnd;
403 
404         /* In the case of a BREAK, just force a predicate (if any) to FALSE */
405 
406         WalkState->ControlState->Common.Value = FALSE;
407         Status = AE_CTRL_END;
408         break;
409 
410     case AE_CTRL_TRANSFER:
411 
412         /* A method call (invocation) -- transfer control */
413 
414         Status = AE_CTRL_TRANSFER;
415         WalkState->PrevOp = Op;
416         WalkState->MethodCallOp = Op;
417         WalkState->MethodCallNode = (Op->Common.Value.Arg)->Common.Node;
418 
419         /* Will return value (if any) be used by the caller? */
420 
421         WalkState->ReturnUsed = AcpiDsIsResultUsed (Op, WalkState);
422         break;
423 
424     default:
425 
426         Status = CallbackStatus;
427         if ((CallbackStatus & AE_CODE_MASK) == AE_CODE_CONTROL)
428         {
429             Status = AE_OK;
430         }
431         break;
432     }
433 
434     return_ACPI_STATUS (Status);
435 }
436 
437 
438 /*******************************************************************************
439  *
440  * FUNCTION:    AcpiPsParseAml
441  *
442  * PARAMETERS:  WalkState       - Current state
443  *
444  *
445  * RETURN:      Status
446  *
447  * DESCRIPTION: Parse raw AML and return a tree of ops
448  *
449  ******************************************************************************/
450 
451 ACPI_STATUS
AcpiPsParseAml(ACPI_WALK_STATE * WalkState)452 AcpiPsParseAml (
453     ACPI_WALK_STATE         *WalkState)
454 {
455     ACPI_STATUS             Status;
456     ACPI_THREAD_STATE       *Thread;
457     ACPI_THREAD_STATE       *PrevWalkList = AcpiGbl_CurrentWalkList;
458     ACPI_WALK_STATE         *PreviousWalkState;
459 
460 
461     ACPI_FUNCTION_TRACE (PsParseAml);
462 
463     ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
464         "Entered with WalkState=%p Aml=%p size=%X\n",
465         WalkState, WalkState->ParserState.Aml,
466         WalkState->ParserState.AmlSize));
467 
468     if (!WalkState->ParserState.Aml)
469     {
470         return_ACPI_STATUS (AE_NULL_OBJECT);
471     }
472 
473     /* Create and initialize a new thread state */
474 
475     Thread = AcpiUtCreateThreadState ();
476     if (!Thread)
477     {
478         if (WalkState->MethodDesc)
479         {
480             /* Executing a control method - additional cleanup */
481 
482             AcpiDsTerminateControlMethod (WalkState->MethodDesc, WalkState);
483         }
484 
485         AcpiDsDeleteWalkState (WalkState);
486         return_ACPI_STATUS (AE_NO_MEMORY);
487     }
488 
489     WalkState->Thread = Thread;
490 
491     /*
492      * If executing a method, the starting SyncLevel is this method's
493      * SyncLevel
494      */
495     if (WalkState->MethodDesc)
496     {
497         WalkState->Thread->CurrentSyncLevel =
498             WalkState->MethodDesc->Method.SyncLevel;
499     }
500 
501     AcpiDsPushWalkState (WalkState, Thread);
502 
503     /*
504      * This global allows the AML debugger to get a handle to the currently
505      * executing control method.
506      */
507     AcpiGbl_CurrentWalkList = Thread;
508 
509     /*
510      * Execute the walk loop as long as there is a valid Walk State. This
511      * handles nested control method invocations without recursion.
512      */
513     ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "State=%p\n", WalkState));
514 
515     Status = AE_OK;
516     while (WalkState)
517     {
518         if (ACPI_SUCCESS (Status))
519         {
520             /*
521              * The ParseLoop executes AML until the method terminates
522              * or calls another method.
523              */
524             Status = AcpiPsParseLoop (WalkState);
525         }
526 
527         ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
528             "Completed one call to walk loop, %s State=%p\n",
529             AcpiFormatException (Status), WalkState));
530 
531         if (Status == AE_CTRL_TRANSFER)
532         {
533             /*
534              * A method call was detected.
535              * Transfer control to the called control method
536              */
537             Status = AcpiDsCallControlMethod (Thread, WalkState, NULL);
538             if (ACPI_FAILURE (Status))
539             {
540                 Status = AcpiDsMethodError (Status, WalkState);
541             }
542 
543             /*
544              * If the transfer to the new method method call worked
545              *, a new walk state was created -- get it
546              */
547             WalkState = AcpiDsGetCurrentWalkState (Thread);
548             continue;
549         }
550         else if (Status == AE_CTRL_TERMINATE)
551         {
552             Status = AE_OK;
553         }
554         else if ((Status != AE_OK) && (WalkState->MethodDesc))
555         {
556             /* Either the method parse or actual execution failed */
557 
558             ACPI_ERROR_METHOD ("Method parse/execution failed",
559                 WalkState->MethodNode, NULL, Status);
560 
561             /* Check for possible multi-thread reentrancy problem */
562 
563             if ((Status == AE_ALREADY_EXISTS) &&
564                 (!(WalkState->MethodDesc->Method.InfoFlags &
565                     ACPI_METHOD_SERIALIZED)))
566             {
567                 /*
568                  * Method is not serialized and tried to create an object
569                  * twice. The probable cause is that the method cannot
570                  * handle reentrancy. Mark as "pending serialized" now, and
571                  * then mark "serialized" when the last thread exits.
572                  */
573                 WalkState->MethodDesc->Method.InfoFlags |=
574                     ACPI_METHOD_SERIALIZED_PENDING;
575             }
576         }
577 
578         /* We are done with this walk, move on to the parent if any */
579 
580         WalkState = AcpiDsPopWalkState (Thread);
581 
582         /* Reset the current scope to the beginning of scope stack */
583 
584         AcpiDsScopeStackClear (WalkState);
585 
586         /*
587          * If we just returned from the execution of a control method or if we
588          * encountered an error during the method parse phase, there's lots of
589          * cleanup to do
590          */
591         if (((WalkState->ParseFlags & ACPI_PARSE_MODE_MASK) ==
592             ACPI_PARSE_EXECUTE) ||
593             (ACPI_FAILURE (Status)))
594         {
595             AcpiDsTerminateControlMethod (WalkState->MethodDesc, WalkState);
596         }
597 
598         /* Delete this walk state and all linked control states */
599 
600         AcpiPsCleanupScope (&WalkState->ParserState);
601         PreviousWalkState = WalkState;
602 
603         ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
604             "ReturnValue=%p, ImplicitValue=%p State=%p\n",
605             WalkState->ReturnDesc, WalkState->ImplicitReturnObj, WalkState));
606 
607         /* Check if we have restarted a preempted walk */
608 
609         WalkState = AcpiDsGetCurrentWalkState (Thread);
610         if (WalkState)
611         {
612             if (ACPI_SUCCESS (Status))
613             {
614                 /*
615                  * There is another walk state, restart it.
616                  * If the method return value is not used by the parent,
617                  * The object is deleted
618                  */
619                 if (!PreviousWalkState->ReturnDesc)
620                 {
621                     /*
622                      * In slack mode execution, if there is no return value
623                      * we should implicitly return zero (0) as a default value.
624                      */
625                     if (AcpiGbl_EnableInterpreterSlack &&
626                         !PreviousWalkState->ImplicitReturnObj)
627                     {
628                         PreviousWalkState->ImplicitReturnObj =
629                             AcpiUtCreateIntegerObject ((UINT64) 0);
630                         if (!PreviousWalkState->ImplicitReturnObj)
631                         {
632                             return_ACPI_STATUS (AE_NO_MEMORY);
633                         }
634                     }
635 
636                     /* Restart the calling control method */
637 
638                     Status = AcpiDsRestartControlMethod (WalkState,
639                         PreviousWalkState->ImplicitReturnObj);
640                 }
641                 else
642                 {
643                     /*
644                      * We have a valid return value, delete any implicit
645                      * return value.
646                      */
647                     AcpiDsClearImplicitReturn (PreviousWalkState);
648 
649                     Status = AcpiDsRestartControlMethod (WalkState,
650                         PreviousWalkState->ReturnDesc);
651                 }
652                 if (ACPI_SUCCESS (Status))
653                 {
654                     WalkState->WalkType |= ACPI_WALK_METHOD_RESTART;
655                 }
656             }
657             else
658             {
659                 /* On error, delete any return object or implicit return */
660 
661                 AcpiUtRemoveReference (PreviousWalkState->ReturnDesc);
662                 AcpiDsClearImplicitReturn (PreviousWalkState);
663             }
664         }
665 
666         /*
667          * Just completed a 1st-level method, save the final internal return
668          * value (if any)
669          */
670         else if (PreviousWalkState->CallerReturnDesc)
671         {
672             if (PreviousWalkState->ImplicitReturnObj)
673             {
674                 *(PreviousWalkState->CallerReturnDesc) =
675                     PreviousWalkState->ImplicitReturnObj;
676             }
677             else
678             {
679                  /* NULL if no return value */
680 
681                 *(PreviousWalkState->CallerReturnDesc) =
682                     PreviousWalkState->ReturnDesc;
683             }
684         }
685         else
686         {
687             if (PreviousWalkState->ReturnDesc)
688             {
689                 /* Caller doesn't want it, must delete it */
690 
691                 AcpiUtRemoveReference (PreviousWalkState->ReturnDesc);
692             }
693             if (PreviousWalkState->ImplicitReturnObj)
694             {
695                 /* Caller doesn't want it, must delete it */
696 
697                 AcpiUtRemoveReference (PreviousWalkState->ImplicitReturnObj);
698             }
699         }
700 
701         AcpiDsDeleteWalkState (PreviousWalkState);
702     }
703 
704     /* Normal exit */
705 
706     AcpiExReleaseAllMutexes (Thread);
707     AcpiUtDeleteGenericState (ACPI_CAST_PTR (ACPI_GENERIC_STATE, Thread));
708     AcpiGbl_CurrentWalkList = PrevWalkList;
709     return_ACPI_STATUS (Status);
710 }
711