2 SMM Driver Dispatcher Dependency Evaluator
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.
8 Copyright (c) 2009 - 2010, 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
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.
19 #include "PiSmmCore.h"
22 /// EFI_DEP_REPLACE_TRUE - Used to dynamically patch the dependecy expression
23 /// to save time. A EFI_DEP_PUSH is evauated 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.
29 #define EFI_DEP_REPLACE_TRUE 0xff
32 /// Define the initial size of the dependency expression evaluation stack
34 #define DEPEX_STACK_SIZE_INCREMENT 0x1000
37 // Global stack used to evaluate dependency expressions
39 BOOLEAN
*mDepexEvaluationStack
= NULL
;
40 BOOLEAN
*mDepexEvaluationStackEnd
= NULL
;
41 BOOLEAN
*mDepexEvaluationStackPointer
= NULL
;
44 Grow size of the Depex stack
46 @retval EFI_SUCCESS Stack successfully growed.
47 @retval EFI_OUT_OF_RESOURCES There is not enough system memory to grow the stack.
58 Size
= DEPEX_STACK_SIZE_INCREMENT
;
59 if (mDepexEvaluationStack
!= NULL
) {
60 Size
= Size
+ (mDepexEvaluationStackEnd
- mDepexEvaluationStack
);
63 NewStack
= AllocatePool (Size
* sizeof (BOOLEAN
));
64 if (NewStack
== NULL
) {
65 return EFI_OUT_OF_RESOURCES
;
68 if (mDepexEvaluationStack
!= NULL
) {
70 // Copy to Old Stack to the New Stack
74 mDepexEvaluationStack
,
75 (mDepexEvaluationStackEnd
- mDepexEvaluationStack
) * sizeof (BOOLEAN
)
81 FreePool (mDepexEvaluationStack
);
85 // Make the Stack pointer point to the old data in the new stack
87 mDepexEvaluationStackPointer
= NewStack
+ (mDepexEvaluationStackPointer
- mDepexEvaluationStack
);
88 mDepexEvaluationStack
= NewStack
;
89 mDepexEvaluationStackEnd
= NewStack
+ Size
;
95 Push an element onto the Boolean Stack.
97 @param Value BOOLEAN to push.
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.
111 // Check for a stack overflow condition
113 if (mDepexEvaluationStackPointer
== mDepexEvaluationStackEnd
) {
117 Status
= GrowDepexStack ();
118 if (EFI_ERROR (Status
)) {
124 // Push the item onto the stack
126 *mDepexEvaluationStackPointer
= Value
;
127 mDepexEvaluationStackPointer
++;
133 Pop an element from the Boolean stack.
135 @param Value BOOLEAN to pop.
137 @retval EFI_SUCCESS The value was popped onto the stack.
138 @retval EFI_ACCESS_DENIED The pop operation underflowed the stack.
147 // Check for a stack underflow condition
149 if (mDepexEvaluationStackPointer
== mDepexEvaluationStack
) {
150 return EFI_ACCESS_DENIED
;
154 // Pop the item off the stack
156 mDepexEvaluationStackPointer
--;
157 *Value
= *mDepexEvaluationStackPointer
;
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. The SOR is just ignored and is a nop in the grammer.
165 POSTFIX means all the math is done on top of the stack.
167 @param DriverEntry DriverEntry element to update.
169 @retval TRUE If driver is ready to run.
170 @retval FALSE If driver is not ready to run or some fatal error
176 IN EFI_SMM_DRIVER_ENTRY
*DriverEntry
189 if (DriverEntry
->After
|| DriverEntry
->Before
) {
191 // If Before or After Depex skip as SmmInsertOnScheduledQueueWhileProcessingBeforeAndAfter ()
197 if (DriverEntry
->Depex
== NULL
) {
199 // A NULL Depex means that the SMM driver is not built correctly.
200 // All SMM drivers must have a valid depex expressiion.
207 // Clean out memory leaks in Depex Boolean stack. Leaks are only caused by
208 // incorrectly formed DEPEX expressions
210 mDepexEvaluationStackPointer
= mDepexEvaluationStack
;
213 Iterator
= DriverEntry
->Depex
;
217 // Check to see if we are attempting to fetch dependency expression instructions
218 // past the end of the dependency expression.
220 if (((UINTN
)Iterator
- (UINTN
)DriverEntry
->Depex
) >= DriverEntry
->DepexSize
) {
225 // Look at the opcode of the dependency expression instruction.
231 // For a well-formed Dependency Expression, the code should never get here.
232 // The BEFORE and AFTER are processed prior to this routine's invocation.
233 // If the code flow arrives at this point, there was a BEFORE or AFTER
234 // that were not the first opcodes.
239 // These opcodes can only appear once as the first opcode. If it is found
240 // at any other location, then the dependency expression evaluates to FALSE
242 if (Iterator
!= DriverEntry
->Depex
) {
246 // Otherwise, it is the first opcode and should be treated as a NOP.
252 // Push operator is followed by a GUID. Test to see if the GUID protocol
253 // is installed and push the boolean result on the stack.
255 CopyMem (&DriverGuid
, Iterator
+ 1, sizeof (EFI_GUID
));
257 Status
= SmmLocateProtocol (&DriverGuid
, NULL
, &Interface
);
258 if (EFI_ERROR (Status
)) {
260 // For SMM Driver, it may depend on uefi protocols
262 Status
= gBS
->LocateProtocol (&DriverGuid
, NULL
, &Interface
);
265 if (EFI_ERROR (Status
)) {
266 Status
= PushBool (FALSE
);
268 *Iterator
= EFI_DEP_REPLACE_TRUE
;
269 Status
= PushBool (TRUE
);
271 if (EFI_ERROR (Status
)) {
275 Iterator
+= sizeof (EFI_GUID
);
279 Status
= PopBool (&Operator
);
280 if (EFI_ERROR (Status
)) {
284 Status
= PopBool (&Operator2
);
285 if (EFI_ERROR (Status
)) {
289 Status
= PushBool ((BOOLEAN
)(Operator
&& Operator2
));
290 if (EFI_ERROR (Status
)) {
296 Status
= PopBool (&Operator
);
297 if (EFI_ERROR (Status
)) {
301 Status
= PopBool (&Operator2
);
302 if (EFI_ERROR (Status
)) {
306 Status
= PushBool ((BOOLEAN
)(Operator
|| Operator2
));
307 if (EFI_ERROR (Status
)) {
313 Status
= PopBool (&Operator
);
314 if (EFI_ERROR (Status
)) {
318 Status
= PushBool ((BOOLEAN
)(!Operator
));
319 if (EFI_ERROR (Status
)) {
325 Status
= PushBool (TRUE
);
326 if (EFI_ERROR (Status
)) {
332 Status
= PushBool (FALSE
);
333 if (EFI_ERROR (Status
)) {
339 Status
= PopBool (&Operator
);
340 if (EFI_ERROR (Status
)) {
345 case EFI_DEP_REPLACE_TRUE
:
346 Status
= PushBool (TRUE
);
347 if (EFI_ERROR (Status
)) {
351 Iterator
+= sizeof (EFI_GUID
);
359 // Skip over the Dependency Op Code we just processed in the switch.
360 // The math is done out of order, but it should not matter. That is
361 // we may add in the sizeof (EFI_GUID) before we account for the OP Code.
362 // This is not an issue, since we just need the correct end result. You
363 // need to be careful using Iterator in the loop as it's intermediate value