Deleted Added
sdiff udiff text old ( 80062 ) new ( 82367 )
full compact
1/******************************************************************************
2 *
3 * Module Name: dswstate - Dispatcher parse tree walk management routines
4 * $Revision: 46 $
5 *
6 *****************************************************************************/
7
8/******************************************************************************
9 *
10 * 1. Copyright Notice
11 *
12 * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp.

--- 138 unchanged lines hidden (view full) ---

151
152
153 PROC_NAME ("DsResultInsert");
154
155
156 State = WalkState->Results;
157 if (!State)
158 {
159 DEBUG_PRINTP (ACPI_ERROR, ("No result object pushed! State=%p\n",
160 WalkState));
161 return (AE_NOT_EXIST);
162 }
163
164 if (Index >= OBJ_NUM_OPERANDS)
165 {
166 DEBUG_PRINTP (ACPI_ERROR,
167 ("Index out of range: %X Obj=%p State=%p Num=%X\n",
168 Index, Object, WalkState, State->Results.NumResults));
169 return (AE_BAD_PARAMETER);
170 }
171
172 if (!Object)
173 {
174 DEBUG_PRINTP (ACPI_ERROR,
175 ("Null Object! Index=%X Obj=%p State=%p Num=%X\n",
176 Index, Object, WalkState, State->Results.NumResults));
177 return (AE_BAD_PARAMETER);
178 }
179
180 State->Results.ObjDesc [Index] = Object;
181 State->Results.NumResults++;
182
183 DEBUG_PRINTP (TRACE_EXEC,
184 ("Obj=%p [%s] State=%p Num=%X Cur=%X\n",
185 Object, Object ? AcpiUtGetTypeName (((ACPI_OPERAND_OBJECT *) Object)->Common.Type) : "NULL",
186 WalkState, State->Results.NumResults, WalkState->CurrentResult));
187
188 return (AE_OK);
189}
190
191
192/*******************************************************************************

--- 20 unchanged lines hidden (view full) ---

213
214
215 PROC_NAME ("DsResultRemove");
216
217
218 State = WalkState->Results;
219 if (!State)
220 {
221 DEBUG_PRINTP (ACPI_ERROR, ("No result object pushed! State=%p\n",
222 WalkState));
223 return (AE_NOT_EXIST);
224 }
225
226 if (Index >= OBJ_NUM_OPERANDS)
227 {
228 DEBUG_PRINTP (ACPI_ERROR,
229 ("Index out of range: %X State=%p Num=%X\n",
230 Index, WalkState, State->Results.NumResults));
231 }
232
233
234 /* Check for a valid result object */
235
236 if (!State->Results.ObjDesc [Index])
237 {
238 DEBUG_PRINTP (ACPI_ERROR,
239 ("Null operand! State=%p #Ops=%X, Index=%X\n",
240 WalkState, State->Results.NumResults, Index));
241 return (AE_AML_NO_RETURN_VALUE);
242 }
243
244 /* Remove the object */
245
246 State->Results.NumResults--;
247
248 *Object = State->Results.ObjDesc [Index];
249 State->Results.ObjDesc [Index] = NULL;
250
251 DEBUG_PRINTP (TRACE_EXEC,
252 ("Obj=%p [%s] Index=%X State=%p Num=%X\n",
253 *Object, (*Object) ? AcpiUtGetTypeName ((*Object)->Common.Type) : "NULL",
254 Index, WalkState, State->Results.NumResults));
255
256 return (AE_OK);
257}
258
259
260/*******************************************************************************

--- 26 unchanged lines hidden (view full) ---

287 if (!State)
288 {
289 return (AE_OK);
290 }
291
292
293 if (!State->Results.NumResults)
294 {
295 DEBUG_PRINTP (ACPI_ERROR, ("Result stack is empty! State=%p\n",
296 WalkState));
297 return (AE_AML_NO_RETURN_VALUE);
298 }
299
300 /* Remove top element */
301
302 State->Results.NumResults--;
303
304 for (Index = OBJ_NUM_OPERANDS; Index; Index--)
305 {
306 /* Check for a valid result object */
307
308 if (State->Results.ObjDesc [Index -1])
309 {
310 *Object = State->Results.ObjDesc [Index -1];
311 State->Results.ObjDesc [Index -1] = NULL;
312
313 DEBUG_PRINTP (TRACE_EXEC, ("Obj=%p [%s] Index=%X State=%p Num=%X\n",
314 *Object, (*Object) ? AcpiUtGetTypeName ((*Object)->Common.Type) : "NULL",
315 Index -1, WalkState, State->Results.NumResults));
316
317 return (AE_OK);
318 }
319 }
320
321
322 DEBUG_PRINTP (ACPI_ERROR, ("No result objects! State=%p\n", WalkState));
323 return (AE_AML_NO_RETURN_VALUE);
324}
325
326/*******************************************************************************
327 *
328 * FUNCTION: AcpiDsResultPopFromBottom
329 *
330 * PARAMETERS: Object - Where to return the popped object

--- 16 unchanged lines hidden (view full) ---

347
348
349 PROC_NAME ("DsResultPopFromBottom");
350
351
352 State = WalkState->Results;
353 if (!State)
354 {
355 DEBUG_PRINTP (ACPI_ERROR,
356 ("Warning: No result object pushed! State=%p\n", WalkState));
357 return (AE_NOT_EXIST);
358 }
359
360
361 if (!State->Results.NumResults)
362 {
363 DEBUG_PRINTP (ACPI_ERROR, ("No result objects! State=%p\n", WalkState));
364 return (AE_AML_NO_RETURN_VALUE);
365 }
366
367 /* Remove Bottom element */
368
369 *Object = State->Results.ObjDesc [0];
370
371

