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