MdeModulePkg/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 = PeiServicesLocatePpi(
  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 BOOLEAN
  91 PeimDispatchReadiness (
  92   IN EFI_PEI_SERVICES   **PeiServices,
  93   IN VOID               *DependencyExpression
  94   )
  95 /*++
  96
  97 Routine Description:
  98
  99   This is the POSTFIX version of the dependency evaluator.  When a
 100   PUSH [PPI GUID] is encountered, a pointer to the GUID is stored on
 101   the evaluation stack.  When that entry is poped from the evaluation
 102   stack, the PPI is checked if it is installed.  This method allows
 103   some time savings as not all PPIs must be checked for certain
 104   operation types (AND, OR).
 105
 106 Arguments:
 107
 108   PeiServices               - Calling context.
 109
 110   DependencyExpression      - Pointer to a dependency expression.  The Grammar adheres to
 111                               the BNF described above and is stored in postfix notation.
 112   Runnable                  - is True if the driver can be scheduled and False if the driver
 113                               cannot be scheduled.  This is the value that the schedulers
 114                               should use for deciding the state of the driver.
 115
 116 Returns:
 117
 118   Status = EFI_SUCCESS            if it is a well-formed Grammar
 119            EFI_INVALID_PARAMETER  if the dependency expression overflows
 120                                   the evaluation stack
 121            EFI_INVALID_PARAMETER  if the dependency expression underflows
 122                                   the evaluation stack
 123            EFI_INVALID_PARAMETER  if the dependency expression is not a
 124                                   well-formed Grammar.
 125 --*/
 126 {
 127   DEPENDENCY_EXPRESSION_OPERAND  *Iterator;
 128   EVAL_STACK_ENTRY               *StackPtr;
 129   EVAL_STACK_ENTRY               EvalStack[MAX_GRAMMAR_SIZE];
 130
 131   Iterator  = DependencyExpression;
 132
 133   StackPtr = &EvalStack[0];
 134
 135   while (TRUE) {
 136
 137     switch (*(Iterator++)) {
 138
 139       //
 140       // For performance reason we put the frequently used items in front of
 141       // the rarely used  items
 142       //
 143
 144       case (EFI_DEP_PUSH):
 145         //
 146         // Check to make sure the dependency grammar doesn't overflow the
 147         // EvalStack on the push
 148         //
 149         if (StackPtr > &EvalStack[MAX_GRAMMAR_SIZE-1]) {
 150           return FALSE;
 151         }
 152
 153         //
 154         // Push the pointer to the PUSH opcode operator (pointer to PPI GUID)
 155         // We will evaluate if the PPI is insalled on the POP operation.
 156         //
 157         StackPtr->Operator = (VOID *) Iterator;
 158         Iterator = Iterator + sizeof (EFI_GUID);
 159         StackPtr++;
 160         break;
 161
 162       case (EFI_DEP_AND):
 163       case (EFI_DEP_OR):
 164         //
 165         // Check to make sure the dependency grammar doesn't underflow the
 166         // EvalStack on the two POPs for the AND operation.  Don't need to
 167         // check for the overflow on PUSHing the result since we already
 168         // did two POPs.
 169         //
 170         if (StackPtr < &EvalStack[2]) {
 171           return FALSE;
 172         }
 173
 174         //
 175         // Evaluate the first POPed operator only. If the operand is
 176         // EFI_DEP_AND and the POPed operator evaluates to FALSE, or the
 177         // operand is EFI_DEP_OR and the POPed operator evaluates to TRUE,
 178         // we don't need to check the second operator, and the result will be
 179         // evaluation of the POPed operator. Otherwise, don't POP the second
 180         // operator since it will now evaluate to the final result on the
 181         // next operand that causes a POP.
 182         //
 183         StackPtr--;
 184         //
 185         // Iterator has increased by 1 after we retrieve the operand, so here we
 186         // should get the value pointed by (Iterator - 1), in order to obtain the
 187         // same operand.
 188         //
 189         if (*(Iterator - 1) == EFI_DEP_AND) {
 190           if (!(IsPpiInstalled (PeiServices, StackPtr))) {
 191             (StackPtr-1)->Result = FALSE;
 192             (StackPtr-1)->Operator = NULL;
 193           }
 194         } else {
 195           if (IsPpiInstalled (PeiServices, StackPtr)) {
 196             (StackPtr-1)->Result = TRUE;
 197             (StackPtr-1)->Operator = NULL;
 198           }
 199         }
 200         break;
 201
 202       case (EFI_DEP_END):
 203         StackPtr--;
 204         //
 205         // Check to make sure EvalStack is balanced.  If not, then there is
 206         // an error in the dependency grammar, so return EFI_INVALID_PARAMETER.
 207         //
 208         if (StackPtr != &EvalStack[0]) {
 209           return FALSE;
 210         }
 211         return IsPpiInstalled (PeiServices, StackPtr);
 212         break;
 213
 214       case (EFI_DEP_NOT):
 215         //
 216         // Check to make sure the dependency grammar doesn't underflow the
 217         // EvalStack on the POP for the NOT operation.  Don't need to
 218         // check for the overflow on PUSHing the result since we already
 219         // did a POP.
 220         //
 221         if (StackPtr < &EvalStack[1]) {
 222           return FALSE;
 223         }
 224         (StackPtr-1)->Result = (BOOLEAN) !IsPpiInstalled (PeiServices, (StackPtr-1));
 225         (StackPtr-1)->Operator = NULL;
 226         break;
 227
 228       case (EFI_DEP_TRUE):
 229       case (EFI_DEP_FALSE):
 230         //
 231         // Check to make sure the dependency grammar doesn't overflow the
 232         // EvalStack on the push
 233         //
 234         if (StackPtr > &EvalStack[MAX_GRAMMAR_SIZE-1]) {
 235           return FALSE;
 236         }
 237         //
 238         // Iterator has increased by 1 after we retrieve the operand, so here we
 239         // should get the value pointed by (Iterator - 1), in order to obtain the
 240         // same operand.
 241         //
 242         if (*(Iterator - 1) == EFI_DEP_TRUE) {
 243           StackPtr->Result = TRUE;
 244         } else {
 245           StackPtr->Result = FALSE;
 246         }
 247         StackPtr->Operator = NULL;
 248         StackPtr++;
 249         break;
 250
 251       default:
 252         //
 253         // The grammar should never arrive here
 254         //
 255         return FALSE;
 256         break;
 257     }
 258   }
 259 }