]> git.proxmox.com Git - mirror_edk2.git/blobdiff - MdeModulePkg/Core/Dxe/Dispatcher/dependency.c
Check in DxeCore for Nt32 platform. Currently, it does not follow PI/UEFI2.1.
[mirror_edk2.git] / MdeModulePkg / Core / Dxe / Dispatcher / dependency.c
diff --git a/MdeModulePkg/Core/Dxe/Dispatcher/dependency.c b/MdeModulePkg/Core/Dxe/Dispatcher/dependency.c
new file mode 100644 (file)
index 0000000..7c2093b
--- /dev/null
@@ -0,0 +1,452 @@
+/*++ \r
+\r
+Copyright (c) 2006, Intel Corporation                                                         \r
+All rights reserved. This program and the accompanying materials                          \r
+are licensed and made available under the terms and conditions of the BSD License         \r
+which accompanies this distribution.  The full text of the license may be found at        \r
+http://opensource.org/licenses/bsd-license.php                                            \r
+                                                                                          \r
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     \r
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             \r
+\r
+Module Name:\r
+\r
+  dependency.c\r
+\r
+Abstract:\r
+\r
+  DXE Dispatcher Dependency Evaluator\r
+\r
+  This routine evaluates a dependency expression (DEPENDENCY_EXPRESSION) to determine\r
+  if a driver can be scheduled for execution.  The criteria for\r
+  schedulability is that the dependency expression is satisfied.\r
+\r
+--*/\r
+\r
+#include <DxeMain.h>\r
+\r
+//\r
+// Global stack used to evaluate dependency expressions\r
+//\r
+BOOLEAN *mDepexEvaluationStack        = NULL;\r
+BOOLEAN *mDepexEvaluationStackEnd     = NULL;\r
+BOOLEAN *mDepexEvaluationStackPointer = NULL;\r
+\r
+//\r
+// Worker functions\r
+//\r
+\r
+STATIC\r
+EFI_STATUS\r
+GrowDepexStack (\r
+  VOID\r
+  )\r
+/*++\r
+\r
+Routine Description:\r
+\r
+  Grow size of the Depex stack\r
+\r
+Arguments:\r
+\r
+  Stack     - Old stack on the way in and new stack on the way out\r
+\r
+  StackSize - New size of the stack\r
+\r
+Returns:\r
+\r
+  EFI_SUCCESS          - Stack successfully growed.\r
+  \r
+  EFI_OUT_OF_RESOURCES - There is not enough system memory to grow the stack.\r
+  \r
+  \r
+\r
+--*/\r
+{\r
+  BOOLEAN     *NewStack;\r
+  UINTN       Size;\r
+\r
+  Size = DEPEX_STACK_SIZE_INCREMENT;\r
+  if (mDepexEvaluationStack != NULL) {\r
+    Size = Size + (mDepexEvaluationStackEnd - mDepexEvaluationStack);\r
+  }\r
+\r
+  NewStack = CoreAllocateBootServicesPool (Size * sizeof (BOOLEAN));\r
+  if (NewStack == NULL) {\r
+    return EFI_OUT_OF_RESOURCES;\r
+  }\r
+\r
+  if (mDepexEvaluationStack != NULL) {\r
+    //\r
+    // Copy to Old Stack to the New Stack\r
+    //\r
+    CopyMem (\r
+      NewStack, \r
+      mDepexEvaluationStack, \r
+      (mDepexEvaluationStackEnd - mDepexEvaluationStack) * sizeof (BOOLEAN)\r
+      );\r
+\r
+    //\r
+    // Free The Old Stack\r
+    //\r
+    CoreFreePool (mDepexEvaluationStack);\r
+  }\r
+\r
+  //\r
+  // Make the Stack pointer point to the old data in the new stack\r
+  //\r
+  mDepexEvaluationStackPointer = NewStack + (mDepexEvaluationStackPointer - mDepexEvaluationStack);\r
+  mDepexEvaluationStack        = NewStack;\r
+  mDepexEvaluationStackEnd     = NewStack + Size;\r
+\r
+  return EFI_SUCCESS;\r
+}\r
+\r
+\r
+STATIC\r
+EFI_STATUS\r
+PushBool (\r
+  IN BOOLEAN  Value\r
+  )\r
+/*++\r
+\r
+Routine Description:\r
+\r
+  Push an element onto the Boolean Stack\r
+\r
+Arguments:\r
+\r
+  Value - BOOLEAN to push.\r
+\r
+Returns:\r
+\r
+  EFI_SUCCESS          - The value was pushed onto the stack.\r
+\r
+  EFI_OUT_OF_RESOURCES - There is not enough system memory to grow the stack.\r
+\r
+--*/\r
+{\r
+  EFI_STATUS  Status;\r
+\r
+  //\r
+  // Check for a stack overflow condition\r
+  //\r
+  if (mDepexEvaluationStackPointer == mDepexEvaluationStackEnd) {\r
+    //\r
+    // Grow the stack\r
+    //\r
+    Status = GrowDepexStack ();\r
+    if (EFI_ERROR (Status)) {\r
+      return Status;\r
+    }\r
+  }\r
+\r
+  //\r
+  // Push the item onto the stack\r
+  //\r
+  *mDepexEvaluationStackPointer = Value;\r
+  mDepexEvaluationStackPointer++;\r
+\r
+  return EFI_SUCCESS;\r
+}\r
+\r
+\r
+STATIC\r
+EFI_STATUS \r
+PopBool (\r
+  OUT BOOLEAN  *Value\r
+  )\r
+/*++\r
+\r
+Routine Description:\r
+\r
+  Pop an element from the Boolean stack.\r
+\r
+Arguments:\r
+\r
+  Value - BOOLEAN to pop.\r
+\r
+Returns:\r
+\r
+  EFI_SUCCESS       - The value was popped onto the stack.\r
+\r
+  EFI_ACCESS_DENIED - The pop operation underflowed the stack\r
+\r
+--*/\r
+{\r
+  //\r
+  // Check for a stack underflow condition\r
+  //\r
+  if (mDepexEvaluationStackPointer == mDepexEvaluationStack) {\r
+    return EFI_ACCESS_DENIED;\r
+  }\r
+\r
+  //\r
+  // Pop the item off the stack\r
+  //\r
+  mDepexEvaluationStackPointer--;\r
+  *Value = *mDepexEvaluationStackPointer;\r
+  return EFI_SUCCESS;  \r
+}\r
+\r
+\r
+EFI_STATUS\r
+CorePreProcessDepex (\r
+  IN  EFI_CORE_DRIVER_ENTRY   *DriverEntry  \r
+  )\r
+/*++\r
+\r
+Routine Description:\r
+\r
+  Preprocess dependency expression and update DriverEntry to reflect the\r
+  state of  Before, After, and SOR dependencies. If DriverEntry->Before\r
+  or DriverEntry->After is set it will never be cleared. If SOR is set\r
+  it will be cleared by CoreSchedule(), and then the driver can be \r
+  dispatched.\r
+\r
+Arguments:\r
+\r
+  DriverEntry - DriverEntry element to update\r
+\r
+Returns:\r
+\r
+  EFI_SUCCESS - It always works.\r
+\r
+--*/\r
+{\r
+  UINT8  *Iterator;\r
+    \r
+  Iterator = DriverEntry->Depex;\r
+  if (*Iterator == EFI_DEP_SOR) {\r
+    DriverEntry->Unrequested = TRUE;\r
+  } else {\r
+    DriverEntry->Dependent = TRUE;\r
+  }\r
+    \r
+  if (*Iterator == EFI_DEP_BEFORE) {\r
+    DriverEntry->Before = TRUE;\r
+  } else if (*Iterator == EFI_DEP_AFTER) {\r
+    DriverEntry->After = TRUE;\r
+  } \r
+\r
+  if (DriverEntry->Before || DriverEntry->After) {\r
+    CopyMem (&DriverEntry->BeforeAfterGuid, Iterator + 1, sizeof (EFI_GUID));\r
+  }\r
+\r
+  return EFI_SUCCESS;\r
+}\r
+\r
+\r
+BOOLEAN\r
+CoreIsSchedulable (\r
+  IN  EFI_CORE_DRIVER_ENTRY   *DriverEntry  \r
+  )\r
+/*++\r
+\r
+Routine Description:\r
+\r
+  This is the POSTFIX version of the dependency evaluator.  This code does \r
+  not need to handle Before or After, as it is not valid to call this \r
+  routine in this case. The SOR is just ignored and is a nop in the grammer.\r
+\r
+  POSTFIX means all the math is done on top of the stack.\r
+\r
+Arguments:\r
+\r
+  DriverEntry - DriverEntry element to update\r
+  \r
+Returns:\r
+\r
+  TRUE - If driver is ready to run.\r
+\r
+  FALSE - If driver is not ready to run or some fatal error was found.\r
+\r
+--*/\r
+{\r
+  EFI_STATUS  Status;\r
+  UINT8       *Iterator;\r
+  BOOLEAN     Operator;\r
+  BOOLEAN     Operator2;\r
+  EFI_GUID    DriverGuid;\r
+  VOID        *Interface;\r
+\r
+  if (DriverEntry->After || DriverEntry->Before) {\r
+    //\r
+    // If Before or After Depex skip as CoreInsertOnScheduledQueueWhileProcessingBeforeAndAfter ()\r
+    // processes them.\r
+    //\r
+    return FALSE;\r
+  }\r
+\r
+  if (DriverEntry->Depex == NULL) {\r
+    //\r
+    // A NULL Depex means treat the driver like an EFI 1.0 thing.\r
+    //\r
+    Status = CoreAllEfiServicesAvailable ();\r
+    if (EFI_ERROR (Status)) {\r
+      return FALSE;\r
+    }\r
+    return TRUE;\r
+  }\r
+\r
+  //\r
+  // Clean out memory leaks in Depex Boolean stack. Leaks are only caused by\r
+  //  incorrectly formed DEPEX expressions\r
+  //\r
+  mDepexEvaluationStackPointer = mDepexEvaluationStack;\r
+\r
+\r
+  Iterator = DriverEntry->Depex;\r
+  \r
+  while (TRUE) {\r
+    //\r
+    // Check to see if we are attempting to fetch dependency expression instructions\r
+    // past the end of the dependency expression.\r
+    //\r
+    if (((UINTN)Iterator - (UINTN)DriverEntry->Depex) >= DriverEntry->DepexSize) {\r
+      return FALSE;\r
+    }\r
+\r
+    //\r
+    // Look at the opcode of the dependency expression instruction.\r
+    //\r
+    switch (*Iterator) {\r
+    case EFI_DEP_BEFORE:\r
+    case EFI_DEP_AFTER:\r
+      //\r
+      // For a well-formed Dependency Expression, the code should never get here.\r
+      // The BEFORE and AFTER are processed prior to this routine's invocation.\r
+      // If the code flow arrives at this point, there was a BEFORE or AFTER\r
+      // that were not the first opcodes.\r
+      //\r
+      ASSERT (FALSE);\r
+    case EFI_DEP_SOR:\r
+      //\r
+      // These opcodes can only appear once as the first opcode.  If it is found \r
+      // at any other location, then the dependency expression evaluates to FALSE\r
+      //\r
+      if (Iterator != DriverEntry->Depex) {\r
+        return FALSE;\r
+      }\r
+      //\r
+      // Otherwise, it is the first opcode and should be treated as a NOP.\r
+      //\r
+      break;\r
+\r
+    case EFI_DEP_PUSH:  \r
+      //\r
+      // Push operator is followed by a GUID. Test to see if the GUID protocol\r
+      // is installed and push the boolean result on the stack.\r
+      //\r
+      CopyMem (&DriverGuid, Iterator + 1, sizeof (EFI_GUID));\r
+\r
+      Status = CoreLocateProtocol (&DriverGuid, NULL, &Interface);\r
+\r
+      if (EFI_ERROR (Status)) {\r
+        Status = PushBool (FALSE);\r
+      } else {\r
+        *Iterator = EFI_DEP_REPLACE_TRUE;\r
+        Status = PushBool (TRUE);\r
+      }\r
+      if (EFI_ERROR (Status)) {\r
+        return FALSE;\r
+      }\r
+\r
+      Iterator += sizeof (EFI_GUID);\r
+      break;\r
+\r
+    case EFI_DEP_AND:    \r
+      Status = PopBool (&Operator);\r
+      if (EFI_ERROR (Status)) {\r
+        return FALSE;\r
+      }\r
+\r
+      Status = PopBool (&Operator2);\r
+      if (EFI_ERROR (Status)) {\r
+        return FALSE;\r
+      }\r
+\r
+      Status = PushBool ((BOOLEAN)(Operator && Operator2));\r
+      if (EFI_ERROR (Status)) {\r
+        return FALSE;\r
+      }\r
+      break;\r
+\r
+    case EFI_DEP_OR:     \r
+      Status = PopBool (&Operator);\r
+      if (EFI_ERROR (Status)) {\r
+        return FALSE;\r
+      }\r
+\r
+      Status = PopBool (&Operator2);\r
+      if (EFI_ERROR (Status)) {\r
+        return FALSE;\r
+      }\r
+\r
+      Status = PushBool ((BOOLEAN)(Operator || Operator2));\r
+      if (EFI_ERROR (Status)) {\r
+        return FALSE;\r
+      }\r
+      break;\r
+\r
+    case EFI_DEP_NOT:    \r
+      Status = PopBool (&Operator);\r
+      if (EFI_ERROR (Status)) {\r
+        return FALSE;\r
+      }\r
+\r
+      Status = PushBool ((BOOLEAN)(!Operator));\r
+      if (EFI_ERROR (Status)) {\r
+        return FALSE;\r
+      }\r
+      break;\r
+\r
+    case EFI_DEP_TRUE:   \r
+      Status = PushBool (TRUE);\r
+      if (EFI_ERROR (Status)) {\r
+        return FALSE;\r
+      }\r
+      break;\r
+\r
+    case EFI_DEP_FALSE: \r
+      Status = PushBool (FALSE);\r
+      if (EFI_ERROR (Status)) {\r
+        return FALSE;\r
+      }\r
+      break;\r
+\r
+    case EFI_DEP_END:    \r
+      Status = PopBool (&Operator);\r
+      if (EFI_ERROR (Status)) {\r
+        return FALSE;\r
+      }\r
+      return Operator;\r
+\r
+    case EFI_DEP_REPLACE_TRUE:\r
+      Status = PushBool (TRUE);\r
+      if (EFI_ERROR (Status)) {\r
+        return FALSE;\r
+      }\r
+\r
+      Iterator += sizeof (EFI_GUID);\r
+      break;\r
+\r
+    default:      \r
+      goto Done;\r
+    }\r
+    \r
+    //\r
+    // Skip over the Dependency Op Code we just processed in the switch.\r
+    // The math is done out of order, but it should not matter. That is\r
+    // we may add in the sizeof (EFI_GUID) before we account for the OP Code.\r
+    // This is not an issue, since we just need the correct end result. You\r
+    // need to be careful using Iterator in the loop as it's intermediate value\r
+    // may be strange.\r
+    //\r
+    Iterator++;\r
+  }\r
+\r
+Done:\r
+  return FALSE;\r
+}\r
+\r