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 - 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 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 } 389