EdkModulePkg/Core/Pei/Dependency/dependency.c

   1 /*++
   2
   3 Copyright (c) 2006, Intel Corporation
   4 All rights reserved. This program and the accompanying materials
   5 are licensed and made available under the terms and conditions of the BSD License
   6 which accompanies this distribution.  The full text of the license may be found at
   7 http://opensource.org/licenses/bsd-license.php
   8
   9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  11
  12 Module Name:
  13
  14   dependency.c
  15
  16 Abstract:
  17
  18   PEI Dispatcher Dependency Evaluator
  19
  20   This routine evaluates a dependency expression (DEPENDENCY_EXPRESSION) to determine
  21   if a driver can be scheduled for execution.  The criteria for
  22   schedulability is that the dependency expression is satisfied.
  23
  24 --*/
  25
  26 #include <PeiMain.h>
  27 #include "dependency.h"
  28
  29 STATIC
  30 BOOLEAN
  31 IsPpiInstalled (
  32   IN EFI_PEI_SERVICES  **PeiServices,
  33   IN EVAL_STACK_ENTRY  *Stack
  34   )
  35 /*++
  36
  37 Routine Description:
  38
  39   This routine determines if a PPI has been installed.
  40   The truth value of a GUID is determined by if the PPI has
  41   been published and can be queried from the PPI database.
  42
  43 Arguments:
  44   PeiServices - The PEI core services table.
  45   Stack       - Reference to EVAL_STACK_ENTRY that contains PPI GUID to check
  46
  47 Returns:
  48
  49   True if the PPI is already installed.
  50   False if the PPI has yet to be installed.
  51
  52 --*/
  53 {
  54   VOID        *PeiInstance;
  55   EFI_STATUS  Status;
  56   EFI_GUID    PpiGuid;
  57
  58   //
  59   // If there is no GUID to evaluate, just return current result on stack.
  60   //
  61   if (Stack->Operator == NULL) {
  62     return Stack->Result;
  63   }
  64
  65   //
  66   // Copy the Guid into a locale variable so that there are no
  67   // possibilities of alignment faults for cross-compilation
  68   // environments such as Intel?Itanium(TM).
  69   //
  70   CopyMem(&PpiGuid, Stack->Operator, sizeof(EFI_GUID));
  71
  72   //
  73   // Check if the PPI is installed.
  74   //
  75   Status = PeiCoreLocatePpi(
  76              &PpiGuid,        // GUID
  77              0,               // INSTANCE
  78              NULL,            // EFI_PEI_PPI_DESCRIPTOR
  79              &PeiInstance     // PPI
  80              );
  81
  82   if (EFI_ERROR(Status)) {
  83     return FALSE;
  84   }
  85
  86   return TRUE;
  87 }
  88
  89
  90 EFI_STATUS
  91 PeimDispatchReadiness (
  92   IN EFI_PEI_SERVICES   **PeiServices,
  93   IN VOID               *DependencyExpression,
  94   OUT BOOLEAN           *Runnable
  95   )
  96 /*++
  97
  98 Routine Description:
  99
 100   This is the POSTFIX version of the dependency evaluator.  When a
 101   PUSH [PPI GUID] is encountered, a pointer to the GUID is stored on
 102   the evaluation stack.  When that entry is poped from the evaluation
 103   stack, the PPI is checked if it is installed.  This method allows
 104   some time savings as not all PPIs must be checked for certain
 105   operation types (AND, OR).
 106
 107 Arguments:
 108
 109   PeiServices               - Calling context.
 110
 111   DependencyExpression      - Pointer to a dependency expression.  The Grammar adheres to
 112                               the BNF described above and is stored in postfix notation.
 113   Runnable                  - is True if the driver can be scheduled and False if the driver
 114                               cannot be scheduled.  This is the value that the schedulers
 115                               should use for deciding the state of the driver.
 116
 117 Returns:
 118
 119   Status = EFI_SUCCESS            if it is a well-formed Grammar
 120            EFI_INVALID_PARAMETER  if the dependency expression overflows
 121                                   the evaluation stack
 122            EFI_INVALID_PARAMETER  if the dependency expression underflows
 123                                   the evaluation stack
 124            EFI_INVALID_PARAMETER  if the dependency expression is not a
 125                                   well-formed Grammar.
 126 --*/
 127 {
 128   EFI_STATUS                     Status;
 129   DEPENDENCY_EXPRESSION_OPERAND  *Iterator;
 130   EVAL_STACK_ENTRY               *StackPtr;
 131   EVAL_STACK_ENTRY               EvalStack[MAX_GRAMMAR_SIZE];
 132
 133   Status    = EFI_SUCCESS;
 134   Iterator  = DependencyExpression;
 135   *Runnable = FALSE;
 136
 137   StackPtr = &EvalStack[0];
 138
 139   while (TRUE) {
 140
 141     switch (*(Iterator++)) {
 142
 143       //
 144       // For performance reason we put the frequently used items in front of
 145       // the rarely used  items
 146       //
 147
 148       case (EFI_DEP_PUSH):
 149         //
 150         // Check to make sure the dependency grammar doesn't overflow the
 151         // EvalStack on the push
 152         //
 153         if (StackPtr > &EvalStack[MAX_GRAMMAR_SIZE-1]) {
 154           return EFI_INVALID_PARAMETER;
 155         }
 156
 157         //
 158         // Push the pointer to the PUSH opcode operator (pointer to PPI GUID)
 159         // We will evaluate if the PPI is insalled on the POP operation.
 160         //
 161         StackPtr->Operator = (VOID *) Iterator;
 162         Iterator = Iterator + sizeof (EFI_GUID);
 163         StackPtr++;
 164         break;
 165
 166       case (EFI_DEP_AND):
 167       case (EFI_DEP_OR):
 168         //
 169         // Check to make sure the dependency grammar doesn't underflow the
 170         // EvalStack on the two POPs for the AND operation.  Don't need to
 171         // check for the overflow on PUSHing the result since we already
 172         // did two POPs.
 173         //
 174         if (StackPtr < &EvalStack[2]) {
 175           return EFI_INVALID_PARAMETER;
 176         }
 177
 178         //
 179         // Evaluate the first POPed operator only. If the operand is
 180         // EFI_DEP_AND and the POPed operator evaluates to FALSE, or the
 181         // operand is EFI_DEP_OR and the POPed operator evaluates to TRUE,
 182         // we don't need to check the second operator, and the result will be
 183         // evaluation of the POPed operator. Otherwise, don't POP the second
 184         // operator since it will now evaluate to the final result on the
 185         // next operand that causes a POP.
 186         //
 187         StackPtr--;
 188         //
 189         // Iterator has increased by 1 after we retrieve the operand, so here we
 190         // should get the value pointed by (Iterator - 1), in order to obtain the
 191         // same operand.
 192         //
 193         if (*(Iterator - 1) == EFI_DEP_AND) {
 194           if (!(IsPpiInstalled (PeiServices, StackPtr))) {
 195             (StackPtr-1)->Result = FALSE;
 196             (StackPtr-1)->Operator = NULL;
 197           }
 198         } else {
 199           if (IsPpiInstalled (PeiServices, StackPtr)) {
 200             (StackPtr-1)->Result = TRUE;
 201             (StackPtr-1)->Operator = NULL;
 202           }
 203         }
 204         break;
 205
 206       case (EFI_DEP_END):
 207         StackPtr--;
 208         //
 209         // Check to make sure EvalStack is balanced.  If not, then there is
 210         // an error in the dependency grammar, so return EFI_INVALID_PARAMETER.
 211         //
 212         if (StackPtr != &EvalStack[0]) {
 213           return EFI_INVALID_PARAMETER;
 214         }
 215         *Runnable = IsPpiInstalled (PeiServices, StackPtr);
 216         return EFI_SUCCESS;
 217         break;
 218
 219       case (EFI_DEP_NOT):
 220         //
 221         // Check to make sure the dependency grammar doesn't underflow the
 222         // EvalStack on the POP for the NOT operation.  Don't need to
 223         // check for the overflow on PUSHing the result since we already
 224         // did a POP.
 225         //
 226         if (StackPtr < &EvalStack[1]) {
 227           return EFI_INVALID_PARAMETER;
 228         }
 229         (StackPtr-1)->Result = (BOOLEAN) !IsPpiInstalled (PeiServices, (StackPtr-1));
 230         (StackPtr-1)->Operator = NULL;
 231         break;
 232
 233       case (EFI_DEP_TRUE):
 234       case (EFI_DEP_FALSE):
 235         //
 236         // Check to make sure the dependency grammar doesn't overflow the
 237         // EvalStack on the push
 238         //
 239         if (StackPtr > &EvalStack[MAX_GRAMMAR_SIZE-1]) {
 240           return EFI_INVALID_PARAMETER;
 241         }
 242         //
 243         // Iterator has increased by 1 after we retrieve the operand, so here we
 244         // should get the value pointed by (Iterator - 1), in order to obtain the
 245         // same operand.
 246         //
 247         if (*(Iterator - 1) == EFI_DEP_TRUE) {
 248           StackPtr->Result = TRUE;
 249         } else {
 250           StackPtr->Result = FALSE;
 251         }
 252         StackPtr->Operator = NULL;
 253         StackPtr++;
 254         break;
 255
 256       default:
 257         //
 258         // The grammar should never arrive here
 259         //
 260         return EFI_INVALID_PARAMETER;
 261         break;
 262     }
 263   }
 264 }