StandaloneMmPkg/Core/Dependency.c

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