ShellPkg/Library/UefiShellDriver1CommandsLib/Drivers.c

   1 /** @file
   2   Main file for Drivers shell Driver1 function.
   3
   4   (C) Copyright 2012-2015 Hewlett-Packard Development Company, L.P.<BR>
   5   Copyright (c) 2010 - 2018, Intel Corporation. All rights reserved.<BR>
   6   SPDX-License-Identifier: BSD-2-Clause-Patent
   7
   8 **/
   9
  10 #include "UefiShellDriver1CommandsLib.h"
  11
  12 #define MAX_LEN_DRIVER_NAME 35
  13
  14 STATIC CONST SHELL_PARAM_ITEM ParamList[] = {
  15   {L"-sfo", TypeFlag},
  16   {L"-l", TypeValue},
  17   {NULL, TypeMax}
  18   };
  19
  20 /**
  21   Get a device path (in text format) for a given handle.
  22
  23   @param[in] TheHandle      The handle to get the device path for.
  24
  25   @retval NULL    An error occured.
  26   @return         A pointer to the driver path as a string.  The callee must
  27                   free this memory.
  28 **/
  29 CHAR16*
  30 GetDevicePathTextForHandle(
  31   IN EFI_HANDLE TheHandle
  32   )
  33 {
  34   EFI_STATUS                Status;
  35   EFI_LOADED_IMAGE_PROTOCOL *LoadedImage;
  36   EFI_DEVICE_PATH_PROTOCOL  *ImageDevicePath;
  37   EFI_DEVICE_PATH_PROTOCOL  *FinalPath;
  38   CHAR16                    *RetVal;
  39
  40   FinalPath = NULL;
  41
  42   Status = gBS->OpenProtocol (
  43                 TheHandle,
  44                 &gEfiLoadedImageProtocolGuid,
  45                 (VOID**)&LoadedImage,
  46                 gImageHandle,
  47                 NULL,
  48                 EFI_OPEN_PROTOCOL_GET_PROTOCOL
  49                );
  50   if (!EFI_ERROR (Status)) {
  51     Status = gBS->OpenProtocol (
  52                   LoadedImage->DeviceHandle,
  53                   &gEfiDevicePathProtocolGuid,
  54                   (VOID**)&ImageDevicePath,
  55                   gImageHandle,
  56                   NULL,
  57                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
  58                  );
  59     if (!EFI_ERROR (Status)) {
  60       FinalPath = AppendDevicePath (ImageDevicePath, LoadedImage->FilePath);
  61       gBS->CloseProtocol(
  62         LoadedImage->DeviceHandle,
  63         &gEfiDevicePathProtocolGuid,
  64         gImageHandle,
  65         NULL);
  66     }
  67     gBS->CloseProtocol(
  68                 TheHandle,
  69                 &gEfiLoadedImageProtocolGuid,
  70                 gImageHandle,
  71                 NULL);
  72   }
  73
  74   if (FinalPath == NULL) {
  75     return (NULL);
  76   }
  77   RetVal = gEfiShellProtocol->GetFilePathFromDevicePath(FinalPath);
  78   if (RetVal == NULL) {
  79     RetVal = ConvertDevicePathToText(FinalPath, TRUE, TRUE);
  80   }
  81   FreePool(FinalPath);
  82   return (RetVal);
  83 }
  84
  85 /**
  86   Determine if the given handle has Driver Configuration protocol.
  87
  88   @param[in] TheHandle      The handle to the driver to test.
  89
  90   @retval TRUE              The driver does have Driver Configuration.
  91   @retval FALSE             The driver does not have Driver Configuration.
  92 **/
  93 BOOLEAN
  94 ReturnDriverConfig(
  95   IN CONST EFI_HANDLE TheHandle
  96   )
  97 {
  98   EFI_STATUS                  Status;
  99   Status = gBS->OpenProtocol((EFI_HANDLE)TheHandle, &gEfiDriverConfigurationProtocolGuid, NULL, gImageHandle, NULL, EFI_OPEN_PROTOCOL_TEST_PROTOCOL);
 100   if (EFI_ERROR(Status)) {
 101     return (FALSE);
 102   }
 103   return (TRUE);
 104 }
 105
 106 /**
 107   Determine if the given handle has DriverDiagnostics protocol.
 108
 109   @param[in] TheHandle      The handle to the driver to test.
 110
 111   @retval TRUE              The driver does have Driver Diasgnostics.
 112   @retval FALSE             The driver does not have Driver Diagnostics.
 113 **/
 114 BOOLEAN
 115 ReturnDriverDiag(
 116   IN CONST EFI_HANDLE TheHandle
 117   )
 118 {
 119   EFI_STATUS                  Status;
 120   Status = gBS->OpenProtocol((EFI_HANDLE)TheHandle, &gEfiDriverDiagnostics2ProtocolGuid, NULL, gImageHandle, NULL, EFI_OPEN_PROTOCOL_TEST_PROTOCOL);
 121   if (EFI_ERROR(Status)) {
 122     Status = gBS->OpenProtocol((EFI_HANDLE)TheHandle, &gEfiDriverDiagnosticsProtocolGuid, NULL, gImageHandle, NULL, EFI_OPEN_PROTOCOL_TEST_PROTOCOL);
 123     if (EFI_ERROR(Status)) {
 124       return (FALSE);
 125     }
 126   }
 127   return (TRUE);
 128 }
 129
 130 /**
 131   Finds and returns the version of the driver specified by TheHandle.
 132
 133   @param[in] TheHandle      The driver handle to get the version of.
 134
 135   @return             The version of the driver.
 136   @retval 0xFFFFFFFF  An error ocurred.
 137 **/
 138 UINT32
 139 ReturnDriverVersion(
 140   IN CONST EFI_HANDLE TheHandle
 141   )
 142 {
 143   EFI_DRIVER_BINDING_PROTOCOL *DriverBinding;
 144   EFI_STATUS                  Status;
 145   UINT32                      RetVal;
 146
 147   RetVal = (UINT32)-1;
 148
 149   Status = gBS->OpenProtocol((EFI_HANDLE)TheHandle, &gEfiDriverBindingProtocolGuid, (VOID**)&DriverBinding, gImageHandle, NULL, EFI_OPEN_PROTOCOL_GET_PROTOCOL);
 150   if (!EFI_ERROR(Status)) {
 151     RetVal = DriverBinding->Version;
 152     gBS->CloseProtocol(TheHandle, &gEfiDriverBindingProtocolGuid, gImageHandle, NULL);
 153   }
 154   return (RetVal);
 155 }
 156
 157 /**
 158   Get image name from Image Handle.
 159
 160   @param[in] Handle      Image Handle
 161
 162   @return         A pointer to the image name as a string.
 163 **/
 164 CHAR16 *
 165 GetImageNameFromHandle (
 166   IN CONST EFI_HANDLE Handle
 167   )
 168 {
 169   EFI_STATUS                        Status;
 170   EFI_DRIVER_BINDING_PROTOCOL       *DriverBinding;
 171   EFI_LOADED_IMAGE_PROTOCOL         *LoadedImage;
 172   EFI_DEVICE_PATH_PROTOCOL          *DevPathNode;
 173   EFI_GUID                          *NameGuid;
 174   CHAR16                            *ImageName;
 175   UINTN                             BufferSize;
 176   UINT32                            AuthenticationStatus;
 177   EFI_FIRMWARE_VOLUME2_PROTOCOL     *Fv2;
 178
 179   LoadedImage   = NULL;
 180   DriverBinding = NULL;
 181   ImageName     = NULL;
 182
 183   Status = gBS->OpenProtocol (
 184                   Handle,
 185                   &gEfiDriverBindingProtocolGuid,
 186                   (VOID **) &DriverBinding,
 187                   NULL,
 188                   NULL,
 189                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 190                   );
 191   if (EFI_ERROR (Status)) {
 192       return NULL;
 193   }
 194   Status = gBS->OpenProtocol (
 195                   DriverBinding->ImageHandle,
 196                   &gEfiLoadedImageProtocolGuid,
 197                   (VOID**)&LoadedImage,
 198                   gImageHandle,
 199                   NULL,
 200                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 201                   );
 202   if (!EFI_ERROR (Status)) {
 203     DevPathNode = LoadedImage->FilePath;
 204     if (DevPathNode == NULL) {
 205       return NULL;
 206     }
 207     while (!IsDevicePathEnd (DevPathNode)) {
 208       NameGuid = EfiGetNameGuidFromFwVolDevicePathNode ((MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *)DevPathNode);
 209       if (NameGuid != NULL) {
 210         Status = gBS->HandleProtocol (
 211                         LoadedImage->DeviceHandle,
 212                         &gEfiFirmwareVolume2ProtocolGuid,
 213                         (VOID **)&Fv2
 214                         );
 215         if (!EFI_ERROR (Status)) {
 216           Status = Fv2->ReadSection (
 217                           Fv2,
 218                           NameGuid,
 219                           EFI_SECTION_USER_INTERFACE,
 220                           0,
 221                           (VOID **)&ImageName,
 222                           &BufferSize,
 223                           &AuthenticationStatus
 224                           );
 225           if (!EFI_ERROR (Status)) {
 226             break;
 227           }
 228           ImageName = NULL;
 229         }
 230       }
 231       //
 232       // Next device path node
 233       //
 234       DevPathNode = NextDevicePathNode (DevPathNode);
 235     }
 236     if (ImageName == NULL) {
 237       ImageName = ConvertDevicePathToText (LoadedImage->FilePath, TRUE, TRUE);
 238     }
 239   }
 240   return ImageName;
 241 }
 242
 243 /**
 244   Function for 'drivers' command.
 245
 246   @param[in] ImageHandle  Handle to the Image (NULL if Internal).
 247   @param[in] SystemTable  Pointer to the System Table (NULL if Internal).
 248 **/
 249 SHELL_STATUS
 250 EFIAPI
 251 ShellCommandRunDrivers (
 252   IN EFI_HANDLE        ImageHandle,
 253   IN EFI_SYSTEM_TABLE  *SystemTable
 254   )
 255 {
 256   EFI_STATUS          Status;
 257   LIST_ENTRY          *Package;
 258   CHAR16              *ProblemParam;
 259   SHELL_STATUS        ShellStatus;
 260   CHAR8               *Language;
 261   CONST CHAR16        *Lang;
 262   EFI_HANDLE          *HandleList;
 263   EFI_HANDLE          *HandleWalker;
 264   UINTN               ChildCount;
 265   UINTN               DeviceCount;
 266   CHAR16              ChildCountStr[3];
 267   CHAR16              DeviceCountStr[3];
 268   CHAR16              *Temp2;
 269   CONST CHAR16        *FullDriverName;
 270   CHAR16              *TruncatedDriverName;
 271   CHAR16              *ImageName;
 272   CHAR16              *FormatString;
 273   UINT32              DriverVersion;
 274   BOOLEAN             DriverConfig;
 275   BOOLEAN             DriverDiag;
 276   BOOLEAN             SfoFlag;
 277
 278   ShellStatus         = SHELL_SUCCESS;
 279   Status              = EFI_SUCCESS;
 280   Language            = NULL;
 281   FormatString        = NULL;
 282   SfoFlag             = FALSE;
 283
 284   //
 285   // initialize the shell lib (we must be in non-auto-init...)
 286   //
 287   Status = ShellInitialize();
 288   ASSERT_EFI_ERROR(Status);
 289
 290   Status = CommandInit();
 291   ASSERT_EFI_ERROR(Status);
 292
 293   //
 294   // parse the command line
 295   //
 296   Status = ShellCommandLineParse (ParamList, &Package, &ProblemParam, TRUE);
 297   if (EFI_ERROR(Status)) {
 298     if (Status == EFI_VOLUME_CORRUPTED && ProblemParam != NULL) {
 299       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellDriver1HiiHandle, L"drivers", ProblemParam);
 300       FreePool(ProblemParam);
 301       ShellStatus = SHELL_INVALID_PARAMETER;
 302     } else {
 303       ASSERT(FALSE);
 304     }
 305   } else {
 306     if (ShellCommandLineGetCount(Package) > 1) {
 307       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDriver1HiiHandle, L"drivers");
 308       ShellStatus = SHELL_INVALID_PARAMETER;
 309     } else {
 310       if (ShellCommandLineGetFlag(Package, L"-l")){
 311         Lang = ShellCommandLineGetValue(Package, L"-l");
 312         if (Lang != NULL) {
 313           Language = AllocateZeroPool(StrSize(Lang));
 314           AsciiSPrint(Language, StrSize(Lang), "%S", Lang);
 315         } else {
 316           ASSERT(Language == NULL);
 317           ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_VALUE), gShellDriver1HiiHandle, L"drivers", L"-l");
 318           ShellCommandLineFreeVarList (Package);
 319           return (SHELL_INVALID_PARAMETER);
 320         }
 321       }
 322
 323       if (ShellCommandLineGetFlag (Package, L"-sfo")) {
 324         SfoFlag = TRUE;
 325         FormatString = HiiGetString (gShellDriver1HiiHandle, STRING_TOKEN (STR_DRIVERS_ITEM_LINE_SFO), Language);
 326         //
 327         // print the SFO header
 328         //
 329         ShellPrintHiiEx (
 330           -1,
 331           -1,
 332           Language,
 333           STRING_TOKEN (STR_GEN_SFO_HEADER),
 334           gShellDriver1HiiHandle,
 335           L"drivers");
 336       } else {
 337         FormatString = HiiGetString (gShellDriver1HiiHandle, STRING_TOKEN (STR_DRIVERS_ITEM_LINE), Language);
 338         //
 339         // print the header row
 340         //
 341         ShellPrintHiiEx(
 342           -1,
 343           -1,
 344           Language,
 345           STRING_TOKEN (STR_DRIVERS_HEADER_LINES),
 346           gShellDriver1HiiHandle);
 347       }
 348
 349       HandleList = GetHandleListByProtocol(&gEfiDriverBindingProtocolGuid);
 350       for (HandleWalker = HandleList ; HandleWalker != NULL && *HandleWalker != NULL ; HandleWalker++){
 351         ChildCount     = 0;
 352         DeviceCount    = 0;
 353         Status         = ParseHandleDatabaseForChildDevices (*HandleWalker, &ChildCount , NULL);
 354         Status         = PARSE_HANDLE_DATABASE_DEVICES      (*HandleWalker, &DeviceCount, NULL);
 355         Temp2          = GetDevicePathTextForHandle(*HandleWalker);
 356         DriverVersion  = ReturnDriverVersion(*HandleWalker);
 357         DriverConfig   = ReturnDriverConfig(*HandleWalker);
 358         DriverDiag     = ReturnDriverDiag  (*HandleWalker);
 359         FullDriverName = GetStringNameFromHandle(*HandleWalker, Language);
 360         ImageName      = GetImageNameFromHandle (*HandleWalker);
 361
 362         UnicodeValueToStringS (ChildCountStr,  sizeof (ChildCountStr),  0, ChildCount,  0);
 363         UnicodeValueToStringS (DeviceCountStr, sizeof (DeviceCountStr), 0, DeviceCount, 0);
 364         TruncatedDriverName = NULL;
 365         if (!SfoFlag && (FullDriverName != NULL)) {
 366           TruncatedDriverName = AllocateZeroPool ((MAX_LEN_DRIVER_NAME + 1) * sizeof (CHAR16));
 367           StrnCpyS (TruncatedDriverName, MAX_LEN_DRIVER_NAME + 1, FullDriverName, MAX_LEN_DRIVER_NAME);
 368         }
 369
 370         if (!SfoFlag) {
 371           ShellPrintEx (
 372             -1,
 373             -1,
 374             FormatString,
 375             ConvertHandleToHandleIndex (*HandleWalker),
 376             DriverVersion,
 377             ChildCount > 0 ? L'B' : (DeviceCount > 0 ? L'D' : L'?'),
 378             DriverConfig ? L'X' : L'-',
 379             DriverDiag ? L'X' : L'-',
 380             DeviceCount > 0 ? DeviceCountStr : L"-",
 381             ChildCount  > 0 ? ChildCountStr : L"-",
 382             TruncatedDriverName,
 383             ImageName == NULL ? L"" : ImageName
 384             );
 385         } else {
 386           ShellPrintEx (
 387             -1,
 388             -1,
 389             FormatString,
 390             ConvertHandleToHandleIndex (*HandleWalker),
 391             DriverVersion,
 392             ChildCount > 0 ? L'B' : (DeviceCount > 0 ? L'D' : L'?'),
 393             DriverConfig ? L'Y' : L'N',
 394             DriverDiag ? L'Y' : L'N',
 395             DeviceCount,
 396             ChildCount,
 397             FullDriverName,
 398             Temp2 == NULL ? L"" : Temp2
 399             );
 400         }
 401         if (TruncatedDriverName != NULL) {
 402           FreePool (TruncatedDriverName);
 403         }
 404         if (Temp2 != NULL) {
 405           FreePool(Temp2);
 406         }
 407         if (ImageName != NULL) {
 408           FreePool (ImageName);
 409         }
 410
 411         if (ShellGetExecutionBreakFlag ()) {
 412           ShellStatus = SHELL_ABORTED;
 413           break;
 414         }
 415       }
 416     }
 417     SHELL_FREE_NON_NULL(Language);
 418     ShellCommandLineFreeVarList (Package);
 419     SHELL_FREE_NON_NULL(FormatString);
 420   }
 421
 422   return (ShellStatus);
 423 }