MdeModulePkg/Core/PiSmmCore/Dependency.c

   1 /** @file
   2   SMM Driver Dispatcher Dependency Evaluator
   3
   4   This routine evaluates a dependency expression (DEPENDENCY_EXPRESSION) to determine
   5   if a driver can be scheduled for execution.  The criteria for
   6   schedulability is that the dependency expression is satisfied.
   7
   8   Copyright (c) 2009 - 2018, Intel Corporation. All rights reserved.<BR>
   9   This program and the accompanying materials are licensed and made available
  10   under the terms and conditions of the BSD License which accompanies this
  11   distribution.  The full text of the license may be found at
  12   http://opensource.org/licenses/bsd-license.php
  13
  14   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  15   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  16
  17 **/
  18
  19 #include "PiSmmCore.h"
  20
  21 ///
  22 /// EFI_DEP_REPLACE_TRUE - Used to dynamically patch the dependency expression
  23 ///                        to save time.  A EFI_DEP_PUSH is evaluated one an
  24 ///                        replaced with EFI_DEP_REPLACE_TRUE. If PI spec's Vol 2
  25 ///                        Driver Execution Environment Core Interface use 0xff
  26 ///                        as new DEPEX opcode. EFI_DEP_REPLACE_TRUE should be
  27 ///                        defined to a new value that is not conflicting with PI spec.
  28 ///
  29 #define EFI_DEP_REPLACE_TRUE  0xff
  30
  31 ///
  32 /// Define the initial size of the dependency expression evaluation stack
  33 ///
  34 #define DEPEX_STACK_SIZE_INCREMENT  0x1000
  35
  36 //
  37 // Global stack used to evaluate dependency expressions
  38 //
  39 BOOLEAN  *mDepexEvaluationStack        = NULL;
  40 BOOLEAN  *mDepexEvaluationStackEnd     = NULL;
  41 BOOLEAN  *mDepexEvaluationStackPointer = NULL;
  42
  43 /**
  44   Grow size of the Depex stack
  45
  46   @retval EFI_SUCCESS           Stack successfully growed.
  47   @retval EFI_OUT_OF_RESOURCES  There is not enough system memory to grow the stack.
  48
  49 **/
  50 EFI_STATUS
  51 GrowDepexStack (
  52   VOID
  53   )
  54 {
  55   BOOLEAN     *NewStack;
  56   UINTN       Size;
  57
  58   Size = DEPEX_STACK_SIZE_INCREMENT;
  59   if (mDepexEvaluationStack != NULL) {
  60     Size = Size + (mDepexEvaluationStackEnd - mDepexEvaluationStack);
  61   }
  62
  63   NewStack = AllocatePool (Size * sizeof (BOOLEAN));
  64   if (NewStack == NULL) {
  65     return EFI_OUT_OF_RESOURCES;
  66   }
  67
  68   if (mDepexEvaluationStack != NULL) {
  69     //
  70     // Copy to Old Stack to the New Stack
  71     //
  72     CopyMem (
  73       NewStack,
  74       mDepexEvaluationStack,
  75       (mDepexEvaluationStackEnd - mDepexEvaluationStack) * sizeof (BOOLEAN)
  76       );
  77
  78     //
  79     // Free The Old Stack
  80     //
  81     FreePool (mDepexEvaluationStack);
  82   }
  83
  84   //
  85   // Make the Stack pointer point to the old data in the new stack
  86   //
  87   mDepexEvaluationStackPointer = NewStack + (mDepexEvaluationStackPointer - mDepexEvaluationStack);
  88   mDepexEvaluationStack        = NewStack;
  89   mDepexEvaluationStackEnd     = NewStack + Size;
  90
  91   return EFI_SUCCESS;
  92 }
  93
  94 /**
  95   Push an element onto the Boolean Stack.
  96
  97   @param  Value                 BOOLEAN to push.
  98
  99   @retval EFI_SUCCESS           The value was pushed onto the stack.
 100   @retval EFI_OUT_OF_RESOURCES  There is not enough system memory to grow the stack.
 101
 102 **/
 103 EFI_STATUS
 104 PushBool (
 105   IN BOOLEAN  Value
 106   )
 107 {
 108   EFI_STATUS  Status;
 109
 110   //
 111   // Check for a stack overflow condition
 112   //
 113   if (mDepexEvaluationStackPointer == mDepexEvaluationStackEnd) {
 114     //
 115     // Grow the stack
 116     //
 117     Status = GrowDepexStack ();
 118     if (EFI_ERROR (Status)) {
 119       return Status;
 120     }
 121   }
 122
 123   //
 124   // Push the item onto the stack
 125   //
 126   *mDepexEvaluationStackPointer = Value;
 127   mDepexEvaluationStackPointer++;
 128
 129   return EFI_SUCCESS;
 130 }
 131
 132 /**
 133   Pop an element from the Boolean stack.
 134
 135   @param  Value                 BOOLEAN to pop.
 136
 137   @retval EFI_SUCCESS           The value was popped onto the stack.
 138   @retval EFI_ACCESS_DENIED     The pop operation underflowed the stack.
 139
 140 **/
 141 EFI_STATUS
 142 PopBool (
 143   OUT BOOLEAN  *Value
 144   )
 145 {
 146   //
 147   // Check for a stack underflow condition
 148   //
 149   if (mDepexEvaluationStackPointer == mDepexEvaluationStack) {
 150     return EFI_ACCESS_DENIED;
 151   }
 152
 153   //
 154   // Pop the item off the stack
 155   //
 156   mDepexEvaluationStackPointer--;
 157   *Value = *mDepexEvaluationStackPointer;
 158   return EFI_SUCCESS;
 159 }
 160
 161 /**
 162   This is the POSTFIX version of the dependency evaluator.  This code does
 163   not need to handle Before or After, as it is not valid to call this
 164   routine in this case. POSTFIX means all the math is done on top of the stack.
 165
 166   @param  DriverEntry           DriverEntry element to update.
 167
 168   @retval TRUE                  If driver is ready to run.
 169   @retval FALSE                 If driver is not ready to run or some fatal error
 170                                 was found.
 171
 172 **/
 173 BOOLEAN
 174 SmmIsSchedulable (
 175   IN  EFI_SMM_DRIVER_ENTRY   *DriverEntry
 176   )
 177 {
 178   EFI_STATUS  Status;
 179   UINT8       *Iterator;
 180   BOOLEAN     Operator;
 181   BOOLEAN     Operator2;
 182   EFI_GUID    DriverGuid;
 183   VOID        *Interface;
 184
 185   Operator = FALSE;
 186   Operator2 = FALSE;
 187
 188   if (DriverEntry->After || DriverEntry->Before) {
 189     //
 190     // If Before or After Depex skip as SmmInsertOnScheduledQueueWhileProcessingBeforeAndAfter ()
 191     // processes them.
 192     //
 193     return FALSE;
 194   }
 195
 196   DEBUG ((DEBUG_DISPATCH, "Evaluate SMM DEPEX for FFS(%g)\n", &DriverEntry->FileName));
 197
 198   if (DriverEntry->Depex == NULL) {
 199     //
 200     // A NULL Depex means that the SMM driver is not built correctly.
 201     // All SMM drivers must have a valid depex expressiion.
 202     //
 203     DEBUG ((DEBUG_DISPATCH, "  RESULT = FALSE (Depex is empty)\n"));
 204     ASSERT (FALSE);
 205     return FALSE;
 206   }
 207
 208   //
 209   // Clean out memory leaks in Depex Boolean stack. Leaks are only caused by
 210   // incorrectly formed DEPEX expressions
 211   //
 212   mDepexEvaluationStackPointer = mDepexEvaluationStack;
 213
 214
 215   Iterator = DriverEntry->Depex;
 216
 217   while (TRUE) {
 218     //
 219     // Check to see if we are attempting to fetch dependency expression instructions
 220     // past the end of the dependency expression.
 221     //
 222     if (((UINTN)Iterator - (UINTN)DriverEntry->Depex) >= DriverEntry->DepexSize) {
 223       DEBUG ((DEBUG_DISPATCH, "  RESULT = FALSE (Attempt to fetch past end of depex)\n"));
 224       return FALSE;
 225     }
 226
 227     //
 228     // Look at the opcode of the dependency expression instruction.
 229     //
 230     switch (*Iterator) {
 231     case EFI_DEP_BEFORE:
 232     case EFI_DEP_AFTER:
 233       //
 234       // For a well-formed Dependency Expression, the code should never get here.
 235       // The BEFORE and AFTER are processed prior to this routine's invocation.
 236       // If the code flow arrives at this point, there was a BEFORE or AFTER
 237       // that were not the first opcodes.
 238       //
 239       DEBUG ((DEBUG_DISPATCH, "  RESULT = FALSE (Unexpected BEFORE or AFTER opcode)\n"));
 240       ASSERT (FALSE);
 241
 242     case EFI_DEP_PUSH:
 243       //
 244       // Push operator is followed by a GUID. Test to see if the GUID protocol
 245       // is installed and push the boolean result on the stack.
 246       //
 247       CopyMem (&DriverGuid, Iterator + 1, sizeof (EFI_GUID));
 248
 249       Status = SmmLocateProtocol (&DriverGuid, NULL, &Interface);
 250       if (EFI_ERROR (Status)) {
 251         //
 252         // For SMM Driver, it may depend on uefi protocols
 253         //
 254         Status = gBS->LocateProtocol (&DriverGuid, NULL, &Interface);
 255       }
 256
 257       if (EFI_ERROR (Status)) {
 258         DEBUG ((DEBUG_DISPATCH, "  PUSH GUID(%g) = FALSE\n", &DriverGuid));
 259         Status = PushBool (FALSE);
 260       } else {
 261         DEBUG ((DEBUG_DISPATCH, "  PUSH GUID(%g) = TRUE\n", &DriverGuid));
 262         *Iterator = EFI_DEP_REPLACE_TRUE;
 263         Status = PushBool (TRUE);
 264       }
 265       if (EFI_ERROR (Status)) {
 266         DEBUG ((DEBUG_DISPATCH, "  RESULT = FALSE (Unexpected error)\n"));
 267         return FALSE;
 268       }
 269
 270       Iterator += sizeof (EFI_GUID);
 271       break;
 272
 273     case EFI_DEP_AND:
 274       DEBUG ((DEBUG_DISPATCH, "  AND\n"));
 275       Status = PopBool (&Operator);
 276       if (EFI_ERROR (Status)) {
 277         DEBUG ((DEBUG_DISPATCH, "  RESULT = FALSE (Unexpected error)\n"));
 278         return FALSE;
 279       }
 280
 281       Status = PopBool (&Operator2);
 282       if (EFI_ERROR (Status)) {
 283         DEBUG ((DEBUG_DISPATCH, "  RESULT = FALSE (Unexpected error)\n"));
 284         return FALSE;
 285       }
 286
 287       Status = PushBool ((BOOLEAN)(Operator && Operator2));
 288       if (EFI_ERROR (Status)) {
 289         DEBUG ((DEBUG_DISPATCH, "  RESULT = FALSE (Unexpected error)\n"));
 290         return FALSE;
 291       }
 292       break;
 293
 294     case EFI_DEP_OR:
 295       DEBUG ((DEBUG_DISPATCH, "  OR\n"));
 296       Status = PopBool (&Operator);
 297       if (EFI_ERROR (Status)) {
 298         DEBUG ((DEBUG_DISPATCH, "  RESULT = FALSE (Unexpected error)\n"));
 299         return FALSE;
 300       }
 301
 302       Status = PopBool (&Operator2);
 303       if (EFI_ERROR (Status)) {
 304         DEBUG ((DEBUG_DISPATCH, "  RESULT = FALSE (Unexpected error)\n"));
 305         return FALSE;
 306       }
 307
 308       Status = PushBool ((BOOLEAN)(Operator || Operator2));
 309       if (EFI_ERROR (Status)) {
 310         DEBUG ((DEBUG_DISPATCH, "  RESULT = FALSE (Unexpected error)\n"));
 311         return FALSE;
 312       }
 313       break;
 314
 315     case EFI_DEP_NOT:
 316       DEBUG ((DEBUG_DISPATCH, "  NOT\n"));
 317       Status = PopBool (&Operator);
 318       if (EFI_ERROR (Status)) {
 319         DEBUG ((DEBUG_DISPATCH, "  RESULT = FALSE (Unexpected error)\n"));
 320         return FALSE;
 321       }
 322
 323       Status = PushBool ((BOOLEAN)(!Operator));
 324       if (EFI_ERROR (Status)) {
 325         DEBUG ((DEBUG_DISPATCH, "  RESULT = FALSE (Unexpected error)\n"));
 326         return FALSE;
 327       }
 328       break;
 329
 330     case EFI_DEP_TRUE:
 331       DEBUG ((DEBUG_DISPATCH, "  TRUE\n"));
 332       Status = PushBool (TRUE);
 333       if (EFI_ERROR (Status)) {
 334         DEBUG ((DEBUG_DISPATCH, "  RESULT = FALSE (Unexpected error)\n"));
 335         return FALSE;
 336       }
 337       break;
 338
 339     case EFI_DEP_FALSE:
 340       DEBUG ((DEBUG_DISPATCH, "  FALSE\n"));
 341       Status = PushBool (FALSE);
 342       if (EFI_ERROR (Status)) {
 343         DEBUG ((DEBUG_DISPATCH, "  RESULT = FALSE (Unexpected error)\n"));
 344         return FALSE;
 345       }
 346       break;
 347
 348     case EFI_DEP_END:
 349       DEBUG ((DEBUG_DISPATCH, "  END\n"));
 350       Status = PopBool (&Operator);
 351       if (EFI_ERROR (Status)) {
 352         DEBUG ((DEBUG_DISPATCH, "  RESULT = FALSE (Unexpected error)\n"));
 353         return FALSE;
 354       }
 355       DEBUG ((DEBUG_DISPATCH, "  RESULT = %a\n", Operator ? "TRUE" : "FALSE"));
 356       return Operator;
 357
 358     case EFI_DEP_REPLACE_TRUE:
 359       CopyMem (&DriverGuid, Iterator + 1, sizeof (EFI_GUID));
 360       DEBUG ((DEBUG_DISPATCH, "  PUSH GUID(%g) = TRUE\n", &DriverGuid));
 361       Status = PushBool (TRUE);
 362       if (EFI_ERROR (Status)) {
 363         DEBUG ((DEBUG_DISPATCH, "  RESULT = FALSE (Unexpected error)\n"));
 364         return FALSE;
 365       }
 366
 367       Iterator += sizeof (EFI_GUID);
 368       break;
 369
 370     default:
 371       DEBUG ((DEBUG_DISPATCH, "  RESULT = FALSE (Unknown opcode)\n"));
 372       goto Done;
 373     }
 374
 375     //
 376     // Skip over the Dependency Op Code we just processed in the switch.
 377     // The math is done out of order, but it should not matter. That is
 378     // we may add in the sizeof (EFI_GUID) before we account for the OP Code.
 379     // This is not an issue, since we just need the correct end result. You
 380     // need to be careful using Iterator in the loop as it's intermediate value
 381     // may be strange.
 382     //
 383     Iterator++;
 384   }
 385
 386 Done:
 387   return FALSE;
 388 }