ShellPkg/Library/UefiShellDebug1CommandsLib/MemMap.c

   1 /** @file
   2   Main file for Mode shell Debug1 function.
   3
   4   (C) Copyright 2016 Hewlett Packard Enterprise Development LP<BR>
   5   (C) Copyright 2013-2015 Hewlett-Packard Development Company, L.P.<BR>
   6   Copyright (c) 2010 - 2018, Intel Corporation. All rights reserved.<BR>
   7   SPDX-License-Identifier: BSD-2-Clause-Patent
   8
   9 **/
  10
  11 //
  12 // Need full names for Standard-Format Output
  13 //
  14 STATIC CONST CHAR16  NameEfiReservedMemoryType[]      = L"Reserved";
  15 STATIC CONST CHAR16  NameEfiLoaderCode[]              = L"LoaderCode";
  16 STATIC CONST CHAR16  NameEfiLoaderData[]              = L"LoaderData";
  17 STATIC CONST CHAR16  NameEfiBootServicesCode[]        = L"BootServiceCode";
  18 STATIC CONST CHAR16  NameEfiBootServicesData[]        = L"BootServiceData";
  19 STATIC CONST CHAR16  NameEfiRuntimeServicesCode[]     = L"RuntimeCode";
  20 STATIC CONST CHAR16  NameEfiRuntimeServicesData[]     = L"RuntimeData";
  21 STATIC CONST CHAR16  NameEfiConventionalMemory[]      = L"Available";
  22 STATIC CONST CHAR16  NameEfiPersistentMemory[]        = L"Persistent";
  23 STATIC CONST CHAR16  NameEfiUnusableMemory[]          = L"UnusableMemory";
  24 STATIC CONST CHAR16  NameEfiACPIReclaimMemory[]       = L"ACPIReclaimMemory";
  25 STATIC CONST CHAR16  NameEfiACPIMemoryNVS[]           = L"ACPIMemoryNVS";
  26 STATIC CONST CHAR16  NameEfiMemoryMappedIO[]          = L"MemoryMappedIO";
  27 STATIC CONST CHAR16  NameEfiMemoryMappedIOPortSpace[] = L"MemoryMappedIOPortSpace";
  28 STATIC CONST CHAR16  NameEfiPalCode[]                 = L"PalCode";
  29
  30 //
  31 // Need short names for some memory types
  32 //
  33 STATIC CONST CHAR16  NameEfiBootServicesCodeShort[]        = L"BS_Code";
  34 STATIC CONST CHAR16  NameEfiBootServicesDataShort[]        = L"BS_Data";
  35 STATIC CONST CHAR16  NameEfiRuntimeServicesCodeShort[]     = L"RT_Code";
  36 STATIC CONST CHAR16  NameEfiRuntimeServicesDataShort[]     = L"RT_Data";
  37 STATIC CONST CHAR16  NameEfiUnusableMemoryShort[]          = L"Unusable";
  38 STATIC CONST CHAR16  NameEfiACPIReclaimMemoryShort[]       = L"ACPI_Recl";
  39 STATIC CONST CHAR16  NameEfiACPIMemoryNVSShort[]           = L"ACPI_NVS";
  40 STATIC CONST CHAR16  NameEfiMemoryMappedIOShort[]          = L"MMIO";
  41 STATIC CONST CHAR16  NameEfiMemoryMappedIOPortSpaceShort[] = L"MMIO_Port";
  42
  43 #include "UefiShellDebug1CommandsLib.h"
  44
  45 typedef struct {
  46   UINT32        Type;
  47   UINT64        NumberOfPages;
  48   LIST_ENTRY    Link;
  49 } MEMORY_LENGTH_ENTRY;
  50
  51 /**
  52   Add the length of the specified type to List.
  53
  54   @param List          A list to hold all pairs of <Type, NumberOfPages>.
  55   @param Type          Memory type.
  56   @param NumberOfPages Number of pages.
  57 **/
  58 VOID
  59 AddMemoryLength (
  60   LIST_ENTRY  *List,
  61   UINT32      Type,
  62   UINT64      NumberOfPages
  63   )
  64 {
  65   MEMORY_LENGTH_ENTRY  *Entry;
  66   MEMORY_LENGTH_ENTRY  *NewEntry;
  67   LIST_ENTRY           *Link;
  68
  69   Entry = NULL;
  70   for (Link = GetFirstNode (List); !IsNull (List, Link); Link = GetNextNode (List, Link)) {
  71     Entry = BASE_CR (Link, MEMORY_LENGTH_ENTRY, Link);
  72     if (Entry->Type >= Type) {
  73       break;
  74     }
  75   }
  76
  77   if ((Entry != NULL) && (Entry->Type == Type)) {
  78     //
  79     // The Entry is the one we look for.
  80     //
  81     NewEntry = Entry;
  82   } else {
  83     //
  84     // The search operation breaks due to:
  85     // 1. Type of every entry < Type --> Insert to tail
  86     // 2. Type of an entry > Type --> Insert to previous of this entry
  87     //
  88     NewEntry = AllocatePool (sizeof (*NewEntry));
  89     if (NewEntry == NULL) {
  90       return;
  91     }
  92
  93     NewEntry->Type          = Type;
  94     NewEntry->NumberOfPages = 0;
  95     InsertTailList (Link, &NewEntry->Link);
  96   }
  97
  98   NewEntry->NumberOfPages += NumberOfPages;
  99 }
 100
 101 /**
 102   Function for 'memmap' command.
 103
 104   @param[in] ImageHandle  Handle to the Image (NULL if Internal).
 105   @param[in] SystemTable  Pointer to the System Table (NULL if Internal).
 106 **/
 107 SHELL_STATUS
 108 EFIAPI
 109 ShellCommandRunMemMap (
 110   IN EFI_HANDLE        ImageHandle,
 111   IN EFI_SYSTEM_TABLE  *SystemTable
 112   )
 113 {
 114   EFI_STATUS             Status;
 115   LIST_ENTRY             *Package;
 116   CHAR16                 *ProblemParam;
 117   SHELL_STATUS           ShellStatus;
 118   UINTN                  Size;
 119   EFI_MEMORY_DESCRIPTOR  *Descriptors;
 120   UINTN                  MapKey;
 121   UINTN                  ItemSize;
 122   UINT32                 Version;
 123   EFI_MEMORY_DESCRIPTOR  *Walker;
 124   UINT64                 ReservedPages;
 125   UINT64                 LoadCodePages;
 126   UINT64                 LoadDataPages;
 127   UINT64                 BSCodePages;
 128   UINT64                 BSDataPages;
 129   UINT64                 RTDataPages;
 130   UINT64                 RTCodePages;
 131   UINT64                 AvailPages;
 132   UINT64                 TotalPages;
 133   UINT64                 ReservedPagesSize;
 134   UINT64                 LoadCodePagesSize;
 135   UINT64                 LoadDataPagesSize;
 136   UINT64                 BSCodePagesSize;
 137   UINT64                 BSDataPagesSize;
 138   UINT64                 RTDataPagesSize;
 139   UINT64                 RTCodePagesSize;
 140   UINT64                 AvailPagesSize;
 141   UINT64                 TotalPagesSize;
 142   UINT64                 AcpiReclaimPages;
 143   UINT64                 AcpiNvsPages;
 144   UINT64                 MmioSpacePages;
 145   UINT64                 AcpiReclaimPagesSize;
 146   UINT64                 AcpiNvsPagesSize;
 147   UINT64                 MmioSpacePagesSize;
 148   UINT64                 MmioPortPages;
 149   UINT64                 MmioPortPagesSize;
 150   UINT64                 UnusableMemoryPages;
 151   UINT64                 UnusableMemoryPagesSize;
 152   UINT64                 PalCodePages;
 153   UINT64                 PalCodePagesSize;
 154   UINT64                 PersistentPages;
 155   UINT64                 PersistentPagesSize;
 156   BOOLEAN                Sfo;
 157   LIST_ENTRY             MemoryList;
 158   MEMORY_LENGTH_ENTRY    *Entry;
 159   LIST_ENTRY             *Link;
 160
 161   AcpiReclaimPages    = 0;
 162   AcpiNvsPages        = 0;
 163   MmioSpacePages      = 0;
 164   TotalPages          = 0;
 165   ReservedPages       = 0;
 166   LoadCodePages       = 0;
 167   LoadDataPages       = 0;
 168   BSCodePages         = 0;
 169   BSDataPages         = 0;
 170   RTDataPages         = 0;
 171   RTCodePages         = 0;
 172   AvailPages          = 0;
 173   MmioPortPages       = 0;
 174   UnusableMemoryPages = 0;
 175   PalCodePages        = 0;
 176   PersistentPages     = 0;
 177   Size                = 0;
 178   Descriptors         = NULL;
 179   ShellStatus         = SHELL_SUCCESS;
 180   Status              = EFI_SUCCESS;
 181   InitializeListHead (&MemoryList);
 182
 183   //
 184   // initialize the shell lib (we must be in non-auto-init...)
 185   //
 186   Status = ShellInitialize ();
 187   ASSERT_EFI_ERROR (Status);
 188
 189   Status = CommandInit ();
 190   ASSERT_EFI_ERROR (Status);
 191
 192   //
 193   // parse the command line
 194   //
 195   Status = ShellCommandLineParse (SfoParamList, &Package, &ProblemParam, TRUE);
 196   if (EFI_ERROR (Status)) {
 197     if ((Status == EFI_VOLUME_CORRUPTED) && (ProblemParam != NULL)) {
 198       ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellDebug1HiiHandle, L"memmap", ProblemParam);
 199       FreePool (ProblemParam);
 200       ShellStatus = SHELL_INVALID_PARAMETER;
 201     } else {
 202       ASSERT (FALSE);
 203     }
 204   } else {
 205     if (ShellCommandLineGetCount (Package) > 1) {
 206       ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDebug1HiiHandle, L"memmap");
 207       ShellStatus = SHELL_INVALID_PARAMETER;
 208     } else {
 209       Status = gBS->GetMemoryMap (&Size, Descriptors, &MapKey, &ItemSize, &Version);
 210       if (Status == EFI_BUFFER_TOO_SMALL) {
 211         Size       += SIZE_1KB;
 212         Descriptors = AllocateZeroPool (Size);
 213         Status      = gBS->GetMemoryMap (&Size, Descriptors, &MapKey, &ItemSize, &Version);
 214       }
 215
 216       if (EFI_ERROR (Status)) {
 217         ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_MEMMAP_GET_FAILED), gShellDebug1HiiHandle, L"memmap");
 218         ShellStatus = SHELL_ACCESS_DENIED;
 219       } else {
 220         ASSERT (Version == EFI_MEMORY_DESCRIPTOR_VERSION);
 221
 222         Sfo = ShellCommandLineGetFlag (Package, L"-sfo");
 223         if (!Sfo) {
 224           ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_MEMMAP_LIST_HEAD), gShellDebug1HiiHandle);
 225         } else {
 226           ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_SFO_HEADER), gShellDebug1HiiHandle, L"memmap");
 227         }
 228
 229         for ( Walker = Descriptors
 230               ; (Walker < (EFI_MEMORY_DESCRIPTOR *)((UINT8 *)Descriptors + Size)) && (Walker != NULL)
 231               ; Walker = (EFI_MEMORY_DESCRIPTOR *)((UINT8 *)Walker + ItemSize)
 232               )
 233         {
 234           switch (Walker->Type) {
 235             case EfiReservedMemoryType:
 236               ShellPrintHiiEx (-1, -1, NULL, (EFI_STRING_ID)(!Sfo ? STRING_TOKEN (STR_MEMMAP_LIST_ITEM) : STRING_TOKEN (STR_MEMMAP_LIST_ITEM_SFO)), gShellDebug1HiiHandle, NameEfiReservedMemoryType, Walker->PhysicalStart, Walker->PhysicalStart+MultU64x64 (SIZE_4KB, Walker->NumberOfPages)-1, Walker->NumberOfPages, Walker->Attribute);
 237               ReservedPages += Walker->NumberOfPages;
 238               break;
 239             case EfiLoaderCode:
 240               ShellPrintHiiEx (-1, -1, NULL, (EFI_STRING_ID)(!Sfo ? STRING_TOKEN (STR_MEMMAP_LIST_ITEM) : STRING_TOKEN (STR_MEMMAP_LIST_ITEM_SFO)), gShellDebug1HiiHandle, NameEfiLoaderCode, Walker->PhysicalStart, Walker->PhysicalStart+MultU64x64 (SIZE_4KB, Walker->NumberOfPages)-1, Walker->NumberOfPages, Walker->Attribute);
 241               LoadCodePages += Walker->NumberOfPages;
 242               TotalPages    += Walker->NumberOfPages;
 243               break;
 244             case EfiLoaderData:
 245               ShellPrintHiiEx (-1, -1, NULL, (EFI_STRING_ID)(!Sfo ? STRING_TOKEN (STR_MEMMAP_LIST_ITEM) : STRING_TOKEN (STR_MEMMAP_LIST_ITEM_SFO)), gShellDebug1HiiHandle, NameEfiLoaderData, Walker->PhysicalStart, Walker->PhysicalStart+MultU64x64 (SIZE_4KB, Walker->NumberOfPages)-1, Walker->NumberOfPages, Walker->Attribute);
 246               LoadDataPages += Walker->NumberOfPages;
 247               TotalPages    += Walker->NumberOfPages;
 248               break;
 249             case EfiBootServicesCode:
 250               ShellPrintHiiEx (-1, -1, NULL, (EFI_STRING_ID)(!Sfo ? STRING_TOKEN (STR_MEMMAP_LIST_ITEM) : STRING_TOKEN (STR_MEMMAP_LIST_ITEM_SFO)), gShellDebug1HiiHandle, !Sfo ? NameEfiBootServicesCodeShort : NameEfiBootServicesCode, Walker->PhysicalStart, Walker->PhysicalStart+MultU64x64 (SIZE_4KB, Walker->NumberOfPages)-1, Walker->NumberOfPages, Walker->Attribute);
 251               BSCodePages += Walker->NumberOfPages;
 252               TotalPages  += Walker->NumberOfPages;
 253               break;
 254             case EfiBootServicesData:
 255               ShellPrintHiiEx (-1, -1, NULL, (EFI_STRING_ID)(!Sfo ? STRING_TOKEN (STR_MEMMAP_LIST_ITEM) : STRING_TOKEN (STR_MEMMAP_LIST_ITEM_SFO)), gShellDebug1HiiHandle, !Sfo ? NameEfiBootServicesDataShort : NameEfiBootServicesData, Walker->PhysicalStart, Walker->PhysicalStart+MultU64x64 (SIZE_4KB, Walker->NumberOfPages)-1, Walker->NumberOfPages, Walker->Attribute);
 256               BSDataPages += Walker->NumberOfPages;
 257               TotalPages  += Walker->NumberOfPages;
 258               break;
 259             case EfiRuntimeServicesCode:
 260               ShellPrintHiiEx (-1, -1, NULL, (EFI_STRING_ID)(!Sfo ? STRING_TOKEN (STR_MEMMAP_LIST_ITEM) : STRING_TOKEN (STR_MEMMAP_LIST_ITEM_SFO)), gShellDebug1HiiHandle, !Sfo ? NameEfiRuntimeServicesCodeShort : NameEfiRuntimeServicesCode, Walker->PhysicalStart, Walker->PhysicalStart+MultU64x64 (SIZE_4KB, Walker->NumberOfPages)-1, Walker->NumberOfPages, Walker->Attribute);
 261               RTCodePages += Walker->NumberOfPages;
 262               TotalPages  += Walker->NumberOfPages;
 263               break;
 264             case EfiRuntimeServicesData:
 265               ShellPrintHiiEx (-1, -1, NULL, (EFI_STRING_ID)(!Sfo ? STRING_TOKEN (STR_MEMMAP_LIST_ITEM) : STRING_TOKEN (STR_MEMMAP_LIST_ITEM_SFO)), gShellDebug1HiiHandle, !Sfo ? NameEfiRuntimeServicesDataShort : NameEfiRuntimeServicesData, Walker->PhysicalStart, Walker->PhysicalStart+MultU64x64 (SIZE_4KB, Walker->NumberOfPages)-1, Walker->NumberOfPages, Walker->Attribute);
 266               RTDataPages += Walker->NumberOfPages;
 267               TotalPages  += Walker->NumberOfPages;
 268               break;
 269             case EfiConventionalMemory:
 270               ShellPrintHiiEx (-1, -1, NULL, (EFI_STRING_ID)(!Sfo ? STRING_TOKEN (STR_MEMMAP_LIST_ITEM) : STRING_TOKEN (STR_MEMMAP_LIST_ITEM_SFO)), gShellDebug1HiiHandle, NameEfiConventionalMemory, Walker->PhysicalStart, Walker->PhysicalStart+MultU64x64 (SIZE_4KB, Walker->NumberOfPages)-1, Walker->NumberOfPages, Walker->Attribute);
 271               AvailPages += Walker->NumberOfPages;
 272               TotalPages += Walker->NumberOfPages;
 273               break;
 274             case EfiPersistentMemory:
 275               ShellPrintHiiEx (-1, -1, NULL, (EFI_STRING_ID)(!Sfo ? STRING_TOKEN (STR_MEMMAP_LIST_ITEM) : STRING_TOKEN (STR_MEMMAP_LIST_ITEM_SFO)), gShellDebug1HiiHandle, NameEfiPersistentMemory, Walker->PhysicalStart, Walker->PhysicalStart+MultU64x64 (SIZE_4KB, Walker->NumberOfPages)-1, Walker->NumberOfPages, Walker->Attribute);
 276               PersistentPages += Walker->NumberOfPages;
 277               TotalPages      += Walker->NumberOfPages;
 278               break;
 279             case EfiUnusableMemory:
 280               ShellPrintHiiEx (-1, -1, NULL, (EFI_STRING_ID)(!Sfo ? STRING_TOKEN (STR_MEMMAP_LIST_ITEM) : STRING_TOKEN (STR_MEMMAP_LIST_ITEM_SFO)), gShellDebug1HiiHandle, !Sfo ? NameEfiUnusableMemoryShort : NameEfiUnusableMemory, Walker->PhysicalStart, Walker->PhysicalStart+MultU64x64 (SIZE_4KB, Walker->NumberOfPages)-1, Walker->NumberOfPages, Walker->Attribute);
 281               UnusableMemoryPages += Walker->NumberOfPages;
 282               break;
 283             case EfiACPIReclaimMemory:
 284               ShellPrintHiiEx (-1, -1, NULL, (EFI_STRING_ID)(!Sfo ? STRING_TOKEN (STR_MEMMAP_LIST_ITEM) : STRING_TOKEN (STR_MEMMAP_LIST_ITEM_SFO)), gShellDebug1HiiHandle, !Sfo ? NameEfiACPIReclaimMemoryShort : NameEfiACPIReclaimMemory, Walker->PhysicalStart, Walker->PhysicalStart+MultU64x64 (SIZE_4KB, Walker->NumberOfPages)-1, Walker->NumberOfPages, Walker->Attribute);
 285               TotalPages       += Walker->NumberOfPages;
 286               AcpiReclaimPages += Walker->NumberOfPages;
 287               break;
 288             case EfiACPIMemoryNVS:
 289               ShellPrintHiiEx (-1, -1, NULL, (EFI_STRING_ID)(!Sfo ? STRING_TOKEN (STR_MEMMAP_LIST_ITEM) : STRING_TOKEN (STR_MEMMAP_LIST_ITEM_SFO)), gShellDebug1HiiHandle, !Sfo ? NameEfiACPIMemoryNVSShort : NameEfiACPIMemoryNVS, Walker->PhysicalStart, Walker->PhysicalStart+MultU64x64 (SIZE_4KB, Walker->NumberOfPages)-1, Walker->NumberOfPages, Walker->Attribute);
 290               TotalPages   += Walker->NumberOfPages;
 291               AcpiNvsPages += Walker->NumberOfPages;
 292               break;
 293             case EfiMemoryMappedIO:
 294               ShellPrintHiiEx (-1, -1, NULL, (EFI_STRING_ID)(!Sfo ? STRING_TOKEN (STR_MEMMAP_LIST_ITEM) : STRING_TOKEN (STR_MEMMAP_LIST_ITEM_SFO)), gShellDebug1HiiHandle, !Sfo ? NameEfiMemoryMappedIOShort : NameEfiMemoryMappedIO, Walker->PhysicalStart, Walker->PhysicalStart+MultU64x64 (SIZE_4KB, Walker->NumberOfPages)-1, Walker->NumberOfPages, Walker->Attribute);
 295               MmioSpacePages += Walker->NumberOfPages;
 296               break;
 297             case EfiMemoryMappedIOPortSpace:
 298               ShellPrintHiiEx (-1, -1, NULL, (EFI_STRING_ID)(!Sfo ? STRING_TOKEN (STR_MEMMAP_LIST_ITEM) : STRING_TOKEN (STR_MEMMAP_LIST_ITEM_SFO)), gShellDebug1HiiHandle, !Sfo ? NameEfiMemoryMappedIOPortSpaceShort : NameEfiMemoryMappedIOPortSpace, Walker->PhysicalStart, Walker->PhysicalStart+MultU64x64 (SIZE_4KB, Walker->NumberOfPages)-1, Walker->NumberOfPages, Walker->Attribute);
 299               MmioPortPages += Walker->NumberOfPages;
 300               break;
 301             case EfiPalCode:
 302               ShellPrintHiiEx (-1, -1, NULL, (EFI_STRING_ID)(!Sfo ? STRING_TOKEN (STR_MEMMAP_LIST_ITEM) : STRING_TOKEN (STR_MEMMAP_LIST_ITEM_SFO)), gShellDebug1HiiHandle, NameEfiPalCode, Walker->PhysicalStart, Walker->PhysicalStart+MultU64x64 (SIZE_4KB, Walker->NumberOfPages)-1, Walker->NumberOfPages, Walker->Attribute);
 303               TotalPages   += Walker->NumberOfPages;
 304               PalCodePages += Walker->NumberOfPages;
 305               break;
 306             default:
 307               //
 308               // Shell Spec defines the SFO format.
 309               // Do not print the OEM/OS memory usage in the SFO format, to avoid conflict with Shell Spec.
 310               //
 311               if (!Sfo) {
 312                 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_MEMMAP_LIST_ITEM_OTHER), gShellDebug1HiiHandle, Walker->Type, Walker->PhysicalStart, Walker->PhysicalStart + MultU64x64 (SIZE_4KB, Walker->NumberOfPages) - 1, Walker->NumberOfPages, Walker->Attribute);
 313               }
 314
 315               TotalPages += Walker->NumberOfPages;
 316               AddMemoryLength (&MemoryList, Walker->Type, Walker->NumberOfPages);
 317               break;
 318           }
 319         }
 320
 321         //
 322         // print the summary
 323         //
 324         ReservedPagesSize       = MultU64x64 (SIZE_4KB, ReservedPages);
 325         LoadCodePagesSize       = MultU64x64 (SIZE_4KB, LoadCodePages);
 326         LoadDataPagesSize       = MultU64x64 (SIZE_4KB, LoadDataPages);
 327         BSCodePagesSize         = MultU64x64 (SIZE_4KB, BSCodePages);
 328         BSDataPagesSize         = MultU64x64 (SIZE_4KB, BSDataPages);
 329         RTDataPagesSize         = MultU64x64 (SIZE_4KB, RTDataPages);
 330         RTCodePagesSize         = MultU64x64 (SIZE_4KB, RTCodePages);
 331         AvailPagesSize          = MultU64x64 (SIZE_4KB, AvailPages);
 332         TotalPagesSize          = MultU64x64 (SIZE_4KB, TotalPages);
 333         AcpiReclaimPagesSize    = MultU64x64 (SIZE_4KB, AcpiReclaimPages);
 334         AcpiNvsPagesSize        = MultU64x64 (SIZE_4KB, AcpiNvsPages);
 335         MmioSpacePagesSize      = MultU64x64 (SIZE_4KB, MmioSpacePages);
 336         MmioPortPagesSize       = MultU64x64 (SIZE_4KB, MmioPortPages);
 337         PalCodePagesSize        = MultU64x64 (SIZE_4KB, PalCodePages);
 338         PersistentPagesSize     = MultU64x64 (SIZE_4KB, PersistentPages);
 339         UnusableMemoryPagesSize = MultU64x64 (SIZE_4KB, UnusableMemoryPages);
 340         if (!Sfo) {
 341           ShellPrintHiiEx (
 342             -1,
 343             -1,
 344             NULL,
 345             STRING_TOKEN (STR_MEMMAP_LIST_SUMM),
 346             gShellDebug1HiiHandle,
 347             ReservedPages,
 348             ReservedPagesSize,
 349             LoadCodePages,
 350             LoadCodePagesSize,
 351             LoadDataPages,
 352             LoadDataPagesSize,
 353             BSCodePages,
 354             BSCodePagesSize,
 355             BSDataPages,
 356             BSDataPagesSize,
 357             RTCodePages,
 358             RTCodePagesSize,
 359             RTDataPages,
 360             RTDataPagesSize,
 361             AcpiReclaimPages,
 362             AcpiReclaimPagesSize,
 363             AcpiNvsPages,
 364             AcpiNvsPagesSize,
 365             MmioSpacePages,
 366             MmioSpacePagesSize,
 367             MmioPortPages,
 368             MmioPortPagesSize,
 369             PalCodePages,
 370             PalCodePagesSize,
 371             AvailPages,
 372             AvailPagesSize,
 373             PersistentPages,
 374             PersistentPagesSize
 375             );
 376
 377           //
 378           // Print out the total memory usage for OEM/OS types in the order of type.
 379           //
 380           for (Link = GetFirstNode (&MemoryList); !IsNull (&MemoryList, Link); Link = GetNextNode (&MemoryList, Link)) {
 381             Entry = BASE_CR (Link, MEMORY_LENGTH_ENTRY, Link);
 382             ShellPrintHiiEx (
 383               -1,
 384               -1,
 385               NULL,
 386               STRING_TOKEN (STR_MEMMAP_LIST_SUMM_OTHER),
 387               gShellDebug1HiiHandle,
 388               Entry->Type,
 389               Entry->NumberOfPages,
 390               MultU64x64 (SIZE_4KB, Entry->NumberOfPages)
 391               );
 392           }
 393
 394           ShellPrintHiiEx (
 395             -1,
 396             -1,
 397             NULL,
 398             STRING_TOKEN (STR_MEMMAP_LIST_SUMM2),
 399             gShellDebug1HiiHandle,
 400             DivU64x32 (MultU64x64 (SIZE_4KB, TotalPages), SIZE_1MB),
 401             TotalPagesSize
 402             );
 403         } else {
 404           ShellPrintHiiEx (
 405             -1,
 406             -1,
 407             NULL,
 408             STRING_TOKEN (STR_MEMMAP_LIST_SUMM_SFO),
 409             gShellDebug1HiiHandle,
 410             TotalPagesSize,
 411             ReservedPagesSize,
 412             BSCodePagesSize,
 413             BSDataPagesSize,
 414             RTCodePagesSize,
 415             RTDataPagesSize,
 416             LoadCodePagesSize,
 417             LoadDataPagesSize,
 418             AvailPagesSize,
 419             MmioSpacePagesSize,
 420             MmioPortPagesSize,
 421             UnusableMemoryPagesSize,
 422             AcpiReclaimPagesSize,
 423             AcpiNvsPagesSize,
 424             PalCodePagesSize,
 425             PersistentPagesSize
 426             );
 427         }
 428       }
 429     }
 430
 431     ShellCommandLineFreeVarList (Package);
 432   }
 433
 434   if (Descriptors != NULL) {
 435     FreePool (Descriptors);
 436   }
 437
 438   //
 439   // Free the memory list.
 440   //
 441   for (Link = GetFirstNode (&MemoryList); !IsNull (&MemoryList, Link); ) {
 442     Link = RemoveEntryList (Link);
 443   }
 444
 445   return (ShellStatus);
 446 }