ShellPkg/Library/UefiShellDebug1CommandsLib/HexEdit/MemImage.c

   1 /** @file
   2   Functions to deal with Mem buffer
   3
   4   Copyright (c) 2005 - 2018, Intel Corporation. All rights reserved. <BR>
   5   SPDX-License-Identifier: BSD-2-Clause-Patent
   6
   7 **/
   8
   9 #include "HexEditor.h"
  10
  11 extern EFI_HANDLE                 HImageHandleBackup;
  12
  13 extern HEFI_EDITOR_BUFFER_IMAGE   HBufferImage;
  14
  15 extern BOOLEAN                    HBufferImageNeedRefresh;
  16 extern BOOLEAN                    HBufferImageOnlyLineNeedRefresh;
  17 extern BOOLEAN                    HBufferImageMouseNeedRefresh;
  18
  19 extern HEFI_EDITOR_GLOBAL_EDITOR  HMainEditor;
  20
  21 HEFI_EDITOR_MEM_IMAGE             HMemImage;
  22 HEFI_EDITOR_MEM_IMAGE             HMemImageBackupVar;
  23
  24 //
  25 // for basic initialization of HDiskImage
  26 //
  27 HEFI_EDITOR_MEM_IMAGE             HMemImageConst = {
  28   NULL,
  29   0,
  30   0
  31 };
  32
  33 /**
  34   Initialization function for HDiskImage.
  35
  36   @retval EFI_SUCCESS       The operation was successful.
  37   @retval EFI_LOAD_ERROR    A load error occured.
  38 **/
  39 EFI_STATUS
  40 HMemImageInit (
  41   VOID
  42   )
  43 {
  44   EFI_STATUS  Status;
  45
  46   //
  47   // basically initialize the HMemImage
  48   //
  49   CopyMem (&HMemImage, &HMemImageConst, sizeof (HMemImage));
  50
  51   Status = gBS->LocateProtocol (
  52                 &gEfiCpuIo2ProtocolGuid,
  53                 NULL,
  54                 (VOID**)&HMemImage.IoFncs
  55                 );
  56   if (!EFI_ERROR (Status)) {
  57     return EFI_SUCCESS;
  58   } else {
  59     return EFI_LOAD_ERROR;
  60   }
  61 }
  62
  63 /**
  64   Backup function for HDiskImage. Only a few fields need to be backup.
  65   This is for making the Disk buffer refresh as few as possible.
  66
  67   @retval EFI_SUCCESS       The operation was successful.
  68 **/
  69 EFI_STATUS
  70 HMemImageBackup (
  71   VOID
  72   )
  73 {
  74   HMemImageBackupVar.Offset = HMemImage.Offset;
  75   HMemImageBackupVar.Size   = HMemImage.Size;
  76
  77   return EFI_SUCCESS;
  78 }
  79
  80 /**
  81   Set FileName field in HFileImage.
  82
  83   @param[in] Offset   The offset.
  84   @param[in] Size     The size.
  85
  86   @retval EFI_SUCCESS           The operation was successful.
  87   @retval EFI_OUT_OF_RESOURCES  A memory allocation failed.
  88 **/
  89 EFI_STATUS
  90 HMemImageSetMemOffsetSize (
  91   IN UINTN Offset,
  92   IN UINTN Size
  93   )
  94 {
  95
  96   HMemImage.Offset  = Offset;
  97   HMemImage.Size    = Size;
  98
  99   return EFI_SUCCESS;
 100 }
 101
 102 /**
 103   Read a disk from disk into HBufferImage.
 104
 105   @param[in] Offset   The offset.
 106   @param[in] Size     The size.
 107   @param[in] Recover  if is for recover, no information print.
 108
 109   @retval EFI_LOAD_ERROR        A load error occured.
 110   @retval EFI_SUCCESS           The operation was successful.
 111   @retval EFI_OUT_OF_RESOURCES  A memory allocation failed.
 112 **/
 113 EFI_STATUS
 114 HMemImageRead (
 115   IN UINTN     Offset,
 116   IN UINTN     Size,
 117   IN BOOLEAN   Recover
 118   )
 119 {
 120
 121   EFI_STATUS                      Status;
 122   void                            *Buffer;
 123   CHAR16                          *Str;
 124   HEFI_EDITOR_LINE                *Line;
 125
 126   HBufferImage.BufferType = FileTypeMemBuffer;
 127
 128   Buffer                  = AllocateZeroPool (Size);
 129   if (Buffer == NULL) {
 130     StatusBarSetStatusString (L"Read Memory Failed");
 131     return EFI_OUT_OF_RESOURCES;
 132   }
 133
 134   Status = HMemImage.IoFncs->Mem.Read (
 135                                   HMemImage.IoFncs,
 136                                   EfiCpuIoWidthUint8,
 137                                   Offset,
 138                                   Size,
 139                                   Buffer
 140                                   );
 141
 142   if (EFI_ERROR (Status)) {
 143     FreePool (Buffer);
 144     StatusBarSetStatusString (L"Memory Specified Not Accessible");
 145     return EFI_LOAD_ERROR;
 146   }
 147
 148   HBufferImageFree ();
 149
 150   Status = HBufferImageBufferToList (Buffer, Size);
 151   FreePool (Buffer);
 152
 153   if (EFI_ERROR (Status)) {
 154     StatusBarSetStatusString (L"Read Memory Failed");
 155     return Status;
 156   }
 157
 158   Status  = HMemImageSetMemOffsetSize (Offset, Size);
 159
 160   HBufferImage.DisplayPosition.Row    = 2;
 161   HBufferImage.DisplayPosition.Column = 10;
 162
 163   HBufferImage.MousePosition.Row      = 2;
 164   HBufferImage.MousePosition.Column   = 10;
 165
 166   HBufferImage.LowVisibleRow          = 1;
 167   HBufferImage.HighBits               = TRUE;
 168
 169   HBufferImage.BufferPosition.Row     = 1;
 170   HBufferImage.BufferPosition.Column  = 1;
 171
 172   if (!Recover) {
 173     Str = CatSPrint(NULL, L"%d Lines Read", HBufferImage.NumLines);
 174     if (Str == NULL) {
 175       StatusBarSetStatusString (L"Read Memory Failed");
 176       return EFI_OUT_OF_RESOURCES;
 177     }
 178
 179     StatusBarSetStatusString (Str);
 180     SHELL_FREE_NON_NULL (Str);
 181
 182     HMainEditor.SelectStart = 0;
 183     HMainEditor.SelectEnd   = 0;
 184
 185   }
 186
 187   //
 188   // has line
 189   //
 190   if (HBufferImage.Lines != NULL) {
 191     HBufferImage.CurrentLine = CR (HBufferImage.ListHead->ForwardLink, HEFI_EDITOR_LINE, Link, EFI_EDITOR_LINE_LIST);
 192   } else {
 193     //
 194     // create a dummy line
 195     //
 196     Line = HBufferImageCreateLine ();
 197     if (Line == NULL) {
 198       StatusBarSetStatusString (L"Read Memory Failed");
 199       return EFI_OUT_OF_RESOURCES;
 200     }
 201
 202     HBufferImage.CurrentLine = Line;
 203   }
 204
 205   HBufferImage.Modified           = FALSE;
 206   HBufferImageNeedRefresh         = TRUE;
 207   HBufferImageOnlyLineNeedRefresh = FALSE;
 208   HBufferImageMouseNeedRefresh    = TRUE;
 209
 210   return EFI_SUCCESS;
 211
 212 }
 213
 214 /**
 215   Save lines in HBufferImage to disk.
 216
 217   @param[in] Offset   The offset.
 218   @param[in] Size     The size.
 219
 220   @retval EFI_LOAD_ERROR        A load error occured.
 221   @retval EFI_SUCCESS           The operation was successful.
 222   @retval EFI_OUT_OF_RESOURCES  A memory allocation failed.
 223 **/
 224 EFI_STATUS
 225 HMemImageSave (
 226   IN UINTN Offset,
 227   IN UINTN Size
 228   )
 229 {
 230
 231   EFI_STATUS                      Status;
 232   VOID                            *Buffer;
 233
 234   //
 235   // not modified, so directly return
 236   //
 237   if (HBufferImage.Modified == FALSE) {
 238     return EFI_SUCCESS;
 239   }
 240
 241   HBufferImage.BufferType = FileTypeMemBuffer;
 242
 243   Buffer                  = AllocateZeroPool (Size);
 244
 245   if (Buffer == NULL) {
 246     return EFI_OUT_OF_RESOURCES;
 247   }
 248
 249   Status = HBufferImageListToBuffer (Buffer, Size);
 250   if (EFI_ERROR (Status)) {
 251     FreePool (Buffer);
 252     return Status;
 253   }
 254   //
 255   // write back to memory
 256   //
 257   Status = HMemImage.IoFncs->Mem.Write (
 258                                   HMemImage.IoFncs,
 259                                   EfiCpuIoWidthUint8,
 260                                   Offset,
 261                                   Size,
 262                                   Buffer
 263                                   );
 264
 265   FreePool (Buffer);
 266
 267   if (EFI_ERROR (Status)) {
 268     return EFI_LOAD_ERROR;
 269   }
 270   //
 271   // now not modified
 272   //
 273   HBufferImage.Modified = FALSE;
 274
 275   return EFI_SUCCESS;
 276 }
 277
 278