--- 5 unchanged lines hidden (view full) ---

377 }
378
379 State->Results.NumResults--;
380
381 /* Check for a valid result object */
382
383 if (!*Object)
384 {
385 DEBUG_PRINTP (ACPI_ERROR, ("Null operand! State=%p #Ops=%X, Index=%X\n",
386 WalkState, State->Results.NumResults, Index));
387 return (AE_AML_NO_RETURN_VALUE);
388 }
389
390 DEBUG_PRINTP (TRACE_EXEC, ("Obj=%p [%s], Results=%p State=%p\n",
391 *Object, (*Object) ? AcpiUtGetTypeName ((*Object)->Common.Type) : "NULL",
392 State, WalkState));
393
394
395 return (AE_OK);
396}
397
398

--- 19 unchanged lines hidden (view full) ---

418
419
420 PROC_NAME ("DsResultPush");
421
422
423 State = WalkState->Results;
424 if (!State)
425 {
426 DEBUG_PRINTP (ACPI_ERROR, ("No result stack frame\n"));
427 return (AE_AML_INTERNAL);
428 }
429
430 if (State->Results.NumResults == OBJ_NUM_OPERANDS)
431 {
432 DEBUG_PRINTP (ACPI_ERROR,
433 ("Result stack overflow: Obj=%p State=%p Num=%X\n",
434 Object, WalkState, State->Results.NumResults));
435 return (AE_STACK_OVERFLOW);
436 }
437
438 if (!Object)
439 {
440 DEBUG_PRINTP (ACPI_ERROR, ("Null Object! Obj=%p State=%p Num=%X\n",
441 Object, WalkState, State->Results.NumResults));
442 return (AE_BAD_PARAMETER);
443 }
444
445
446 State->Results.ObjDesc [State->Results.NumResults] = Object;
447 State->Results.NumResults++;
448
449 DEBUG_PRINTP (TRACE_EXEC, ("Obj=%p [%s] State=%p Num=%X Cur=%X\n",
450 Object, Object ? AcpiUtGetTypeName (((ACPI_OPERAND_OBJECT *) Object)->Common.Type) : "NULL",
451 WalkState, State->Results.NumResults, WalkState->CurrentResult));
452
453 return (AE_OK);
454}
455
456
457/*******************************************************************************

--- 10 unchanged lines hidden (view full) ---

468 ******************************************************************************/
469
470ACPI_STATUS
471AcpiDsResultStackPush (
472 ACPI_WALK_STATE *WalkState)
473{
474 ACPI_GENERIC_STATE *State;
475
476
477 State = AcpiUtCreateGenericState ();
478 if (!State)
479 {
480 return (AE_NO_MEMORY);
481 }
482
483 AcpiUtPushGenericState (&WalkState->Results, State);
484
485 DEBUG_PRINT (TRACE_EXEC, ("DsResultStackPush: Results=%p State=%p\n",
486 State, WalkState));
487
488 return (AE_OK);
489}
490
491
492/*******************************************************************************
493 *

--- 8 unchanged lines hidden (view full) ---

502 ******************************************************************************/
503
504ACPI_STATUS
505AcpiDsResultStackPop (
506 ACPI_WALK_STATE *WalkState)
507{
508 ACPI_GENERIC_STATE *State;
509
510
511 /* Check for stack underflow */
512
513 if (WalkState->Results == NULL)
514 {
515 DEBUG_PRINT (TRACE_EXEC, ("DsResultStackPop: Underflow - State=%p\n",
516 WalkState));
517 return (AE_AML_NO_OPERAND);
518 }
519
520
521 State = AcpiUtPopGenericState (&WalkState->Results);
522
523 DEBUG_PRINT (TRACE_EXEC,
524 ("DsResultStackPop: Result=%p RemainingResults=%X State=%p\n",
525 State, State->Results.NumResults, WalkState));
526
527 AcpiUtDeleteGenericState (State);
528
529 return (AE_OK);
530}
531
532

