1 /******************************************************************************
2 *
3 * Module Name: dswload2 - Dispatcher second pass namespace load callbacks
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.h"
45 #include "accommon.h"
46 #include "acparser.h"
47 #include "amlcode.h"
48 #include "acdispat.h"
49 #include "acinterp.h"
50 #include "acnamesp.h"
51 #include "acevents.h"
52
53 #define _COMPONENT ACPI_DISPATCHER
54 ACPI_MODULE_NAME ("dswload2")
55
56
57 /*******************************************************************************
58 *
59 * FUNCTION: AcpiDsLoad2BeginOp
60 *
61 * PARAMETERS: WalkState - Current state of the parse tree walk
62 * OutOp - Wher to return op if a new one is created
63 *
64 * RETURN: Status
65 *
66 * DESCRIPTION: Descending callback used during the loading of ACPI tables.
67 *
68 ******************************************************************************/
69
70 ACPI_STATUS
AcpiDsLoad2BeginOp(ACPI_WALK_STATE * WalkState,ACPI_PARSE_OBJECT ** OutOp)71 AcpiDsLoad2BeginOp (
72 ACPI_WALK_STATE *WalkState,
73 ACPI_PARSE_OBJECT **OutOp)
74 {
75 ACPI_PARSE_OBJECT *Op;
76 ACPI_NAMESPACE_NODE *Node;
77 ACPI_STATUS Status;
78 ACPI_OBJECT_TYPE ObjectType;
79 char *BufferPtr;
80 UINT32 Flags;
81
82
83 ACPI_FUNCTION_TRACE (DsLoad2BeginOp);
84
85
86 Op = WalkState->Op;
87 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Op=%p State=%p\n", Op, WalkState));
88
89 if (Op)
90 {
91 if ((WalkState->ControlState) &&
92 (WalkState->ControlState->Common.State ==
93 ACPI_CONTROL_CONDITIONAL_EXECUTING))
94 {
95 /* We are executing a while loop outside of a method */
96
97 Status = AcpiDsExecBeginOp (WalkState, OutOp);
98 return_ACPI_STATUS (Status);
99 }
100
101 /* We only care about Namespace opcodes here */
102
103 if ((!(WalkState->OpInfo->Flags & AML_NSOPCODE) &&
104 (WalkState->Opcode != AML_INT_NAMEPATH_OP)) ||
105 (!(WalkState->OpInfo->Flags & AML_NAMED)))
106 {
107 return_ACPI_STATUS (AE_OK);
108 }
109
110 /* Get the name we are going to enter or lookup in the namespace */
111
112 if (WalkState->Opcode == AML_INT_NAMEPATH_OP)
113 {
114 /* For Namepath op, get the path string */
115
116 BufferPtr = Op->Common.Value.String;
117 if (!BufferPtr)
118 {
119 /* No name, just exit */
120
121 return_ACPI_STATUS (AE_OK);
122 }
123 }
124 else
125 {
126 /* Get name from the op */
127
128 BufferPtr = ACPI_CAST_PTR (char, &Op->Named.Name);
129 }
130 }
131 else
132 {
133 /* Get the namestring from the raw AML */
134
135 BufferPtr = AcpiPsGetNextNamestring (&WalkState->ParserState);
136 }
137
138 /* Map the opcode into an internal object type */
139
140 ObjectType = WalkState->OpInfo->ObjectType;
141
142 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
143 "State=%p Op=%p Type=%X\n", WalkState, Op, ObjectType));
144
145 switch (WalkState->Opcode)
146 {
147 case AML_FIELD_OP:
148 case AML_BANK_FIELD_OP:
149 case AML_INDEX_FIELD_OP:
150
151 Node = NULL;
152 Status = AE_OK;
153 break;
154
155 case AML_INT_NAMEPATH_OP:
156 /*
157 * The NamePath is an object reference to an existing object.
158 * Don't enter the name into the namespace, but look it up
159 * for use later.
160 */
161 Status = AcpiNsLookup (WalkState->ScopeInfo, BufferPtr, ObjectType,
162 ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT,
163 WalkState, &(Node));
164 break;
165
166 case AML_SCOPE_OP:
167
168 /* Special case for Scope(\) -> refers to the Root node */
169
170 if (Op && (Op->Named.Node == AcpiGbl_RootNode))
171 {
172 Node = Op->Named.Node;
173
174 Status = AcpiDsScopeStackPush (Node, ObjectType, WalkState);
175 if (ACPI_FAILURE (Status))
176 {
177 return_ACPI_STATUS (Status);
178 }
179 }
180 else
181 {
182 /*
183 * The Path is an object reference to an existing object.
184 * Don't enter the name into the namespace, but look it up
185 * for use later.
186 */
187 Status = AcpiNsLookup (WalkState->ScopeInfo, BufferPtr, ObjectType,
188 ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT,
189 WalkState, &(Node));
190 if (ACPI_FAILURE (Status))
191 {
192 #ifdef ACPI_ASL_COMPILER
193 if (Status == AE_NOT_FOUND)
194 {
195 Status = AE_OK;
196 }
197 else
198 {
199 ACPI_ERROR_NAMESPACE (BufferPtr, Status);
200 }
201 #else
202 ACPI_ERROR_NAMESPACE (BufferPtr, Status);
203 #endif
204 return_ACPI_STATUS (Status);
205 }
206 }
207
208 /*
209 * We must check to make sure that the target is
210 * one of the opcodes that actually opens a scope
211 */
212 switch (Node->Type)
213 {
214 case ACPI_TYPE_ANY:
215 case ACPI_TYPE_LOCAL_SCOPE: /* Scope */
216 case ACPI_TYPE_DEVICE:
217 case ACPI_TYPE_POWER:
218 case ACPI_TYPE_PROCESSOR:
219 case ACPI_TYPE_THERMAL:
220
221 /* These are acceptable types */
222 break;
223
224 case ACPI_TYPE_INTEGER:
225 case ACPI_TYPE_STRING:
226 case ACPI_TYPE_BUFFER:
227
228 /*
229 * These types we will allow, but we will change the type.
230 * This enables some existing code of the form:
231 *
232 * Name (DEB, 0)
233 * Scope (DEB) { ... }
234 */
235 ACPI_WARNING ((AE_INFO,
236 "Type override - [%4.4s] had invalid type (%s) "
237 "for Scope operator, changed to type ANY",
238 AcpiUtGetNodeName (Node), AcpiUtGetTypeName (Node->Type)));
239
240 Node->Type = ACPI_TYPE_ANY;
241 WalkState->ScopeInfo->Common.Value = ACPI_TYPE_ANY;
242 break;
243
244 case ACPI_TYPE_METHOD:
245
246 /*
247 * Allow scope change to root during execution of module-level
248 * code. Root is typed METHOD during this time.
249 */
250 if ((Node == AcpiGbl_RootNode) &&
251 (WalkState->ParseFlags & ACPI_PARSE_MODULE_LEVEL))
252 {
253 break;
254 }
255
256 /*lint -fallthrough */
257
258 default:
259
260 /* All other types are an error */
261
262 ACPI_ERROR ((AE_INFO,
263 "Invalid type (%s) for target of "
264 "Scope operator [%4.4s] (Cannot override)",
265 AcpiUtGetTypeName (Node->Type), AcpiUtGetNodeName (Node)));
266
267 return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
268 }
269 break;
270
271 default:
272
273 /* All other opcodes */
274
275 if (Op && Op->Common.Node)
276 {
277 /* This op/node was previously entered into the namespace */
278
279 Node = Op->Common.Node;
280
281 if (AcpiNsOpensScope (ObjectType))
282 {
283 Status = AcpiDsScopeStackPush (Node, ObjectType, WalkState);
284 if (ACPI_FAILURE (Status))
285 {
286 return_ACPI_STATUS (Status);
287 }
288 }
289
290 return_ACPI_STATUS (AE_OK);
291 }
292
293 /*
294 * Enter the named type into the internal namespace. We enter the name
295 * as we go downward in the parse tree. Any necessary subobjects that
296 * involve arguments to the opcode must be created as we go back up the
297 * parse tree later.
298 *
299 * Note: Name may already exist if we are executing a deferred opcode.
300 */
301 if (WalkState->DeferredNode)
302 {
303 /* This name is already in the namespace, get the node */
304
305 Node = WalkState->DeferredNode;
306 Status = AE_OK;
307 break;
308 }
309
310 Flags = ACPI_NS_NO_UPSEARCH;
311 if (WalkState->PassNumber == ACPI_IMODE_EXECUTE)
312 {
313 /* Execution mode, node cannot already exist, node is temporary */
314
315 Flags |= ACPI_NS_ERROR_IF_FOUND;
316
317 if (!(WalkState->ParseFlags & ACPI_PARSE_MODULE_LEVEL))
318 {
319 Flags |= ACPI_NS_TEMPORARY;
320 }
321 }
322
323 /* Add new entry or lookup existing entry */
324
325 Status = AcpiNsLookup (WalkState->ScopeInfo, BufferPtr, ObjectType,
326 ACPI_IMODE_LOAD_PASS2, Flags, WalkState, &Node);
327
328 if (ACPI_SUCCESS (Status) && (Flags & ACPI_NS_TEMPORARY))
329 {
330 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
331 "***New Node [%4.4s] %p is temporary\n",
332 AcpiUtGetNodeName (Node), Node));
333 }
334 break;
335 }
336
337 if (ACPI_FAILURE (Status))
338 {
339 ACPI_ERROR_NAMESPACE (BufferPtr, Status);
340 return_ACPI_STATUS (Status);
341 }
342
343 if (!Op)
344 {
345 /* Create a new op */
346
347 Op = AcpiPsAllocOp (WalkState->Opcode, WalkState->Aml);
348 if (!Op)
349 {
350 return_ACPI_STATUS (AE_NO_MEMORY);
351 }
352
353 /* Initialize the new op */
354
355 if (Node)
356 {
357 Op->Named.Name = Node->Name.Integer;
358 }
359 *OutOp = Op;
360 }
361
362 /*
363 * Put the Node in the "op" object that the parser uses, so we
364 * can get it again quickly when this scope is closed
365 */
366 Op->Common.Node = Node;
367 return_ACPI_STATUS (Status);
368 }
369
370
371 /*******************************************************************************
372 *
373 * FUNCTION: AcpiDsLoad2EndOp
374 *
375 * PARAMETERS: WalkState - Current state of the parse tree walk
376 *
377 * RETURN: Status
378 *
379 * DESCRIPTION: Ascending callback used during the loading of the namespace,
380 * both control methods and everything else.
381 *
382 ******************************************************************************/
383
384 ACPI_STATUS
AcpiDsLoad2EndOp(ACPI_WALK_STATE * WalkState)385 AcpiDsLoad2EndOp (
386 ACPI_WALK_STATE *WalkState)
387 {
388 ACPI_PARSE_OBJECT *Op;
389 ACPI_STATUS Status = AE_OK;
390 ACPI_OBJECT_TYPE ObjectType;
391 ACPI_NAMESPACE_NODE *Node;
392 ACPI_PARSE_OBJECT *Arg;
393 ACPI_NAMESPACE_NODE *NewNode;
394 #ifndef ACPI_NO_METHOD_EXECUTION
395 UINT32 i;
396 UINT8 RegionSpace;
397 #endif
398
399
400 ACPI_FUNCTION_TRACE (DsLoad2EndOp);
401
402 Op = WalkState->Op;
403 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Opcode [%s] Op %p State %p\n",
404 WalkState->OpInfo->Name, Op, WalkState));
405
406 /* Check if opcode had an associated namespace object */
407
408 if (!(WalkState->OpInfo->Flags & AML_NSOBJECT))
409 {
410 return_ACPI_STATUS (AE_OK);
411 }
412
413 if (Op->Common.AmlOpcode == AML_SCOPE_OP)
414 {
415 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
416 "Ending scope Op=%p State=%p\n", Op, WalkState));
417 }
418
419 ObjectType = WalkState->OpInfo->ObjectType;
420
421 /*
422 * Get the Node/name from the earlier lookup
423 * (It was saved in the *op structure)
424 */
425 Node = Op->Common.Node;
426
427 /*
428 * Put the Node on the object stack (Contains the ACPI Name of
429 * this object)
430 */
431 WalkState->Operands[0] = (void *) Node;
432 WalkState->NumOperands = 1;
433
434 /* Pop the scope stack */
435
436 if (AcpiNsOpensScope (ObjectType) &&
437 (Op->Common.AmlOpcode != AML_INT_METHODCALL_OP))
438 {
439 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "(%s) Popping scope for Op %p\n",
440 AcpiUtGetTypeName (ObjectType), Op));
441
442 Status = AcpiDsScopeStackPop (WalkState);
443 if (ACPI_FAILURE (Status))
444 {
445 goto Cleanup;
446 }
447 }
448
449 /*
450 * Named operations are as follows:
451 *
452 * AML_ALIAS
453 * AML_BANKFIELD
454 * AML_CREATEBITFIELD
455 * AML_CREATEBYTEFIELD
456 * AML_CREATEDWORDFIELD
457 * AML_CREATEFIELD
458 * AML_CREATEQWORDFIELD
459 * AML_CREATEWORDFIELD
460 * AML_DATA_REGION
461 * AML_DEVICE
462 * AML_EVENT
463 * AML_FIELD
464 * AML_INDEXFIELD
465 * AML_METHOD
466 * AML_METHODCALL
467 * AML_MUTEX
468 * AML_NAME
469 * AML_NAMEDFIELD
470 * AML_OPREGION
471 * AML_POWERRES
472 * AML_PROCESSOR
473 * AML_SCOPE
474 * AML_THERMALZONE
475 */
476
477 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
478 "Create-Load [%s] State=%p Op=%p NamedObj=%p\n",
479 AcpiPsGetOpcodeName (Op->Common.AmlOpcode), WalkState, Op, Node));
480
481 /* Decode the opcode */
482
483 Arg = Op->Common.Value.Arg;
484
485 switch (WalkState->OpInfo->Type)
486 {
487 #ifndef ACPI_NO_METHOD_EXECUTION
488
489 case AML_TYPE_CREATE_FIELD:
490 /*
491 * Create the field object, but the field buffer and index must
492 * be evaluated later during the execution phase
493 */
494 Status = AcpiDsCreateBufferField (Op, WalkState);
495 break;
496
497 case AML_TYPE_NAMED_FIELD:
498 /*
499 * If we are executing a method, initialize the field
500 */
501 if (WalkState->MethodNode)
502 {
503 Status = AcpiDsInitFieldObjects (Op, WalkState);
504 }
505
506 switch (Op->Common.AmlOpcode)
507 {
508 case AML_INDEX_FIELD_OP:
509
510 Status = AcpiDsCreateIndexField (
511 Op, (ACPI_HANDLE) Arg->Common.Node, WalkState);
512 break;
513
514 case AML_BANK_FIELD_OP:
515
516 Status = AcpiDsCreateBankField (Op, Arg->Common.Node, WalkState);
517 break;
518
519 case AML_FIELD_OP:
520
521 Status = AcpiDsCreateField (Op, Arg->Common.Node, WalkState);
522 break;
523
524 default:
525
526 /* All NAMED_FIELD opcodes must be handled above */
527 break;
528 }
529 break;
530
531 case AML_TYPE_NAMED_SIMPLE:
532
533 Status = AcpiDsCreateOperands (WalkState, Arg);
534 if (ACPI_FAILURE (Status))
535 {
536 goto Cleanup;
537 }
538
539 switch (Op->Common.AmlOpcode)
540 {
541 case AML_PROCESSOR_OP:
542
543 Status = AcpiExCreateProcessor (WalkState);
544 break;
545
546 case AML_POWER_RES_OP:
547
548 Status = AcpiExCreatePowerResource (WalkState);
549 break;
550
551 case AML_MUTEX_OP:
552
553 Status = AcpiExCreateMutex (WalkState);
554 break;
555
556 case AML_EVENT_OP:
557
558 Status = AcpiExCreateEvent (WalkState);
559 break;
560
561 case AML_ALIAS_OP:
562
563 Status = AcpiExCreateAlias (WalkState);
564 break;
565
566 default:
567
568 /* Unknown opcode */
569
570 Status = AE_OK;
571 goto Cleanup;
572 }
573
574 /* Delete operands */
575
576 for (i = 1; i < WalkState->NumOperands; i++)
577 {
578 AcpiUtRemoveReference (WalkState->Operands[i]);
579 WalkState->Operands[i] = NULL;
580 }
581
582 break;
583 #endif /* ACPI_NO_METHOD_EXECUTION */
584
585 case AML_TYPE_NAMED_COMPLEX:
586
587 switch (Op->Common.AmlOpcode)
588 {
589 #ifndef ACPI_NO_METHOD_EXECUTION
590 case AML_REGION_OP:
591 case AML_DATA_REGION_OP:
592
593 if (Op->Common.AmlOpcode == AML_REGION_OP)
594 {
595 RegionSpace = (ACPI_ADR_SPACE_TYPE)
596 ((Op->Common.Value.Arg)->Common.Value.Integer);
597 }
598 else
599 {
600 RegionSpace = ACPI_ADR_SPACE_DATA_TABLE;
601 }
602
603 /*
604 * The OpRegion is not fully parsed at this time. The only valid
605 * argument is the SpaceId. (We must save the address of the
606 * AML of the address and length operands)
607 *
608 * If we have a valid region, initialize it. The namespace is
609 * unlocked at this point.
610 *
611 * Need to unlock interpreter if it is locked (if we are running
612 * a control method), in order to allow _REG methods to be run
613 * during AcpiEvInitializeRegion.
614 */
615 if (WalkState->MethodNode)
616 {
617 /*
618 * Executing a method: initialize the region and unlock
619 * the interpreter
620 */
621 Status = AcpiExCreateRegion (Op->Named.Data,
622 Op->Named.Length, RegionSpace, WalkState);
623 if (ACPI_FAILURE (Status))
624 {
625 return_ACPI_STATUS (Status);
626 }
627
628 AcpiExExitInterpreter ();
629 }
630
631 Status = AcpiEvInitializeRegion (
632 AcpiNsGetAttachedObject (Node), FALSE);
633 if (WalkState->MethodNode)
634 {
635 AcpiExEnterInterpreter ();
636 }
637
638 if (ACPI_FAILURE (Status))
639 {
640 /*
641 * If AE_NOT_EXIST is returned, it is not fatal
642 * because many regions get created before a handler
643 * is installed for said region.
644 */
645 if (AE_NOT_EXIST == Status)
646 {
647 Status = AE_OK;
648 }
649 }
650 break;
651
652 case AML_NAME_OP:
653
654 Status = AcpiDsCreateNode (WalkState, Node, Op);
655 break;
656
657 case AML_METHOD_OP:
658 /*
659 * MethodOp PkgLength NameString MethodFlags TermList
660 *
661 * Note: We must create the method node/object pair as soon as we
662 * see the method declaration. This allows later pass1 parsing
663 * of invocations of the method (need to know the number of
664 * arguments.)
665 */
666 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
667 "LOADING-Method: State=%p Op=%p NamedObj=%p\n",
668 WalkState, Op, Op->Named.Node));
669
670 if (!AcpiNsGetAttachedObject (Op->Named.Node))
671 {
672 WalkState->Operands[0] = ACPI_CAST_PTR (void, Op->Named.Node);
673 WalkState->NumOperands = 1;
674
675 Status = AcpiDsCreateOperands (
676 WalkState, Op->Common.Value.Arg);
677 if (ACPI_SUCCESS (Status))
678 {
679 Status = AcpiExCreateMethod (
680 Op->Named.Data, Op->Named.Length, WalkState);
681 }
682
683 WalkState->Operands[0] = NULL;
684 WalkState->NumOperands = 0;
685
686 if (ACPI_FAILURE (Status))
687 {
688 return_ACPI_STATUS (Status);
689 }
690 }
691 break;
692
693 #endif /* ACPI_NO_METHOD_EXECUTION */
694
695 default:
696
697 /* All NAMED_COMPLEX opcodes must be handled above */
698 break;
699 }
700 break;
701
702 case AML_CLASS_INTERNAL:
703
704 /* case AML_INT_NAMEPATH_OP: */
705 break;
706
707 case AML_CLASS_METHOD_CALL:
708
709 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
710 "RESOLVING-MethodCall: State=%p Op=%p NamedObj=%p\n",
711 WalkState, Op, Node));
712
713 /*
714 * Lookup the method name and save the Node
715 */
716 Status = AcpiNsLookup (WalkState->ScopeInfo, Arg->Common.Value.String,
717 ACPI_TYPE_ANY, ACPI_IMODE_LOAD_PASS2,
718 ACPI_NS_SEARCH_PARENT | ACPI_NS_DONT_OPEN_SCOPE,
719 WalkState, &(NewNode));
720 if (ACPI_SUCCESS (Status))
721 {
722 /*
723 * Make sure that what we found is indeed a method
724 * We didn't search for a method on purpose, to see if the name
725 * would resolve
726 */
727 if (NewNode->Type != ACPI_TYPE_METHOD)
728 {
729 Status = AE_AML_OPERAND_TYPE;
730 }
731
732 /* We could put the returned object (Node) on the object stack for
733 * later, but for now, we will put it in the "op" object that the
734 * parser uses, so we can get it again at the end of this scope
735 */
736 Op->Common.Node = NewNode;
737 }
738 else
739 {
740 ACPI_ERROR_NAMESPACE (Arg->Common.Value.String, Status);
741 }
742 break;
743
744
745 default:
746
747 break;
748 }
749
750 Cleanup:
751
752 /* Remove the Node pushed at the very beginning */
753
754 WalkState->Operands[0] = NULL;
755 WalkState->NumOperands = 0;
756 return_ACPI_STATUS (Status);
757 }
758