ShellPkg/Library/UefiShellDriver1CommandsLib/DrvDiag.c

   1 /** @file
   2   Main file for DrvDiag shell Driver1 function.
   3
   4   Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>
   5   This program and the accompanying materials
   6   are licensed and made available under the terms and conditions of the BSD License
   7   which accompanies this distribution.  The full text of the license may be found at
   8   http://opensource.org/licenses/bsd-license.php
   9
  10   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13 **/
  14
  15 #include "UefiShellDriver1CommandsLib.h"
  16
  17 STATIC CONST EFI_GUID *DiagGuidList[] = {&gEfiDriverDiagnosticsProtocolGuid, &gEfiDriverDiagnostics2ProtocolGuid, NULL};
  18 //
  19 // We need 1 more item on the list...
  20 //
  21 typedef enum {
  22   TestModeStandard      = EfiDriverDiagnosticTypeStandard,
  23   TestModeExtended      = EfiDriverDiagnosticTypeExtended,
  24   TestModeManufacturing = EfiDriverDiagnosticTypeManufacturing,
  25   TestModeList,
  26   TestModeMax
  27 } DRV_DIAG_TEST_MODE;
  28
  29 /**
  30   Do the diagnostics call for some set of handles.
  31
  32   @param[in] Mode               The type of diagnostic test to run.
  33   @param[in] Lang               The language code to use.
  34   @param[in] AllChilds          Should the test be on all children.
  35   @param[in] DriverHandle       The driver handle to test with.
  36   @param[in] ControllerHandle   The specific controller handle to test.
  37   @param[in] ChildHandle        The specific child handle to test.
  38
  39   @retval EFI_SUCCESS           The operation was successful.
  40   @retval EFI_INVALID_PARAMETER A parameter had an invalid value.
  41   @retval EFI_NOT_FOUND         No diagnostic handle could be found.
  42 **/
  43 EFI_STATUS
  44 EFIAPI
  45 DoDiagnostics (
  46   IN CONST DRV_DIAG_TEST_MODE Mode,
  47   IN CONST CHAR8              *Lang,
  48   IN CONST BOOLEAN            AllChilds,
  49   IN CONST EFI_HANDLE         DriverHandle,
  50   IN CONST EFI_HANDLE         ControllerHandle,
  51   IN CONST EFI_HANDLE         ChildHandle
  52   )
  53 {
  54   EFI_DRIVER_DIAGNOSTICS_PROTOCOL     *DriverDiagnostics;
  55   EFI_DRIVER_DIAGNOSTICS2_PROTOCOL    *DriverDiagnostics2;
  56   EFI_HANDLE                          *DriverHandleList;
  57   EFI_HANDLE                          *ControllerHandleList;
  58   EFI_HANDLE                          *ChildHandleList;
  59   EFI_HANDLE                          *Walker;
  60   UINTN                               DriverHandleListCount;
  61   UINTN                               ControllerHandleListCount;
  62   UINTN                               ChildHandleListCount;
  63   UINTN                               DriverHandleListLoop;
  64   UINTN                               ControllerHandleListLoop;
  65   UINTN                               ChildHandleListLoop;
  66   EFI_STATUS                          Status;
  67   EFI_STATUS                          Status2;
  68   EFI_GUID                            *ErrorType;
  69   UINTN                               OutBufferSize;
  70   CHAR16                              *OutBuffer;
  71   UINTN                               HandleIndex1;
  72   UINTN                               HandleIndex2;
  73   CHAR8                               *Language;
  74   CHAR8                               *TempChar;
  75   BOOLEAN                             Found;
  76
  77   if ((ChildHandle != NULL && AllChilds) || (Mode >= TestModeMax)){
  78     return (EFI_INVALID_PARAMETER);
  79   }
  80
  81   DriverDiagnostics                   = NULL;
  82   DriverDiagnostics2                  = NULL;
  83   Status                              = EFI_SUCCESS;
  84   Status2                             = EFI_SUCCESS;
  85   DriverHandleList                    = NULL;
  86   ControllerHandleList                = NULL;
  87   ChildHandleList                     = NULL;
  88   Language                            = NULL;
  89   OutBuffer                           = NULL;
  90   ErrorType                           = NULL;
  91   DriverHandleListCount               = 0;
  92   ControllerHandleListCount           = 0;
  93   ChildHandleListCount                = 0;
  94
  95   if (DriverHandle != NULL) {
  96     DriverHandleList = AllocateZeroPool(2*sizeof(EFI_HANDLE));
  97     ASSERT(DriverHandleList!=NULL);
  98     DriverHandleList[0] = DriverHandle;
  99     DriverHandleListCount = 1;
 100   } else {
 101     DriverHandleList = GetHandleListByProtocolList(DiagGuidList);
 102     if (DriverHandleList == NULL) {
 103       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROTOCOL_NF), gShellDriver1HiiHandle, L"gEfiDriverDiagnosticsProtocolGuid", &gEfiDriverDiagnosticsProtocolGuid);
 104       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROTOCOL_NF), gShellDriver1HiiHandle, L"gEfiDriverDiagnostics2ProtocolGuid", &gEfiDriverDiagnostics2ProtocolGuid);
 105       return (EFI_NOT_FOUND);
 106     }
 107     for (Walker = DriverHandleList ; Walker != NULL && *Walker != NULL ; DriverHandleListCount++, Walker++);
 108   }
 109
 110   if (ControllerHandle != NULL) {
 111     ControllerHandleList = AllocateZeroPool(2*sizeof(EFI_HANDLE));
 112     ASSERT(ControllerHandleList!=NULL);
 113     ControllerHandleList[0] = ControllerHandle;
 114     ControllerHandleListCount = 1;
 115   } else {
 116     ControllerHandleList = NULL;
 117   }
 118
 119   if (ChildHandle != NULL) {
 120     ChildHandleList = AllocateZeroPool(2*sizeof(EFI_HANDLE));
 121     ASSERT(ChildHandleList!=NULL);
 122     ChildHandleList[0] = ChildHandle;
 123     ChildHandleListCount = 1;
 124   } else if (AllChilds) {
 125     ChildHandleList = NULL;
 126     //
 127     // This gets handled in the loop below.
 128     //
 129   } else {
 130     ChildHandleList = NULL;
 131   }
 132
 133   if (Mode == TestModeList) {
 134     ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_DRVDIAG_HEADER), gShellDriver1HiiHandle);
 135   }
 136   for (DriverHandleListLoop = 0
 137     ;  DriverHandleListLoop < DriverHandleListCount
 138     ;  DriverHandleListLoop++
 139     ){
 140     if (Mode == TestModeList) {
 141       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_DRVDIAG_DRIVER_HEADER), gShellDriver1HiiHandle, ConvertHandleToHandleIndex(DriverHandleList[DriverHandleListLoop]));
 142     }
 143     if (ControllerHandle == NULL) {
 144       PARSE_HANDLE_DATABASE_DEVICES(DriverHandleList[DriverHandleListLoop], &ControllerHandleListCount, &ControllerHandleList);
 145     }
 146     if (ControllerHandleListCount == 0) {
 147       if (Mode == TestModeList) {
 148         ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_DRVDIAG_DRIVER_NO_HANDLES), gShellDriver1HiiHandle);
 149       }
 150     } else {
 151       if (Mode == TestModeList) {
 152         ShellPrintEx(-1, -1, L"\r\n");
 153       }
 154       for (ControllerHandleListLoop = 0
 155         ;  ControllerHandleListLoop < ControllerHandleListCount
 156         ;  ControllerHandleListLoop++
 157         ){
 158         if (AllChilds) {
 159           ASSERT(ChildHandleList == NULL);
 160           PARSE_HANDLE_DATABASE_MANAGED_CHILDREN(
 161             DriverHandleList[DriverHandleListLoop],
 162             ControllerHandleList[ControllerHandleListLoop],
 163             &ChildHandleListCount,
 164             &ChildHandleList);
 165         }
 166         for (ChildHandleListLoop = 0
 167           ;  (ChildHandleListLoop < ChildHandleListCount || ChildHandleList == NULL)
 168           ;  ChildHandleListLoop++
 169           ){
 170           Found = FALSE;
 171           if (Mode != TestModeList) {
 172             if (Lang == NULL || Lang[2] == '-') {
 173               //
 174               // Get the protocol pointer and call the function
 175               //
 176               Status = gBS->OpenProtocol(
 177                 DriverHandleList[DriverHandleListLoop],
 178                 &gEfiDriverDiagnostics2ProtocolGuid,
 179                 (VOID**)&DriverDiagnostics2,
 180                 gImageHandle,
 181                 NULL,
 182                 EFI_OPEN_PROTOCOL_GET_PROTOCOL);
 183               if (!EFI_ERROR(Status)) {
 184                 if (Lang == NULL) {
 185                   Language = AllocateZeroPool(AsciiStrSize(DriverDiagnostics2->SupportedLanguages));
 186                   if (Language == NULL) {
 187                     return (EFI_OUT_OF_RESOURCES);
 188                   }
 189                   AsciiStrCpy(Language, DriverDiagnostics2->SupportedLanguages);
 190                   TempChar = AsciiStrStr(Language, ";");
 191                   if (TempChar != NULL){
 192                     *TempChar = CHAR_NULL;
 193                   }
 194                 } else {
 195                   Language = AllocateZeroPool(AsciiStrSize(Lang));
 196                   if (Language == NULL) {
 197                     return (EFI_OUT_OF_RESOURCES);
 198                   }
 199                   AsciiStrCpy(Language, Lang);
 200                 }
 201                 Found = TRUE;
 202                 Status = DriverDiagnostics2->RunDiagnostics(
 203                   DriverDiagnostics2,
 204                   ControllerHandleList[ControllerHandleListLoop],
 205                   ChildHandleList == NULL?NULL:ChildHandleList[ChildHandleListLoop],
 206                   (EFI_DRIVER_DIAGNOSTIC_TYPE)Mode,
 207                   Language,
 208                   &ErrorType,
 209                   &OutBufferSize,
 210                   &OutBuffer);
 211                 FreePool(Language);
 212               }
 213             }
 214             if (!Found && (Lang == NULL||(Lang!=NULL&&(Lang[2]!='-')))){
 215               Status = gBS->OpenProtocol(
 216                 DriverHandleList[DriverHandleListLoop],
 217                 &gEfiDriverDiagnosticsProtocolGuid,
 218                 (VOID**)&DriverDiagnostics,
 219                 gImageHandle,
 220                 NULL,
 221                 EFI_OPEN_PROTOCOL_GET_PROTOCOL);
 222               if (!EFI_ERROR(Status)) {
 223                 if (Lang == NULL) {
 224                   Language = AllocateZeroPool(AsciiStrSize(DriverDiagnostics2->SupportedLanguages));
 225                   if (Language == NULL) {
 226                     return (EFI_OUT_OF_RESOURCES);
 227                   }
 228                   AsciiStrCpy(Language, DriverDiagnostics2->SupportedLanguages);
 229                   TempChar = AsciiStrStr(Language, ";");
 230                   if (TempChar != NULL){
 231                     *TempChar = CHAR_NULL;
 232                   }
 233                 } else {
 234                   Language = AllocateZeroPool(AsciiStrSize(Lang));
 235                   if (Language == NULL) {
 236                     return (EFI_OUT_OF_RESOURCES);
 237                   }
 238                   AsciiStrCpy(Language, Lang);
 239                 }
 240                 Status = DriverDiagnostics->RunDiagnostics(
 241                   DriverDiagnostics,
 242                   ControllerHandleList[ControllerHandleListLoop],
 243                   ChildHandleList == NULL?NULL:ChildHandleList[ChildHandleListLoop],
 244                   (EFI_DRIVER_DIAGNOSTIC_TYPE)Mode,
 245                   Language,
 246                   &ErrorType,
 247                   &OutBufferSize,
 248                   &OutBuffer);
 249                 FreePool(Language);
 250               }
 251             }
 252             if (EFI_ERROR(Status)) {
 253               Status2 = Status;
 254             }
 255             HandleIndex1 = ConvertHandleToHandleIndex(DriverHandleList[DriverHandleListLoop]);
 256             HandleIndex2 = ConvertHandleToHandleIndex(ControllerHandleList[ControllerHandleListLoop]);
 257             ShellPrintHiiEx(
 258               -1,
 259               -1,
 260               NULL,
 261               STRING_TOKEN (STR_3P_RESULT),
 262               gShellDriver1HiiHandle,
 263               L"DrvDiag",
 264               HandleIndex1,
 265               HandleIndex2,
 266               ChildHandleList == NULL?0:ConvertHandleToHandleIndex(ChildHandleList[ChildHandleListLoop]),
 267               Status);
 268             if (OutBuffer!=NULL) {
 269               FreePool(OutBuffer);
 270               OutBuffer = NULL;
 271             }
 272             if (ErrorType!=NULL) {
 273               FreePool(ErrorType);
 274               ErrorType = NULL;
 275             }
 276           } else {
 277             HandleIndex1 = ConvertHandleToHandleIndex(DriverHandleList[DriverHandleListLoop]);
 278             HandleIndex2 = ConvertHandleToHandleIndex(ControllerHandleList[ControllerHandleListLoop]);
 279             //
 280             // Print out the information that this set can be tested
 281             //
 282             ShellPrintHiiEx(
 283               -1,
 284               -1,
 285               NULL,
 286               STRING_TOKEN (STR_DRV_DIAG_ITEM_LINE),
 287               gShellDriver1HiiHandle,
 288               HandleIndex1,
 289               HandleIndex2,
 290               ChildHandleList == NULL?0:ConvertHandleToHandleIndex(ChildHandleList[ChildHandleListLoop])
 291            );
 292           }
 293
 294           //
 295           // If we are doing a single pass with NULL child jump out after a single loop
 296           //
 297           if (ChildHandleList == NULL) {
 298             break;
 299           }
 300         }
 301         if (AllChilds) {
 302           SHELL_FREE_NON_NULL(ChildHandleList);
 303           ChildHandleList       = NULL;
 304           ChildHandleListCount  = 0;
 305         }
 306       }
 307       if (ControllerHandle == NULL) {
 308         SHELL_FREE_NON_NULL(ControllerHandleList);
 309         ControllerHandleList      = NULL;
 310         ControllerHandleListCount = 0;
 311       }
 312       }
 313   }
 314
 315   if (DriverHandleList != NULL) {
 316     FreePool(DriverHandleList);
 317   }
 318   if (ControllerHandleList != NULL) {
 319     FreePool(ControllerHandleList);
 320   }
 321   if (ChildHandleList != NULL) {
 322     FreePool(ChildHandleList);
 323   }
 324   return (Status2);
 325 }
 326
 327
 328 STATIC CONST SHELL_PARAM_ITEM ParamList[] = {
 329   {L"-c", TypeFlag},
 330   {L"-s", TypeFlag},
 331   {L"-e", TypeFlag},
 332   {L"-m", TypeFlag},
 333   {L"-l", TypeValue},
 334   {NULL, TypeMax}
 335   };
 336
 337 /**
 338   Function for 'drvdiag' command.
 339
 340   @param[in] ImageHandle  Handle to the Image (NULL if Internal).
 341   @param[in] SystemTable  Pointer to the System Table (NULL if Internal).
 342 **/
 343 SHELL_STATUS
 344 EFIAPI
 345 ShellCommandRunDrvDiag (
 346   IN EFI_HANDLE        ImageHandle,
 347   IN EFI_SYSTEM_TABLE  *SystemTable
 348   )
 349 {
 350   EFI_STATUS          Status;
 351   LIST_ENTRY          *Package;
 352   CHAR16              *ProblemParam;
 353   SHELL_STATUS        ShellStatus;
 354   DRV_DIAG_TEST_MODE  Mode;
 355   CHAR8               *Language;
 356   CONST CHAR16        *DriverHandleStr;
 357   CONST CHAR16        *ControllerHandleStr;
 358   CONST CHAR16        *ChildHandleStr;
 359   CONST CHAR16        *Lang;
 360   EFI_HANDLE          Handle1;
 361   EFI_HANDLE          Handle2;
 362   EFI_HANDLE          Handle3;
 363   UINT64              Intermediate;
 364
 365   ShellStatus         = SHELL_SUCCESS;
 366   Mode                = TestModeMax;
 367   Language            = NULL;
 368
 369   //
 370   // initialize the shell lib (we must be in non-auto-init...)
 371   //
 372   Status = ShellInitialize();
 373   ASSERT_EFI_ERROR(Status);
 374
 375   Status = CommandInit();
 376   ASSERT_EFI_ERROR(Status);
 377
 378   //
 379   // parse the command line
 380   //
 381   Status = ShellCommandLineParse (ParamList, &Package, &ProblemParam, TRUE);
 382   if (EFI_ERROR(Status)) {
 383     if (Status == EFI_VOLUME_CORRUPTED && ProblemParam != NULL) {
 384       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellDriver1HiiHandle, ProblemParam);
 385       FreePool(ProblemParam);
 386       ShellStatus = SHELL_INVALID_PARAMETER;
 387     } else {
 388       ASSERT(FALSE);
 389     }
 390   } else {
 391     //
 392     // if more than 3 'value' parameters (plus the name one) or we have any 2 mode flags
 393     //
 394     if ((ShellCommandLineGetCount(Package) > 4)
 395       ||(ShellCommandLineGetFlag(Package, L"-s") && ShellCommandLineGetFlag(Package, L"-e"))
 396       ||(ShellCommandLineGetFlag(Package, L"-s") && ShellCommandLineGetFlag(Package, L"-m"))
 397       ||(ShellCommandLineGetFlag(Package, L"-e") && ShellCommandLineGetFlag(Package, L"-m"))
 398      ){
 399       //
 400       // error for too many parameters
 401       //
 402       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDriver1HiiHandle);
 403       ShellStatus = SHELL_INVALID_PARAMETER;
 404     } else if ((ShellCommandLineGetFlag(Package, L"-s"))
 405             || (ShellCommandLineGetFlag(Package, L"-e"))
 406             || (ShellCommandLineGetFlag(Package, L"-m"))
 407            ){
 408       //
 409       // Run the apropriate test
 410       //
 411       if        (ShellCommandLineGetFlag(Package, L"-s")) {
 412         Mode =   TestModeStandard;
 413       } else if (ShellCommandLineGetFlag(Package, L"-e")) {
 414         Mode = TestModeExtended;
 415       } else if (ShellCommandLineGetFlag(Package, L"-m")) {
 416         Mode = TestModeManufacturing;
 417       } else {
 418         ASSERT(FALSE);
 419       }
 420     } else {
 421       //
 422       // Do a listing of what's available to test
 423       //
 424       Mode = TestModeList;
 425     }
 426
 427     Lang = ShellCommandLineGetValue(Package, L"-l");
 428     if (ShellCommandLineGetFlag(Package, L"-l") && Lang == NULL) {
 429       ASSERT(Language == NULL);
 430       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_VALUE), gShellDriver1HiiHandle, L"-l");
 431       ShellCommandLineFreeVarList (Package);
 432       return (SHELL_INVALID_PARAMETER);
 433     } else if (Lang != NULL) {
 434       Language = AllocateZeroPool(StrSize(Lang));
 435       AsciiSPrint(Language, StrSize(Lang), "%S", Lang);
 436     }
 437
 438     DriverHandleStr     = ShellCommandLineGetRawValue(Package, 1);
 439     ControllerHandleStr = ShellCommandLineGetRawValue(Package, 2);
 440     ChildHandleStr      = ShellCommandLineGetRawValue(Package, 3);
 441
 442     if (DriverHandleStr == NULL) {
 443       Handle1 = NULL;
 444     } else {
 445       ShellConvertStringToUint64(DriverHandleStr, &Intermediate, TRUE, FALSE);
 446       Handle1 = ConvertHandleIndexToHandle((UINTN)Intermediate);
 447     }
 448     if (ControllerHandleStr == NULL) {
 449       Handle2 = NULL;
 450     } else {
 451       ShellConvertStringToUint64(ControllerHandleStr, &Intermediate, TRUE, FALSE);
 452       Handle2 = ConvertHandleIndexToHandle((UINTN)Intermediate);
 453     }
 454     if (ChildHandleStr == NULL) {
 455       Handle3 = NULL;
 456     } else {
 457       ShellConvertStringToUint64(ChildHandleStr, &Intermediate, TRUE, FALSE);
 458       Handle3 = ConvertHandleIndexToHandle((UINTN)Intermediate);
 459     }
 460
 461     Status = DoDiagnostics (
 462       Mode,
 463       Language,
 464       ShellCommandLineGetFlag(Package, L"-c"),
 465       Handle1,
 466       Handle2,
 467       Handle3
 468       );
 469
 470     SHELL_FREE_NON_NULL(Language);
 471     ShellCommandLineFreeVarList (Package);
 472
 473   }
 474   if (ShellStatus == SHELL_SUCCESS) {
 475     if (Status == EFI_SECURITY_VIOLATION) {
 476       ShellStatus = SHELL_SECURITY_VIOLATION;
 477     } else if (Status == EFI_INVALID_PARAMETER) {
 478       ShellStatus = SHELL_INVALID_PARAMETER;
 479     } else if (Status == EFI_NOT_FOUND) {
 480       ShellStatus = SHELL_NOT_FOUND;
 481     } else if (EFI_ERROR(Status)) {
 482       ShellStatus = SHELL_NOT_FOUND;
 483     }
 484   }
 485
 486   return (ShellStatus);
 487 }