ShellPkg/Library/UefiShellDebug1CommandsLib/Dblk.c

   1 /** @file
   2   Main file for Dblk shell Debug1 function.
   3
   4   (C) Copyright 2015 Hewlett-Packard Development Company, L.P.<BR>
   5   Copyright (c) 2005 - 2017, Intel Corporation. All rights reserved.<BR>
   6   This program and the accompanying materials
   7   are licensed and made available under the terms and conditions of the BSD License
   8   which accompanies this distribution.  The full text of the license may be found at
   9   http://opensource.org/licenses/bsd-license.php
  10
  11   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  12   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  13
  14 **/
  15
  16 #include "UefiShellDebug1CommandsLib.h"
  17 #include <Protocol/BlockIo.h>
  18
  19 /**
  20   Display blocks to the screen.
  21
  22   @param[in] DevPath      The device path to get the blocks from.
  23   @param[in] Lba          The Lba number to start from.
  24   @param[in] BlockCount   How many blocks to display.
  25
  26   @retval SHELL_SUCCESS   The display was successful.
  27 **/
  28 SHELL_STATUS
  29 DisplayTheBlocks(
  30   IN CONST EFI_DEVICE_PATH_PROTOCOL *DevPath,
  31   IN CONST UINT64                   Lba,
  32   IN CONST UINT8                    BlockCount
  33   )
  34 {
  35   EFI_BLOCK_IO_PROTOCOL     *BlockIo;
  36   EFI_HANDLE                BlockIoHandle;
  37   EFI_STATUS                Status;
  38   SHELL_STATUS              ShellStatus;
  39   UINT8                     *Buffer;
  40   UINT8                     *OriginalBuffer;
  41   UINTN                     BufferSize;
  42
  43   ShellStatus = SHELL_SUCCESS;
  44
  45   Status = gBS->LocateDevicePath(&gEfiBlockIoProtocolGuid, (EFI_DEVICE_PATH_PROTOCOL **)&DevPath, &BlockIoHandle);
  46   if (EFI_ERROR(Status)) {
  47     return (SHELL_NOT_FOUND);
  48   }
  49
  50   Status = gBS->OpenProtocol(BlockIoHandle, &gEfiBlockIoProtocolGuid, (VOID**)&BlockIo, gImageHandle, NULL, EFI_OPEN_PROTOCOL_GET_PROTOCOL);
  51   if (EFI_ERROR(Status)) {
  52     return (SHELL_NOT_FOUND);
  53   }
  54
  55   BufferSize = BlockIo->Media->BlockSize * BlockCount;
  56   if(BlockIo->Media->IoAlign == 0) {
  57     BlockIo->Media->IoAlign = 1;
  58   }
  59
  60   if (BufferSize > 0) {
  61     OriginalBuffer = AllocateZeroPool(BufferSize + BlockIo->Media->IoAlign);
  62     Buffer         = ALIGN_POINTER (OriginalBuffer,BlockIo->Media->IoAlign);
  63   } else {
  64     ShellPrintEx(-1,-1,L"  BlockSize: 0x%08x, BlockCount: 0x%08x\r\n", BlockIo->Media->BlockSize, BlockCount);
  65     OriginalBuffer = NULL;
  66     Buffer         = NULL;
  67   }
  68
  69   Status = BlockIo->ReadBlocks(BlockIo, BlockIo->Media->MediaId, Lba, BufferSize, Buffer);
  70   if (!EFI_ERROR(Status) && Buffer != NULL) {
  71     ShellPrintHiiEx(
  72       -1,
  73       -1,
  74       NULL,
  75       STRING_TOKEN (STR_DBLK_HEADER),
  76       gShellDebug1HiiHandle,
  77       Lba,
  78       BufferSize,
  79       BlockIo
  80       );
  81
  82     DumpHex(2,0,BufferSize,Buffer);
  83   } else {
  84     ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_FILE_READ_FAIL), gShellDebug1HiiHandle, L"dblk", L"BlockIo");
  85     ShellStatus = SHELL_DEVICE_ERROR;
  86   }
  87
  88   if (OriginalBuffer != NULL) {
  89     FreePool (OriginalBuffer);
  90   }
  91
  92   gBS->CloseProtocol(BlockIoHandle, &gEfiBlockIoProtocolGuid, gImageHandle, NULL);
  93   return (ShellStatus);
  94 }
  95
  96 /**
  97   Function for 'dblk' command.
  98
  99   @param[in] ImageHandle  Handle to the Image (NULL if Internal).
 100   @param[in] SystemTable  Pointer to the System Table (NULL if Internal).
 101 **/
 102 SHELL_STATUS
 103 EFIAPI
 104 ShellCommandRunDblk (
 105   IN EFI_HANDLE        ImageHandle,
 106   IN EFI_SYSTEM_TABLE  *SystemTable
 107   )
 108 {
 109   EFI_STATUS                Status;
 110   LIST_ENTRY                *Package;
 111   CHAR16                    *ProblemParam;
 112   SHELL_STATUS              ShellStatus;
 113   CONST CHAR16              *BlockName;
 114   CONST CHAR16              *LbaString;
 115   CONST CHAR16              *BlockCountString;
 116   UINT64                    Lba;
 117   UINT64                    BlockCount;
 118   EFI_DEVICE_PATH_PROTOCOL  *DevPath;
 119
 120   ShellStatus         = SHELL_SUCCESS;
 121   Status              = EFI_SUCCESS;
 122
 123   //
 124   // initialize the shell lib (we must be in non-auto-init...)
 125   //
 126   Status = ShellInitialize();
 127   ASSERT_EFI_ERROR(Status);
 128
 129   Status = CommandInit();
 130   ASSERT_EFI_ERROR(Status);
 131
 132   //
 133   // parse the command line
 134   //
 135   Status = ShellCommandLineParse (EmptyParamList, &Package, &ProblemParam, TRUE);
 136   if (EFI_ERROR(Status)) {
 137     if (Status == EFI_VOLUME_CORRUPTED && ProblemParam != NULL) {
 138       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellDebug1HiiHandle, L"dblk", ProblemParam);
 139       FreePool(ProblemParam);
 140       ShellStatus = SHELL_INVALID_PARAMETER;
 141     } else {
 142       ASSERT(FALSE);
 143     }
 144   } else {
 145     if (ShellCommandLineGetCount(Package) > 4) {
 146       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDebug1HiiHandle, L"dblk");
 147       ShellStatus = SHELL_INVALID_PARAMETER;
 148     } else if (ShellCommandLineGetCount(Package) < 2) {
 149       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellDebug1HiiHandle, L"dblk");
 150       ShellStatus = SHELL_INVALID_PARAMETER;
 151     } else {
 152       //
 153       // Parse the params
 154       //
 155       BlockName         = ShellCommandLineGetRawValue(Package, 1);
 156       LbaString         = ShellCommandLineGetRawValue(Package, 2);
 157       BlockCountString  = ShellCommandLineGetRawValue(Package, 3);
 158
 159       if (LbaString == NULL) {
 160         Lba = 0;
 161       } else {
 162         if (!ShellIsHexOrDecimalNumber(LbaString, TRUE, FALSE)) {
 163           ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellDebug1HiiHandle, L"dblk", LbaString);
 164           ShellStatus = SHELL_INVALID_PARAMETER;
 165         }
 166         ShellConvertStringToUint64(LbaString, &Lba, TRUE, FALSE);
 167       }
 168
 169       if (BlockCountString == NULL) {
 170         BlockCount = 1;
 171       } else {
 172         if (!ShellIsHexOrDecimalNumber(BlockCountString, TRUE, FALSE)) {
 173           ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellDebug1HiiHandle, L"dblk", BlockCountString);
 174           ShellStatus = SHELL_INVALID_PARAMETER;
 175         }
 176         ShellConvertStringToUint64(BlockCountString, &BlockCount, TRUE, FALSE);
 177         if (BlockCount > 0x10) {
 178           BlockCount = 0x10;
 179         } else if (BlockCount == 0) {
 180           ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellDebug1HiiHandle, L"dblk", BlockCountString);
 181           ShellStatus = SHELL_INVALID_PARAMETER;
 182         }
 183       }
 184
 185       if (ShellStatus == SHELL_SUCCESS) {
 186         //
 187         // do the work if we have a valid block identifier
 188         //
 189         if (gEfiShellProtocol->GetDevicePathFromMap(BlockName) == NULL) {
 190           ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellDebug1HiiHandle, L"dblk", BlockName);
 191           ShellStatus = SHELL_INVALID_PARAMETER;
 192         } else {
 193           DevPath = (EFI_DEVICE_PATH_PROTOCOL*)gEfiShellProtocol->GetDevicePathFromMap(BlockName);
 194           if (gBS->LocateDevicePath(&gEfiBlockIoProtocolGuid, &DevPath, NULL) == EFI_NOT_FOUND) {
 195             ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_MAP_PROTOCOL), gShellDebug1HiiHandle, L"dblk", BlockName, L"BlockIo");
 196             ShellStatus = SHELL_INVALID_PARAMETER;
 197           } else {
 198             ShellStatus = DisplayTheBlocks(gEfiShellProtocol->GetDevicePathFromMap(BlockName), Lba, (UINT8)BlockCount);
 199           }
 200         }
 201       }
 202     }
 203
 204     ShellCommandLineFreeVarList (Package);
 205   }
 206   return (ShellStatus);
 207 }