ShellPkg/Library/UefiShellDriver1CommandsLib/Dh.c

   1 /** @file
   2   Main file for Dh shell Driver1 function.
   3
   4   Copyright (c) 2010, 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 SHELL_PARAM_ITEM ParamList[] = {
  18   {L"-p", TypeValue},
  19   {L"-d", TypeFlag},
  20   {L"-v", TypeFlag},
  21   {L"-verbose", TypeFlag},
  22   {L"-sfo", TypeFlag},
  23   {L"-l", TypeValue},
  24   {NULL, TypeMax}
  25   };
  26
  27 STATIC CONST EFI_GUID *UefiDriverModelProtocolsGuidArray[] = {
  28   &gEfiDriverBindingProtocolGuid,
  29   &gEfiPlatformDriverOverrideProtocolGuid,
  30   &gEfiBusSpecificDriverOverrideProtocolGuid,
  31   &gEfiDriverDiagnosticsProtocolGuid,
  32   &gEfiDriverDiagnostics2ProtocolGuid,
  33   &gEfiComponentNameProtocolGuid,
  34   &gEfiComponentName2ProtocolGuid,
  35   &gEfiPlatformToDriverConfigurationProtocolGuid,
  36   &gEfiDriverSupportedEfiVersionProtocolGuid,
  37   &gEfiDriverFamilyOverrideProtocolGuid,
  38   &gEfiDriverHealthProtocolGuid,
  39   &gEfiLoadedImageProtocolGuid,
  40   NULL
  41 };
  42
  43 BOOLEAN
  44 EFIAPI
  45 IsDriverProt (
  46   IN CONST EFI_GUID *Guid
  47   )
  48 {
  49   CONST EFI_GUID            **GuidWalker;
  50   BOOLEAN                   GuidFound;
  51   GuidFound = FALSE;
  52   for (GuidWalker = UefiDriverModelProtocolsGuidArray
  53     ;  GuidWalker != NULL && *GuidWalker != NULL
  54     ;  GuidWalker++
  55    ){
  56     if (CompareGuid(*GuidWalker, Guid)) {
  57       GuidFound = TRUE;
  58       break;
  59     }
  60   }
  61   return (GuidFound);
  62 }
  63
  64 CHAR16*
  65 EFIAPI
  66 GetProtocolInfoString(
  67   IN CONST EFI_HANDLE TheHandle,
  68   IN CONST CHAR8      *Language,
  69   IN CONST CHAR16     *Seperator,
  70   IN CONST BOOLEAN    DriverInfo,
  71   IN CONST BOOLEAN    Verbose,
  72   IN CONST BOOLEAN    ExtraInfo
  73   )
  74 {
  75   EFI_GUID                  **ProtocolGuidArray;
  76   UINTN                     ArrayCount;
  77   UINTN                     ProtocolIndex;
  78   EFI_STATUS                Status;
  79   CHAR16                    *RetVal;
  80   UINTN                     Size;
  81   CHAR16                    *Temp;
  82
  83   ProtocolGuidArray = NULL;
  84
  85   Status = gBS->ProtocolsPerHandle (
  86                 TheHandle,
  87                 &ProtocolGuidArray,
  88                 &ArrayCount
  89                );
  90   if (!EFI_ERROR (Status)) {
  91     RetVal = NULL;
  92     Size   = 0;
  93     for (ProtocolIndex = 0; ProtocolIndex < ArrayCount; ProtocolIndex++) {
  94       Temp = GetStringNameFromGuid(ProtocolGuidArray[ProtocolIndex], Language);
  95       if (Temp != NULL) {
  96         ASSERT((RetVal == NULL && Size == 0) || (RetVal != NULL));
  97         if (Size != 0) {
  98           StrnCatGrow(&RetVal, &Size, Seperator, 0);
  99         }
 100         StrnCatGrow(&RetVal, &Size, L"%H", 0);
 101         StrnCatGrow(&RetVal, &Size, Temp, 0);
 102         StrnCatGrow(&RetVal, &Size, L"%N", 0);
 103         FreePool(Temp);
 104       }
 105       if (ExtraInfo) {
 106         Temp = GetProtocolInformationDump(TheHandle, ProtocolGuidArray[ProtocolIndex], Verbose);
 107         if (Temp != NULL) {
 108           ASSERT((RetVal == NULL && Size == 0) || (RetVal != NULL));
 109           if (!Verbose) {
 110             StrnCatGrow(&RetVal, &Size, L"(", 0);
 111             StrnCatGrow(&RetVal, &Size, Temp, 0);
 112             StrnCatGrow(&RetVal, &Size, L")", 0);
 113           } else {
 114             StrnCatGrow(&RetVal, &Size, Seperator, 0);
 115             StrnCatGrow(&RetVal, &Size, Temp, 0);
 116           }
 117           FreePool(Temp);
 118         }
 119       }
 120     }
 121   } else {
 122     return (NULL);
 123   }
 124
 125   if (ProtocolGuidArray != NULL) {
 126     FreePool(ProtocolGuidArray);
 127   }
 128   ASSERT((RetVal == NULL && Size == 0) || (RetVal != NULL));
 129   StrnCatGrow(&RetVal, &Size, Seperator, 0);
 130   return (RetVal);
 131 }
 132
 133 SHELL_STATUS
 134 EFIAPI
 135 DoDhByHandle(
 136   IN CONST EFI_HANDLE TheHandle,
 137   IN CONST BOOLEAN    Verbose,
 138   IN CONST BOOLEAN    Sfo,
 139   IN CONST CHAR8      *Language,
 140   IN CONST BOOLEAN    DriverInfo,
 141   IN CONST BOOLEAN    Multiple
 142   )
 143 {
 144   CHAR16              *ProtocolInfoString;
 145   SHELL_STATUS        ShellStatus;
 146   EFI_STATUS          Status;
 147
 148   Status              = EFI_SUCCESS;
 149   ShellStatus         = SHELL_SUCCESS;
 150   ProtocolInfoString  = NULL;
 151
 152   if (!Sfo) {
 153     if (Multiple) {
 154       ProtocolInfoString = GetProtocolInfoString(TheHandle, Language, L" ", DriverInfo, Verbose, TRUE);
 155       ShellPrintHiiEx(
 156         -1,
 157         -1,
 158         NULL,
 159         STRING_TOKEN (STR_DH_OUTPUT),
 160         gShellDriver1HiiHandle,
 161         ConvertHandleToHandleIndex(TheHandle),
 162         ProtocolInfoString==NULL?L"":ProtocolInfoString);
 163     } else {
 164       ProtocolInfoString = GetProtocolInfoString(TheHandle, Language, L"\r\n", DriverInfo, Verbose, TRUE);
 165       ShellPrintHiiEx(
 166         -1,
 167         -1,
 168         NULL,
 169         STRING_TOKEN (STR_DH_OUTPUT_SINGLE),
 170         gShellDriver1HiiHandle,
 171         ConvertHandleToHandleIndex(TheHandle),
 172         TheHandle,
 173         ProtocolInfoString==NULL?L"":ProtocolInfoString);
 174     }
 175   } else {
 176 //#string STR_DH_OUTPUT_SFO         #language en-US "%s, %s, %s, %H%02x%N, %s, %s\r\n"
 177       ProtocolInfoString = GetProtocolInfoString(TheHandle, Language, L";", DriverInfo, FALSE, FALSE);
 178       ShellPrintHiiEx(
 179         -1,
 180         -1,
 181         NULL,
 182         STRING_TOKEN (STR_DH_OUTPUT_SFO),
 183         gShellDriver1HiiHandle,
 184         Multiple ?L"HandlesInfo":L"HandleInfo",
 185         L"DriverName",
 186         L"ControllerName",
 187         ConvertHandleToHandleIndex(TheHandle),
 188         L"DevPath",
 189         ProtocolInfoString==NULL?L"":ProtocolInfoString);
 190
 191
 192   }
 193
 194
 195   if (ProtocolInfoString != NULL) {
 196     FreePool(ProtocolInfoString);
 197   }
 198   return (ShellStatus);
 199 }
 200
 201 SHELL_STATUS
 202 EFIAPI
 203 DoDhForHandleList(
 204   IN CONST EFI_HANDLE *HandleList,
 205   IN CONST BOOLEAN    Sfo,
 206   IN CONST CHAR8      *Language,
 207   IN CONST BOOLEAN    DriverInfo
 208   )
 209 {
 210   CONST EFI_HANDLE  *HandleWalker;
 211   SHELL_STATUS      ShellStatus;
 212
 213   ShellStatus       = SHELL_SUCCESS;
 214
 215   for (HandleWalker = HandleList ; HandleWalker != NULL && *HandleWalker != NULL && ShellStatus == SHELL_SUCCESS; HandleWalker++) {
 216     ShellStatus = DoDhByHandle(
 217           *HandleWalker,
 218           FALSE,
 219           Sfo,
 220           Language,
 221           DriverInfo,
 222           TRUE
 223          );
 224   }
 225   return (ShellStatus);
 226 }
 227
 228 SHELL_STATUS
 229 EFIAPI
 230 DoDhForAll(
 231   IN CONST BOOLEAN  Sfo,
 232   IN CONST CHAR8    *Language,
 233   IN CONST BOOLEAN  DriverInfo
 234   )
 235 {
 236   EFI_HANDLE    *HandleList;
 237   SHELL_STATUS  ShellStatus;
 238
 239   HandleList = GetHandleListByProtocol(NULL);
 240
 241   ShellStatus = DoDhForHandleList(
 242     HandleList,
 243     Sfo,
 244     Language,
 245     DriverInfo);
 246
 247   FreePool(HandleList);
 248
 249   return (ShellStatus);
 250 }
 251
 252 SHELL_STATUS
 253 EFIAPI
 254 DoDhByProtocol(
 255   IN CONST CHAR16   *ProtocolName,
 256   IN CONST BOOLEAN  Sfo,
 257   IN CONST CHAR8    *Language,
 258   IN CONST BOOLEAN  DriverInfo
 259   )
 260 {
 261   EFI_GUID      *Guid;
 262   EFI_STATUS    Status;
 263   EFI_HANDLE    *HandleList;
 264   SHELL_STATUS  ShellStatus;
 265
 266   ASSERT(ProtocolName != NULL);
 267
 268   Status = GetGuidFromStringName(ProtocolName, Language, &Guid);
 269   if (EFI_ERROR(Status)) {
 270     ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_DH_NO_GUID_FOUND), gShellDriver1HiiHandle, ProtocolName);
 271     return (SHELL_INVALID_PARAMETER);
 272   }
 273
 274   HandleList = GetHandleListByProtocol(Guid);
 275
 276   ShellStatus = DoDhForHandleList(
 277     HandleList,
 278     Sfo,
 279     Language,
 280     DriverInfo);
 281
 282   SHELL_FREE_NON_NULL(HandleList);
 283
 284   return (ShellStatus);
 285 }
 286
 287 SHELL_STATUS
 288 EFIAPI
 289 ShellCommandRunDh (
 290   IN EFI_HANDLE        ImageHandle,
 291   IN EFI_SYSTEM_TABLE  *SystemTable
 292   )
 293 {
 294   EFI_STATUS          Status;
 295   LIST_ENTRY          *Package;
 296   CHAR16              *ProblemParam;
 297   SHELL_STATUS        ShellStatus;
 298   CHAR8               *Language;
 299   CONST CHAR16        *Lang;
 300   CONST CHAR16        *Temp2;
 301   BOOLEAN             SfoMode;
 302   BOOLEAN             FlagD;
 303   BOOLEAN             Verbose;
 304
 305   ShellStatus         = SHELL_SUCCESS;
 306   Status              = EFI_SUCCESS;
 307   Language            = NULL;
 308
 309   //
 310   // initialize the shell lib (we must be in non-auto-init...)
 311   //
 312   Status = ShellInitialize();
 313   ASSERT_EFI_ERROR(Status);
 314
 315   Status = CommandInit();
 316   ASSERT_EFI_ERROR(Status);
 317
 318   //
 319   // parse the command line
 320   //
 321   Status = ShellCommandLineParse (ParamList, &Package, &ProblemParam, TRUE);
 322   if (EFI_ERROR(Status)) {
 323     if (Status == EFI_VOLUME_CORRUPTED && ProblemParam != NULL) {
 324       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellDriver1HiiHandle, ProblemParam);
 325       FreePool(ProblemParam);
 326       ShellStatus = SHELL_INVALID_PARAMETER;
 327     } else {
 328       ASSERT(FALSE);
 329     }
 330   } else {
 331     if (ShellCommandLineGetCount(Package) > 2) {
 332       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDriver1HiiHandle);
 333       ShellCommandLineFreeVarList (Package);
 334       return (SHELL_INVALID_PARAMETER);
 335     }
 336
 337     Lang = ShellCommandLineGetValue(Package, L"-l");
 338     if (Lang != NULL) {
 339       Language = AllocateZeroPool(StrSize(Lang));
 340       AsciiSPrint(Language, StrSize(Lang), "%S", Lang);
 341     } else if (!ShellCommandLineGetFlag(Package, L"-l")){
 342       Language = AllocateZeroPool(10);
 343       AsciiSPrint(Language, 10, "en-us");
 344     } else {
 345       ASSERT(Language == NULL);
 346       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_VALUE), gShellDriver1HiiHandle, L"-l");
 347       ShellCommandLineFreeVarList (Package);
 348       return (SHELL_INVALID_PARAMETER);
 349     }
 350
 351     SfoMode = ShellCommandLineGetFlag(Package, L"-sfo");
 352     FlagD   = ShellCommandLineGetFlag(Package, L"-d");
 353     if (ShellCommandLineGetFlag(Package, L"-v") || ShellCommandLineGetFlag(Package, L"-verbose")) {
 354       Verbose = TRUE;
 355     } else {
 356       Verbose = FALSE;
 357     }
 358
 359     if (ShellCommandLineGetFlag(Package, L"-p")) {
 360       if (ShellCommandLineGetCount(Package) > 1) {
 361         ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDriver1HiiHandle);
 362         ShellStatus = SHELL_INVALID_PARAMETER;
 363       } else if (ShellCommandLineGetValue(Package, L"-p") == NULL) {
 364         ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_VALUE), gShellDriver1HiiHandle, L"-p");
 365         ShellStatus = SHELL_INVALID_PARAMETER;
 366       } else {
 367         //
 368         // print by protocol
 369         //
 370         ShellStatus = DoDhByProtocol(
 371           ShellCommandLineGetValue(Package, L"-p"),
 372           SfoMode,
 373           Lang==NULL?NULL:Language,
 374           FlagD
 375          );
 376       }
 377     } else {
 378       Temp2 = ShellCommandLineGetRawValue(Package, 1);
 379       if (Temp2 == NULL) {
 380         //
 381         // Print everything
 382         //
 383         ShellStatus = DoDhForAll(
 384           SfoMode,
 385           Lang==NULL?NULL:Language,
 386           FlagD
 387          );
 388       } else {
 389         if (!ShellIsHexOrDecimalNumber(Temp2, TRUE, FALSE) || ConvertHandleIndexToHandle(StrHexToUintn(Temp2)) == NULL) {
 390           ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_INV_HANDLE), gShellDriver1HiiHandle, Temp2);
 391           ShellStatus = SHELL_INVALID_PARAMETER;
 392         } else {
 393           //
 394           // print 1 handle
 395           //
 396           ShellStatus = DoDhByHandle(
 397             ConvertHandleIndexToHandle(StrHexToUintn(Temp2)),
 398             Verbose,
 399             SfoMode,
 400             Lang==NULL?NULL:Language,
 401             FlagD,
 402             FALSE
 403            );
 404         }
 405       }
 406     }
 407
 408
 409     ShellCommandLineFreeVarList (Package);
 410     SHELL_FREE_NON_NULL(Language);
 411   }
 412
 413   return (ShellStatus);
 414 }