ShellPkg/Library/UefiShellDebug1CommandsLib/HexEdit/MemImage.c

   1 /** @file
   2   Functions to deal with Mem buffer
   3
   4   Copyright (c) 2005 - 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 "HexEditor.h"
  16
  17 extern EFI_HANDLE                 HImageHandleBackup;
  18
  19 extern HEFI_EDITOR_BUFFER_IMAGE   HBufferImage;
  20
  21 extern BOOLEAN                    HBufferImageNeedRefresh;
  22 extern BOOLEAN                    HBufferImageOnlyLineNeedRefresh;
  23 extern BOOLEAN                    HBufferImageMouseNeedRefresh;
  24
  25 extern HEFI_EDITOR_GLOBAL_EDITOR  HMainEditor;
  26
  27 HEFI_EDITOR_MEM_IMAGE             HMemImage;
  28 HEFI_EDITOR_MEM_IMAGE             HMemImageBackupVar;
  29
  30 EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL   DummyPciRootBridgeIo;
  31
  32 //
  33 // for basic initialization of HDiskImage
  34 //
  35 HEFI_EDITOR_MEM_IMAGE             HMemImageConst = {
  36   NULL,
  37   0,
  38   0
  39 };
  40
  41 /**
  42   Empty function.  always returns the same.
  43
  44   @param[in] This       Ignored.
  45   @param[in] Width      Ignored.
  46   @param[in] Address    Ignored.
  47   @param[in] Count      Ignored.
  48   @param[in,out] Buffer Ignored.
  49
  50   @retval EFI_UNSUPPORTED.
  51 **/
  52 EFI_STATUS
  53 DummyMemRead (
  54   IN EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL              * This,
  55   IN     EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_WIDTH    Width,
  56   IN     UINT64                                   Address,
  57   IN     UINTN                                    Count,
  58   IN OUT VOID                                     *Buffer
  59   )
  60 {
  61   return EFI_UNSUPPORTED;
  62 }
  63
  64 /**
  65   Empty function.  always returns the same.
  66
  67   @param[in] This       Ignored.
  68   @param[in] Width      Ignored.
  69   @param[in] Address    Ignored.
  70   @param[in] Count      Ignored.
  71   @param[in,out] Buffer Ignored.
  72
  73   @retval EFI_UNSUPPORTED.
  74 **/
  75 EFI_STATUS
  76 DummyMemWrite (
  77   IN EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL              * This,
  78   IN     EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_WIDTH    Width,
  79   IN     UINT64                                   Address,
  80   IN     UINTN                                    Count,
  81   IN OUT VOID                                     *Buffer
  82   )
  83 {
  84   return EFI_UNSUPPORTED;
  85 }
  86
  87 /**
  88   Initialization function for HDiskImage.
  89
  90   @retval EFI_SUCCESS       The operation was successful.
  91   @retval EFI_LOAD_ERROR    A load error occured.
  92 **/
  93 EFI_STATUS
  94 HMemImageInit (
  95   VOID
  96   )
  97 {
  98   EFI_STATUS  Status;
  99
 100   //
 101   // basically initialize the HMemImage
 102   //
 103   CopyMem (&HMemImage, &HMemImageConst, sizeof (HMemImage));
 104
 105   Status = gBS->LocateProtocol (
 106                 &gEfiPciRootBridgeIoProtocolGuid,
 107                 NULL,
 108                 (VOID**)&HMemImage.IoFncs
 109                 );
 110   if (Status == EFI_NOT_FOUND) {
 111     //
 112     // For NT32, no EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL is available
 113     // Use Dummy PciRootBridgeIo for memory access
 114     //
 115     ZeroMem (&DummyPciRootBridgeIo, sizeof (EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL));
 116     DummyPciRootBridgeIo.Mem.Read  = DummyMemRead;
 117     DummyPciRootBridgeIo.Mem.Write = DummyMemWrite;
 118     HMemImage.IoFncs = &DummyPciRootBridgeIo;
 119     Status = EFI_SUCCESS;
 120   }
 121   if (!EFI_ERROR (Status)) {
 122     return EFI_SUCCESS;
 123   } else {
 124     return EFI_LOAD_ERROR;
 125   }
 126 }
 127
 128 /**
 129   Backup function for HDiskImage. Only a few fields need to be backup.
 130   This is for making the Disk buffer refresh as few as possible.
 131
 132   @retval EFI_SUCCESS       The operation was successful.
 133 **/
 134 EFI_STATUS
 135 HMemImageBackup (
 136   VOID
 137   )
 138 {
 139   HMemImageBackupVar.Offset = HMemImage.Offset;
 140   HMemImageBackupVar.Size   = HMemImage.Size;
 141
 142   return EFI_SUCCESS;
 143 }
 144
 145 /**
 146   Set FileName field in HFileImage.
 147
 148   @param[in] Offset   The offset.
 149   @param[in] Size     The size.
 150
 151   @retval EFI_SUCCESS           The operation was successful.
 152   @retval EFI_OUT_OF_RESOURCES  A memory allocation failed.
 153 **/
 154 EFI_STATUS
 155 HMemImageSetMemOffsetSize (
 156   IN UINTN Offset,
 157   IN UINTN Size
 158   )
 159 {
 160
 161   HMemImage.Offset  = Offset;
 162   HMemImage.Size    = Size;
 163
 164   return EFI_SUCCESS;
 165 }
 166
 167 /**
 168   Read a disk from disk into HBufferImage.
 169
 170   @param[in] Offset   The offset.
 171   @param[in] Size     The size.
 172   @param[in] Recover  if is for recover, no information print.
 173
 174   @retval EFI_LOAD_ERROR        A load error occured.
 175   @retval EFI_SUCCESS           The operation was successful.
 176   @retval EFI_OUT_OF_RESOURCES  A memory allocation failed.
 177 **/
 178 EFI_STATUS
 179 HMemImageRead (
 180   IN UINTN     Offset,
 181   IN UINTN     Size,
 182   IN BOOLEAN   Recover
 183   )
 184 {
 185
 186   EFI_STATUS                      Status;
 187   void                            *Buffer;
 188   CHAR16                          *Str;
 189   HEFI_EDITOR_LINE                *Line;
 190
 191   EDIT_FILE_TYPE                  BufferTypeBackup;
 192
 193   BufferTypeBackup        = HBufferImage.BufferType;
 194   HBufferImage.BufferType = FileTypeMemBuffer;
 195
 196   Buffer                  = AllocateZeroPool (Size);
 197   if (Buffer == NULL) {
 198     StatusBarSetStatusString (L"Read Memory Failed");
 199     return EFI_OUT_OF_RESOURCES;
 200   }
 201
 202   Status = HMemImage.IoFncs->Mem.Read (
 203                                   HMemImage.IoFncs,
 204                                   EfiPciWidthUint8,
 205                                   Offset,
 206                                   Size,
 207                                   Buffer
 208                                   );
 209
 210   if (EFI_ERROR (Status)) {
 211     FreePool (Buffer);
 212     StatusBarSetStatusString (L"Memory Specified Not Accessible");
 213     return EFI_LOAD_ERROR;
 214   }
 215
 216   HBufferImageFree ();
 217
 218   Status = HBufferImageBufferToList (Buffer, Size);
 219   FreePool (Buffer);
 220
 221   if (EFI_ERROR (Status)) {
 222     StatusBarSetStatusString (L"Read Memory Failed");
 223     return Status;
 224   }
 225
 226   Status  = HMemImageSetMemOffsetSize (Offset, Size);
 227
 228   HBufferImage.DisplayPosition.Row    = 2;
 229   HBufferImage.DisplayPosition.Column = 10;
 230
 231   HBufferImage.MousePosition.Row      = 2;
 232   HBufferImage.MousePosition.Column   = 10;
 233
 234   HBufferImage.LowVisibleRow          = 1;
 235   HBufferImage.HighBits               = TRUE;
 236
 237   HBufferImage.BufferPosition.Row     = 1;
 238   HBufferImage.BufferPosition.Column  = 1;
 239
 240   if (!Recover) {
 241     Str = CatSPrint(NULL, L"%d Lines Read", HBufferImage.NumLines);
 242     if (Str == NULL) {
 243       StatusBarSetStatusString (L"Read Memory Failed");
 244       return EFI_OUT_OF_RESOURCES;
 245     }
 246
 247     StatusBarSetStatusString (Str);
 248     SHELL_FREE_NON_NULL (Str);
 249
 250     HMainEditor.SelectStart = 0;
 251     HMainEditor.SelectEnd   = 0;
 252
 253   }
 254
 255   //
 256   // has line
 257   //
 258   if (HBufferImage.Lines != NULL) {
 259     HBufferImage.CurrentLine = CR (HBufferImage.ListHead->ForwardLink, HEFI_EDITOR_LINE, Link, EFI_EDITOR_LINE_LIST);
 260   } else {
 261     //
 262     // create a dummy line
 263     //
 264     Line = HBufferImageCreateLine ();
 265     if (Line == NULL) {
 266       StatusBarSetStatusString (L"Read Memory Failed");
 267       return EFI_OUT_OF_RESOURCES;
 268     }
 269
 270     HBufferImage.CurrentLine = Line;
 271   }
 272
 273   HBufferImage.Modified           = FALSE;
 274   HBufferImageNeedRefresh         = TRUE;
 275   HBufferImageOnlyLineNeedRefresh = FALSE;
 276   HBufferImageMouseNeedRefresh    = TRUE;
 277
 278   return EFI_SUCCESS;
 279
 280 }
 281
 282 /**
 283   Save lines in HBufferImage to disk.
 284
 285   @param[in] Offset   The offset.
 286   @param[in] Size     The size.
 287
 288   @retval EFI_LOAD_ERROR        A load error occured.
 289   @retval EFI_SUCCESS           The operation was successful.
 290   @retval EFI_OUT_OF_RESOURCES  A memory allocation failed.
 291 **/
 292 EFI_STATUS
 293 HMemImageSave (
 294   IN UINTN Offset,
 295   IN UINTN Size
 296   )
 297 {
 298
 299   EFI_STATUS                      Status;
 300   VOID                            *Buffer;
 301
 302   EDIT_FILE_TYPE                  BufferTypeBackup;
 303
 304   //
 305   // not modified, so directly return
 306   //
 307   if (HBufferImage.Modified == FALSE) {
 308     return EFI_SUCCESS;
 309   }
 310
 311   BufferTypeBackup        = HBufferImage.BufferType;
 312   HBufferImage.BufferType = FileTypeMemBuffer;
 313
 314   Buffer                  = AllocateZeroPool (Size);
 315
 316   if (Buffer == NULL) {
 317     return EFI_OUT_OF_RESOURCES;
 318   }
 319
 320   Status = HBufferImageListToBuffer (Buffer, Size);
 321   if (EFI_ERROR (Status)) {
 322     FreePool (Buffer);
 323     return Status;
 324   }
 325   //
 326   // write back to memory
 327   //
 328   Status = HMemImage.IoFncs->Mem.Write (
 329                                   HMemImage.IoFncs,
 330                                   EfiPciWidthUint8,
 331                                   Offset,
 332                                   Size,
 333                                   Buffer
 334                                   );
 335
 336   FreePool (Buffer);
 337
 338   if (EFI_ERROR (Status)) {
 339     return EFI_LOAD_ERROR;
 340   }
 341   //
 342   // now not modified
 343   //
 344   HBufferImage.Modified = FALSE;
 345
 346   return EFI_SUCCESS;
 347 }
 348
 349