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 EFI_STATUS
  42 DummyMemRead (
  43   IN EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL              * This,
  44   IN     EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_WIDTH    Width,
  45   IN     UINT64                                   Address,
  46   IN     UINTN                                    Count,
  47   IN OUT VOID                                     *Buffer
  48   );
  49
  50 EFI_STATUS
  51 DummyMemWrite (
  52   IN EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL              * This,
  53   IN     EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_WIDTH    Width,
  54   IN     UINT64                                   Address,
  55   IN     UINTN                                    Count,
  56   IN OUT VOID                                     *Buffer
  57   );
  58
  59 EFI_STATUS
  60 HMemImageInit (
  61   VOID
  62   )
  63 /*++
  64
  65 Routine Description:
  66
  67   Initialization function for HDiskImage
  68
  69 Arguments:
  70
  71   None
  72
  73 Returns:
  74
  75   EFI_SUCCESS
  76   EFI_LOAD_ERROR
  77
  78 --*/
  79 {
  80   EFI_STATUS  Status;
  81
  82   //
  83   // basically initialize the HMemImage
  84   //
  85   CopyMem (&HMemImage, &HMemImageConst, sizeof (HMemImage));
  86
  87   Status = gBS->LocateProtocol (
  88                 &gEfiPciRootBridgeIoProtocolGuid,
  89                 NULL,
  90                 (VOID**)&HMemImage.IoFncs
  91                 );
  92   if (Status == EFI_NOT_FOUND) {
  93     //
  94     // For NT32, no EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL is available
  95     // Use Dummy PciRootBridgeIo for memory access
  96     //
  97     ZeroMem (&DummyPciRootBridgeIo, sizeof (EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL));
  98     DummyPciRootBridgeIo.Mem.Read  = DummyMemRead;
  99     DummyPciRootBridgeIo.Mem.Write = DummyMemWrite;
 100     HMemImage.IoFncs = &DummyPciRootBridgeIo;
 101     Status = EFI_SUCCESS;
 102   }
 103   if (!EFI_ERROR (Status)) {
 104     return EFI_SUCCESS;
 105   } else {
 106     return EFI_LOAD_ERROR;
 107   }
 108 }
 109
 110 EFI_STATUS
 111 HMemImageBackup (
 112   VOID
 113   )
 114 /*++
 115
 116 Routine Description:
 117
 118   Backup function for HDiskImage
 119   Only a few fields need to be backup.
 120   This is for making the Disk buffer refresh
 121   as few as possible.
 122
 123 Arguments:
 124
 125   None
 126
 127 Returns:
 128
 129   EFI_SUCCESS
 130
 131 --*/
 132 {
 133   HMemImageBackupVar.Offset = HMemImage.Offset;
 134   HMemImageBackupVar.Size   = HMemImage.Size;
 135
 136   return EFI_SUCCESS;
 137 }
 138
 139 EFI_STATUS
 140 HMemImageCleanup (
 141   VOID
 142   )
 143 /*++
 144
 145 Routine Description:
 146
 147   Cleanup function for HDiskImage
 148
 149 Arguments:
 150
 151   None
 152
 153 Returns:
 154
 155   EFI_SUCCESS
 156
 157 --*/
 158 {
 159   return EFI_SUCCESS;
 160 }
 161
 162 EFI_STATUS
 163 HMemImageSetMemOffsetSize (
 164   IN UINTN Offset,
 165   IN UINTN Size
 166   )
 167 /*++
 168
 169 Routine Description:
 170
 171   Set FileName field in HFileImage
 172
 173 Arguments:
 174
 175   Offset - The offset
 176   Size   - The size
 177
 178 Returns:
 179
 180   EFI_SUCCESS
 181   EFI_OUT_OF_RESOURCES
 182
 183 --*/
 184 {
 185
 186   HMemImage.Offset  = Offset;
 187   HMemImage.Size    = Size;
 188
 189   return EFI_SUCCESS;
 190 }
 191
 192 EFI_STATUS
 193 HMemImageRead (
 194   IN UINTN  Offset,
 195   IN UINTN  Size,
 196   BOOLEAN   Recover
 197   )
 198 /*++
 199
 200 Routine Description:
 201
 202   Read a disk from disk into HBufferImage
 203
 204 Arguments:
 205
 206   Offset  - The offset
 207   Size    - The size
 208   Recover - if is for recover, no information print
 209
 210 Returns:
 211
 212   EFI_SUCCESS
 213   EFI_LOAD_ERROR
 214   EFI_OUT_OF_RESOURCES
 215
 216 --*/
 217 {
 218
 219   EFI_STATUS                      Status;
 220   void                            *Buffer;
 221   CHAR16                          *Str;
 222   HEFI_EDITOR_LINE                *Line;
 223
 224   EDIT_FILE_TYPE                  BufferTypeBackup;
 225
 226   BufferTypeBackup        = HBufferImage.BufferType;
 227   HBufferImage.BufferType = FileTypeMemBuffer;
 228
 229   Buffer                  = AllocateZeroPool (Size);
 230   if (Buffer == NULL) {
 231     StatusBarSetStatusString (L"Read Memory Failed");
 232     return EFI_OUT_OF_RESOURCES;
 233   }
 234
 235   Status = HMemImage.IoFncs->Mem.Read (
 236                                   HMemImage.IoFncs,
 237                                   EfiPciWidthUint8,
 238                                   Offset,
 239                                   Size,
 240                                   Buffer
 241                                   );
 242
 243   if (EFI_ERROR (Status)) {
 244     FreePool (Buffer);
 245     StatusBarSetStatusString (L"Memory Specified Not Accessible");
 246     return EFI_LOAD_ERROR;
 247   }
 248
 249   HBufferImageFree ();
 250
 251   Status = HBufferImageBufferToList (Buffer, Size);
 252   FreePool (Buffer);
 253
 254   if (EFI_ERROR (Status)) {
 255     StatusBarSetStatusString (L"Read Memory Failed");
 256     return Status;
 257   }
 258
 259   Status  = HMemImageSetMemOffsetSize (Offset, Size);
 260
 261   HBufferImage.DisplayPosition.Row    = 2;
 262   HBufferImage.DisplayPosition.Column = 10;
 263
 264   HBufferImage.MousePosition.Row      = 2;
 265   HBufferImage.MousePosition.Column   = 10;
 266
 267   HBufferImage.LowVisibleRow          = 1;
 268   HBufferImage.HighBits               = TRUE;
 269
 270   HBufferImage.BufferPosition.Row     = 1;
 271   HBufferImage.BufferPosition.Column  = 1;
 272
 273   if (!Recover) {
 274     Str = CatSPrint(NULL, L"%d Lines Read", HBufferImage.NumLines);
 275     if (Str == NULL) {
 276       StatusBarSetStatusString (L"Read Memory Failed");
 277       return EFI_OUT_OF_RESOURCES;
 278     }
 279
 280     StatusBarSetStatusString (Str);
 281     SHELL_FREE_NON_NULL (Str);
 282
 283     HMainEditor.SelectStart = 0;
 284     HMainEditor.SelectEnd   = 0;
 285
 286   }
 287
 288   //
 289   // has line
 290   //
 291   if (HBufferImage.Lines != NULL) {
 292     HBufferImage.CurrentLine = CR (HBufferImage.ListHead->ForwardLink, HEFI_EDITOR_LINE, Link, EFI_EDITOR_LINE_LIST);
 293   } else {
 294     //
 295     // create a dummy line
 296     //
 297     Line = HBufferImageCreateLine ();
 298     if (Line == NULL) {
 299       StatusBarSetStatusString (L"Read Memory Failed");
 300       return EFI_OUT_OF_RESOURCES;
 301     }
 302
 303     HBufferImage.CurrentLine = Line;
 304   }
 305
 306   HBufferImage.Modified           = FALSE;
 307   HBufferImageNeedRefresh         = TRUE;
 308   HBufferImageOnlyLineNeedRefresh = FALSE;
 309   HBufferImageMouseNeedRefresh    = TRUE;
 310
 311   return EFI_SUCCESS;
 312
 313 }
 314
 315 EFI_STATUS
 316 HMemImageSave (
 317   IN UINTN Offset,
 318   IN UINTN Size
 319   )
 320 /*++
 321
 322 Routine Description:
 323
 324   Save lines in HBufferImage to disk
 325
 326 Arguments:
 327
 328   Offset - The offset
 329   Size   - The size
 330
 331 Returns:
 332
 333   EFI_SUCCESS
 334   EFI_LOAD_ERROR
 335   EFI_OUT_OF_RESOURCES
 336
 337 --*/
 338 {
 339
 340   EFI_STATUS                      Status;
 341   VOID                            *Buffer;
 342
 343   EDIT_FILE_TYPE                  BufferTypeBackup;
 344
 345   //
 346   // not modified, so directly return
 347   //
 348   if (HBufferImage.Modified == FALSE) {
 349     return EFI_SUCCESS;
 350   }
 351
 352   BufferTypeBackup        = HBufferImage.BufferType;
 353   HBufferImage.BufferType = FileTypeMemBuffer;
 354
 355   Buffer                  = AllocateZeroPool (Size);
 356
 357   if (Buffer == NULL) {
 358     return EFI_OUT_OF_RESOURCES;
 359   }
 360
 361   Status = HBufferImageListToBuffer (Buffer, Size);
 362   if (EFI_ERROR (Status)) {
 363     FreePool (Buffer);
 364     return Status;
 365   }
 366   //
 367   // write back to memory
 368   //
 369   Status = HMemImage.IoFncs->Mem.Write (
 370                                   HMemImage.IoFncs,
 371                                   EfiPciWidthUint8,
 372                                   Offset,
 373                                   Size,
 374                                   Buffer
 375                                   );
 376
 377   FreePool (Buffer);
 378
 379   if (EFI_ERROR (Status)) {
 380     return EFI_LOAD_ERROR;
 381   }
 382   //
 383   // now not modified
 384   //
 385   HBufferImage.Modified = FALSE;
 386
 387   return EFI_SUCCESS;
 388 }
 389
 390 EFI_STATUS
 391 DummyMemRead (
 392   IN EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL              * This,
 393   IN     EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_WIDTH    Width,
 394   IN     UINT64                                   Address,
 395   IN     UINTN                                    Count,
 396   IN OUT VOID                                     *Buffer
 397   )
 398 {
 399   return EFI_UNSUPPORTED;
 400 }
 401
 402 EFI_STATUS
 403 DummyMemWrite (
 404   IN EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL              * This,
 405   IN     EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_WIDTH    Width,
 406   IN     UINT64                                   Address,
 407   IN     UINTN                                    Count,
 408   IN OUT VOID                                     *Buffer
 409   )
 410 {
 411   return EFI_UNSUPPORTED;
 412 }