--- 48 unchanged lines hidden (view full) ---

581 *
582 ******************************************************************************/
583
584ACPI_STATUS
585AcpiDsObjStackPush (
586 void *Object,
587 ACPI_WALK_STATE *WalkState)
588{
589
590
591 /* Check for stack overflow */
592
593 if (WalkState->NumOperands >= OBJ_NUM_OPERANDS)
594 {
595 DEBUG_PRINT (ACPI_ERROR,
596 ("DsObjStackPush: overflow! Obj=%p State=%p #Ops=%X\n",
597 Object, WalkState, WalkState->NumOperands));
598 return (AE_STACK_OVERFLOW);
599 }
600
601 /* Put the object onto the stack */
602
603 WalkState->Operands [WalkState->NumOperands] = Object;
604 WalkState->NumOperands++;
605
606 DEBUG_PRINT (TRACE_EXEC, ("DsObjStackPush: Obj=%p [%s] State=%p #Ops=%X\n",
607 Object, AcpiUtGetTypeName (((ACPI_OPERAND_OBJECT *) Object)->Common.Type),
608 WalkState, WalkState->NumOperands));
609
610 return (AE_OK);
611}
612
613
614/*******************************************************************************

--- 10 unchanged lines hidden (view full) ---

625 *
626 ******************************************************************************/
627
628ACPI_STATUS
629AcpiDsObjStackPopObject (
630 ACPI_OPERAND_OBJECT **Object,
631 ACPI_WALK_STATE *WalkState)
632{
633
634
635 /* Check for stack underflow */
636
637 if (WalkState->NumOperands == 0)
638 {
639 DEBUG_PRINT (ACPI_ERROR,
640 ("DsObjStackPop: Missing operand/stack empty! State=%p #Ops=%X\n",
641 WalkState, WalkState->NumOperands));
642 *Object = NULL;
643 return (AE_AML_NO_OPERAND);
644 }
645
646 /* Pop the stack */
647
648 WalkState->NumOperands--;
649
650 /* Check for a valid operand */
651
652 if (!WalkState->Operands [WalkState->NumOperands])
653 {
654 DEBUG_PRINT (ACPI_ERROR,
655 ("DsObjStackPop: Null operand! State=%p #Ops=%X\n",
656 WalkState, WalkState->NumOperands));
657 *Object = NULL;
658 return (AE_AML_NO_OPERAND);
659 }
660
661 /* Get operand and set stack entry to null */
662
663 *Object = WalkState->Operands [WalkState->NumOperands];
664 WalkState->Operands [WalkState->NumOperands] = NULL;
665
666 DEBUG_PRINT (TRACE_EXEC, ("DsObjStackPopObject: Obj=%p [%s] State=%p #Ops=%X\n",
667 *Object, AcpiUtGetTypeName ((*Object)->Common.Type),
668 WalkState, WalkState->NumOperands));
669
670 return (AE_OK);
671}
672
673
674/*******************************************************************************

--- 12 unchanged lines hidden (view full) ---

687
688ACPI_STATUS
689AcpiDsObjStackPop (
690 UINT32 PopCount,
691 ACPI_WALK_STATE *WalkState)
692{
693 UINT32 i;
694
695
696 for (i = 0; i < PopCount; i++)
697 {
698 /* Check for stack underflow */
699
700 if (WalkState->NumOperands == 0)
701 {
702 DEBUG_PRINT (ACPI_ERROR,
703 ("DsObjStackPop: Underflow! Count=%X State=%p #Ops=%X\n",
704 PopCount, WalkState, WalkState->NumOperands));
705 return (AE_STACK_UNDERFLOW);
706 }
707
708 /* Just set the stack entry to null */
709
710 WalkState->NumOperands--;
711 WalkState->Operands [WalkState->NumOperands] = NULL;
712 }
713
714 DEBUG_PRINT (TRACE_EXEC, ("DsObjStackPop: Count=%X State=%p #Ops=%X\n",
715 PopCount, WalkState, WalkState->NumOperands));
716
717 return (AE_OK);
718}
719
720
721/*******************************************************************************
722 *

--- 12 unchanged lines hidden (view full) ---

735ACPI_STATUS
736AcpiDsObjStackPopAndDelete (
737 UINT32 PopCount,
738 ACPI_WALK_STATE *WalkState)
739{
740 UINT32 i;
741 ACPI_OPERAND_OBJECT *ObjDesc;
742
743
744 for (i = 0; i < PopCount; i++)
745 {
746 /* Check for stack underflow */
747
748 if (WalkState->NumOperands == 0)
749 {
750 DEBUG_PRINT (ACPI_ERROR,
751 ("DsObjStackPop: Underflow! Count=%X State=%p #Ops=%X\n",
752 PopCount, WalkState, WalkState->NumOperands));
753 return (AE_STACK_UNDERFLOW);
754 }
755
756 /* Pop the stack and delete an object if present in this stack entry */
757
758 WalkState->NumOperands--;
759 ObjDesc = WalkState->Operands [WalkState->NumOperands];
760 if (ObjDesc)
761 {
762 AcpiUtRemoveReference (WalkState->Operands [WalkState->NumOperands]);
763 WalkState->Operands [WalkState->NumOperands] = NULL;
764 }
765 }
766
767 DEBUG_PRINT (TRACE_EXEC, ("DsObjStackPop: Count=%X State=%p #Ops=%X\n",
768 PopCount, WalkState, WalkState->NumOperands));
769
770 return (AE_OK);
771}
772
773
774/*******************************************************************************
775 *

--- 52 unchanged lines hidden (view full) ---

828 *
829 ******************************************************************************/
830
831ACPI_WALK_STATE *
832AcpiDsGetCurrentWalkState (
833 ACPI_WALK_LIST *WalkList)
834
835{
836
837 DEBUG_PRINT (TRACE_PARSE, ("DsGetCurrentWalkState, =%p\n",
838 WalkList->WalkState));
839
840 if (!WalkList)
841 {
842 return (NULL);
843 }
844
845 return (WalkList->WalkState);

--- 96 unchanged lines hidden (view full) ---

942{
943 ACPI_WALK_STATE *WalkState;
944 ACPI_STATUS Status;
945
946
947 FUNCTION_TRACE ("DsCreateWalkState");
948
949
950 AcpiUtAcquireMutex (ACPI_MTX_CACHES);
951 AcpiGbl_WalkStateCacheRequests++;
952
953 /* Check the cache first */
954
955 if (AcpiGbl_WalkStateCache)
956 {
957 /* There is an object available, use it */
958
959 WalkState = AcpiGbl_WalkStateCache;
960 AcpiGbl_WalkStateCache = WalkState->Next;
961
962 AcpiGbl_WalkStateCacheHits++;
963 AcpiGbl_WalkStateCacheDepth--;
964
965 DEBUG_PRINTP (TRACE_EXEC, ("State %p from cache\n", WalkState));
966
967 AcpiUtReleaseMutex (ACPI_MTX_CACHES);
968 }
969
970 else
971 {
972 /* The cache is empty, create a new object */
973
974 /* Avoid deadlock with ACPI_MEM_CALLOCATE */
975
976 AcpiUtReleaseMutex (ACPI_MTX_CACHES);
977
978 WalkState = ACPI_MEM_CALLOCATE (sizeof (ACPI_WALK_STATE));
979 if (!WalkState)
980 {
981 return_PTR (NULL);
982 }
983 }
984
985 WalkState->DataType = ACPI_DESC_TYPE_WALK;
986 WalkState->OwnerId = OwnerId;
987 WalkState->Origin = Origin;
988 WalkState->MethodDesc = MthDesc;
989 WalkState->WalkList = WalkList;
990
991 /* Init the method args/local */
992

--- 42 unchanged lines hidden (view full) ---

1035
1036 if (!WalkState)
1037 {
1038 return;
1039 }
1040
1041 if (WalkState->DataType != ACPI_DESC_TYPE_WALK)
1042 {
1043 DEBUG_PRINTP (ACPI_ERROR, ("%p is not a valid walk state\n", WalkState));
1044 return;
1045 }
1046
1047
1048 /* Always must free any linked control states */
1049
1050 while (WalkState->ControlState)
1051 {

--- 19 unchanged lines hidden (view full) ---

1071 {
1072 State = WalkState->Results;
1073 WalkState->Results = State->Common.Next;
1074
1075 AcpiUtDeleteGenericState (State);
1076 }
1077
1078
1079 /* If walk cache is full, just free this wallkstate object */
1080
1081 if (AcpiGbl_WalkStateCacheDepth >= MAX_WALK_CACHE_DEPTH)
1082 {
1083 ACPI_MEM_FREE (WalkState);
1084 }
1085
1086 /* Otherwise put this object back into the cache */
1087
1088 else
1089 {
1090 AcpiUtAcquireMutex (ACPI_MTX_CACHES);
1091
1092 /* Clear the state */
1093
1094 MEMSET (WalkState, 0, sizeof (ACPI_WALK_STATE));
1095 WalkState->DataType = ACPI_DESC_TYPE_WALK;
1096
1097 /* Put the object at the head of the global cache list */
1098
1099 WalkState->Next = AcpiGbl_WalkStateCache;
1100 AcpiGbl_WalkStateCache = WalkState;
1101 AcpiGbl_WalkStateCacheDepth++;
1102
1103
1104 AcpiUtReleaseMutex (ACPI_MTX_CACHES);
1105 }
1106
1107 return_VOID;
1108}
1109
1110
1111/******************************************************************************
1112 *
1113 * FUNCTION: AcpiDsDeleteWalkStateCache
1114 *

--- 5 unchanged lines hidden (view full) ---

1120 * termination.
1121 *
1122 ******************************************************************************/
1123
1124void
1125AcpiDsDeleteWalkStateCache (
1126 void)
1127{
1128 ACPI_WALK_STATE *Next;
1129
1130
1131 FUNCTION_TRACE ("DsDeleteWalkStateCache");
1132
1133
1134 /* Traverse the global cache list */
1135
1136 while (AcpiGbl_WalkStateCache)
1137 {
1138 /* Delete one cached state object */
1139
1140 Next = AcpiGbl_WalkStateCache->Next;
1141 ACPI_MEM_FREE (AcpiGbl_WalkStateCache);
1142
1143 AcpiGbl_WalkStateCache = Next;
1144 AcpiGbl_WalkStateCacheDepth--;
1145 }
1146
1147 return_VOID;
1148}
1149
1150