UefiCpuPkg: Apply uncrustify changes

[mirror_edk2.git] / UefiCpuPkg / Library / CpuCacheInfoLib / CpuCacheInfoLib.c

/** @file\r
  Provides cache info for each package, core type, cache level and cache type.\r
\r
  Copyright (c) 2020 - 2021, Intel Corporation. All rights reserved.<BR>\r
  SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#include "InternalCpuCacheInfoLib.h"\r
\r
/**\r
  Print CpuCacheInfo array.\r
\r
  @param[in]  CpuCacheInfo        Pointer to the CpuCacheInfo array.\r
  @param[in]  CpuCacheInfoCount   The length of CpuCacheInfo array.\r
\r
**/\r
VOID\r
CpuCacheInfoPrintCpuCacheInfoTable (\r
  IN CPU_CACHE_INFO  *CpuCacheInfo,\r
  IN UINTN           CpuCacheInfoCount\r
  )\r
{\r
  UINTN  Index;\r
\r
  DEBUG ((DEBUG_INFO, "+-------+--------------------------------------------------------------------------------------+\n"));\r
  DEBUG ((DEBUG_INFO, "| Index | Packge  CoreType  CacheLevel  CacheType  CacheWays (FA|DM) CacheSizeinKB  CacheCount |\n"));\r
  DEBUG ((DEBUG_INFO, "+-------+--------------------------------------------------------------------------------------+\n"));\r
\r
  for (Index = 0; Index < CpuCacheInfoCount; Index++) {\r
    DEBUG ((\r
      DEBUG_INFO,\r
      "| %4x  | %4x       %2x        %2x          %2x       %4x     ( %x| %x) %8x         %4x     |\n",\r
      Index,\r
      CpuCacheInfo[Index].Package,\r
      CpuCacheInfo[Index].CoreType,\r
      CpuCacheInfo[Index].CacheLevel,\r
      CpuCacheInfo[Index].CacheType,\r
      CpuCacheInfo[Index].CacheWays,\r
      CpuCacheInfo[Index].FullyAssociativeCache,\r
      CpuCacheInfo[Index].DirectMappedCache,\r
      CpuCacheInfo[Index].CacheSizeinKB,\r
      CpuCacheInfo[Index].CacheCount\r
      ));\r
  }\r
\r
  DEBUG ((DEBUG_INFO, "+-------+--------------------------------------------------------------------------------------+\n"));\r
}\r
\r
/**\r
  Function to compare CPU package ID, core type, cache level and cache type for use in QuickSort.\r
\r
  @param[in]  Buffer1             pointer to CPU_CACHE_INFO poiner to compare\r
  @param[in]  Buffer2             pointer to second CPU_CACHE_INFO pointer to compare\r
\r
  @retval  0                      Buffer1 equal to Buffer2\r
  @retval  1                      Buffer1 is greater than Buffer2\r
  @retval  -1                     Buffer1 is less than Buffer2\r
**/\r
INTN\r
EFIAPI\r
CpuCacheInfoCompare (\r
  IN CONST VOID  *Buffer1,\r
  IN CONST VOID  *Buffer2\r
  )\r
{\r
  CPU_CACHE_INFO_COMPARATOR  Comparator1, Comparator2;\r
\r
  ZeroMem (&Comparator1, sizeof (Comparator1));\r
  ZeroMem (&Comparator2, sizeof (Comparator2));\r
\r
  Comparator1.Bits.Package    = ((CPU_CACHE_INFO *)Buffer1)->Package;\r
  Comparator1.Bits.CoreType   = ((CPU_CACHE_INFO *)Buffer1)->CoreType;\r
  Comparator1.Bits.CacheLevel = ((CPU_CACHE_INFO *)Buffer1)->CacheLevel;\r
  Comparator1.Bits.CacheType  = ((CPU_CACHE_INFO *)Buffer1)->CacheType;\r
\r
  Comparator2.Bits.Package    = ((CPU_CACHE_INFO *)Buffer2)->Package;\r
  Comparator2.Bits.CoreType   = ((CPU_CACHE_INFO *)Buffer2)->CoreType;\r
  Comparator2.Bits.CacheLevel = ((CPU_CACHE_INFO *)Buffer2)->CacheLevel;\r
  Comparator2.Bits.CacheType  = ((CPU_CACHE_INFO *)Buffer2)->CacheType;\r
\r
  if (Comparator1.Uint64 == Comparator2.Uint64) {\r
    return 0;\r
  } else if (Comparator1.Uint64 > Comparator2.Uint64) {\r
    return 1;\r
  } else {\r
    return -1;\r
  }\r
}\r
\r
/**\r
  Get the total number of package and package ID in the platform.\r
\r
  @param[in]      ProcessorInfo       Pointer to the ProcessorInfo array.\r
  @param[in]      NumberOfProcessors  Total number of logical processors in the platform.\r
  @param[in, out] Package             Pointer to the Package array.\r
\r
  @retval  Return the total number of package and package ID in the platform.\r
**/\r
UINT32\r
CpuCacheInfoGetNumberOfPackages (\r
  IN CPUID_PROCESSOR_INFO  *ProcessorInfo,\r
  IN UINTN                 NumberOfProcessors,\r
  IN OUT UINT32            *Package\r
  )\r
{\r
  UINTN   ProcessorIndex;\r
  UINT32  PackageIndex;\r
  UINT32  PackageCount;\r
  UINT32  CurrentPackage;\r
\r
  PackageCount = 0;\r
\r
  for (ProcessorIndex = 0; ProcessorIndex < NumberOfProcessors; ProcessorIndex++) {\r
    CurrentPackage = ProcessorInfo[ProcessorIndex].Package;\r
\r
    //\r
    // For the package that already exists in Package array, break out the loop.\r
    //\r
    for (PackageIndex = 0; PackageIndex < PackageCount; PackageIndex++) {\r
      if (CurrentPackage == Package[PackageIndex]) {\r
        break;\r
      }\r
    }\r
\r
    //\r
    // For the new package, save it in Package array.\r
    //\r
    if (PackageIndex == PackageCount) {\r
      ASSERT (PackageCount < MAX_NUM_OF_PACKAGE);\r
      Package[PackageCount++] = CurrentPackage;\r
    }\r
  }\r
\r
  return PackageCount;\r
}\r
\r
/**\r
  Get the number of CoreType of requested package.\r
\r
  @param[in]  ProcessorInfo       Pointer to the ProcessorInfo array.\r
  @param[in]  NumberOfProcessors  Total number of logical processors in the platform.\r
  @param[in]  Package             The requested package number.\r
\r
  @retval  Return the number of CoreType of requested package.\r
**/\r
UINTN\r
CpuCacheInfoGetNumberOfCoreTypePerPackage (\r
  IN CPUID_PROCESSOR_INFO  *ProcessorInfo,\r
  IN UINTN                 NumberOfProcessors,\r
  IN UINTN                 Package\r
  )\r
{\r
  UINTN  ProcessorIndex;\r
  //\r
  // Core Type value comes from CPUID.1Ah.EAX[31:24].\r
  // So max number of core types should be MAX_UINT8.\r
  //\r
  UINT8  CoreType[MAX_UINT8];\r
  UINTN  CoreTypeIndex;\r
  UINTN  CoreTypeCount;\r
  UINT8  CurrentCoreType;\r
\r
  //\r
  // CoreType array is empty.\r
  //\r
  CoreTypeCount = 0;\r
\r
  for (ProcessorIndex = 0; ProcessorIndex < NumberOfProcessors; ProcessorIndex++) {\r
    CurrentCoreType = ProcessorInfo[ProcessorIndex].CoreType;\r
\r
    if (ProcessorInfo[ProcessorIndex].Package != Package) {\r
      continue;\r
    }\r
\r
    //\r
    // For the type that already exists in CoreType array, break out the loop.\r
    //\r
    for (CoreTypeIndex = 0; CoreTypeIndex < CoreTypeCount; CoreTypeIndex++) {\r
      if (CurrentCoreType == CoreType[CoreTypeIndex]) {\r
        break;\r
      }\r
    }\r
\r
    //\r
    // For the new type, save it in CoreType array.\r
    //\r
    if (CoreTypeIndex == CoreTypeCount) {\r
      ASSERT (CoreTypeCount < MAX_UINT8);\r
      CoreType[CoreTypeCount++] = CurrentCoreType;\r
    }\r
  }\r
\r
  return CoreTypeCount;\r
}\r
\r
/**\r
  Collect core and cache information of calling processor via CPUID instructions.\r
\r
  @param[in, out] Buffer              The pointer to private data buffer.\r
**/\r
VOID\r
EFIAPI\r
CpuCacheInfoCollectCoreAndCacheData (\r
  IN OUT VOID  *Buffer\r
  )\r
{\r
  UINTN                                    ProcessorIndex;\r
  UINT32                                   CpuidMaxInput;\r
  UINT8                                    CacheParamLeafIndex;\r
  CPUID_CACHE_PARAMS_EAX                   CacheParamEax;\r
  CPUID_CACHE_PARAMS_EBX                   CacheParamEbx;\r
  UINT32                                   CacheParamEcx;\r
  CPUID_CACHE_PARAMS_EDX                   CacheParamEdx;\r
  CPUID_NATIVE_MODEL_ID_AND_CORE_TYPE_EAX  NativeModelIdAndCoreTypeEax;\r
  COLLECT_CPUID_CACHE_DATA_CONTEXT         *Context;\r
  CPUID_CACHE_DATA                         *CacheData;\r
\r
  Context        = (COLLECT_CPUID_CACHE_DATA_CONTEXT *)Buffer;\r
  ProcessorIndex = CpuCacheInfoWhoAmI (Context->MpServices);\r
  CacheData      = &Context->CacheData[MAX_NUM_OF_CACHE_PARAMS_LEAF * ProcessorIndex];\r
\r
  AsmCpuid (CPUID_SIGNATURE, &CpuidMaxInput, NULL, NULL, NULL);\r
\r
  //\r
  // get CoreType if CPUID_HYBRID_INFORMATION leaf is supported.\r
  //\r
  Context->ProcessorInfo[ProcessorIndex].CoreType = 0;\r
  if (CpuidMaxInput >= CPUID_HYBRID_INFORMATION) {\r
    AsmCpuidEx (CPUID_HYBRID_INFORMATION, CPUID_HYBRID_INFORMATION_MAIN_LEAF, &NativeModelIdAndCoreTypeEax.Uint32, NULL, NULL, NULL);\r
    Context->ProcessorInfo[ProcessorIndex].CoreType = (UINT8)NativeModelIdAndCoreTypeEax.Bits.CoreType;\r
  }\r
\r
  //\r
  // cache hierarchy starts with an index value of 0.\r
  //\r
  CacheParamLeafIndex = 0;\r
\r
  while (CacheParamLeafIndex < MAX_NUM_OF_CACHE_PARAMS_LEAF) {\r
    AsmCpuidEx (CPUID_CACHE_PARAMS, CacheParamLeafIndex, &CacheParamEax.Uint32, &CacheParamEbx.Uint32, &CacheParamEcx, &CacheParamEdx.Uint32);\r
\r
    if (CacheParamEax.Bits.CacheType == 0) {\r
      break;\r
    }\r
\r
    CacheData[CacheParamLeafIndex].CacheLevel            = (UINT8)CacheParamEax.Bits.CacheLevel;\r
    CacheData[CacheParamLeafIndex].CacheType             = (UINT8)CacheParamEax.Bits.CacheType;\r
    CacheData[CacheParamLeafIndex].CacheWays             = (UINT16)CacheParamEbx.Bits.Ways;\r
    CacheData[CacheParamLeafIndex].FullyAssociativeCache = (UINT8)CacheParamEax.Bits.FullyAssociativeCache;\r
    CacheData[CacheParamLeafIndex].DirectMappedCache     = (UINT8)(CacheParamEdx.Bits.ComplexCacheIndexing == 0);\r
    CacheData[CacheParamLeafIndex].CacheShareBits        = (UINT16)CacheParamEax.Bits.MaximumAddressableIdsForLogicalProcessors;\r
    CacheData[CacheParamLeafIndex].CacheSizeinKB         = (CacheParamEbx.Bits.Ways + 1) *\r
                                                           (CacheParamEbx.Bits.LinePartitions + 1) * (CacheParamEbx.Bits.LineSize + 1) * (CacheParamEcx + 1) / SIZE_1KB;\r
\r
    CacheParamLeafIndex++;\r
  }\r
}\r
\r
/**\r
  Collect CacheInfo data from the CacheData.\r
\r
  @param[in]      CacheData           Pointer to the CacheData array.\r
  @param[in]      ProcessorInfo       Pointer to the ProcessorInfo array.\r
  @param[in]      NumberOfProcessors  Total number of logical processors in the platform.\r
  @param[in, out] CacheInfo           Pointer to the CacheInfo array.\r
  @param[in, out] CacheInfoCount      As input, point to the length of response CacheInfo array.\r
                                      As output, point to the actual length of response CacheInfo array.\r
\r
  @retval         EFI_SUCCESS             Function completed successfully.\r
  @retval         EFI_OUT_OF_RESOURCES    Required resources could not be allocated.\r
  @retval         EFI_BUFFER_TOO_SMALL    CacheInfoCount is too small to hold the response CacheInfo\r
                                          array. CacheInfoCount has been updated with the length needed\r
                                          to complete the request.\r
**/\r
EFI_STATUS\r
CpuCacheInfoCollectCpuCacheInfoData (\r
  IN CPUID_CACHE_DATA      *CacheData,\r
  IN CPUID_PROCESSOR_INFO  *ProcessorInfo,\r
  IN UINTN                 NumberOfProcessors,\r
  IN OUT CPU_CACHE_INFO    *CacheInfo,\r
  IN OUT UINTN             *CacheInfoCount\r
  )\r
{\r
  EFI_STATUS      Status;\r
  UINT32          NumberOfPackage;\r
  UINT32          Package[MAX_NUM_OF_PACKAGE];\r
  UINTN           PackageIndex;\r
  UINTN           TotalNumberOfCoreType;\r
  UINTN           MaxCacheInfoCount;\r
  CPU_CACHE_INFO  *LocalCacheInfo;\r
  UINTN           CacheInfoIndex;\r
  UINTN           LocalCacheInfoCount;\r
  UINTN           Index;\r
  UINTN           NextIndex;\r
  CPU_CACHE_INFO  SortBuffer;\r
\r
  //\r
  // Get number of Packages and Package ID.\r
  //\r
  NumberOfPackage = CpuCacheInfoGetNumberOfPackages (ProcessorInfo, NumberOfProcessors, Package);\r
\r
  //\r
  // Get number of core types for each package and count the total number.\r
  // E.g. If Package1 and Package2 both have 2 core types, the total number is 4.\r
  //\r
  TotalNumberOfCoreType = 0;\r
  for (PackageIndex = 0; PackageIndex < NumberOfPackage; PackageIndex++) {\r
    TotalNumberOfCoreType += CpuCacheInfoGetNumberOfCoreTypePerPackage (ProcessorInfo, NumberOfProcessors, Package[PackageIndex]);\r
  }\r
\r
  MaxCacheInfoCount = TotalNumberOfCoreType * MAX_NUM_OF_CACHE_PARAMS_LEAF;\r
  LocalCacheInfo    = AllocatePages (EFI_SIZE_TO_PAGES (MaxCacheInfoCount * sizeof (*LocalCacheInfo)));\r
  ASSERT (LocalCacheInfo != NULL);\r
  if (LocalCacheInfo == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  LocalCacheInfoCount = 0;\r
\r
  for (Index = 0; Index < NumberOfProcessors * MAX_NUM_OF_CACHE_PARAMS_LEAF; Index++) {\r
    if (CacheData[Index].CacheSizeinKB == 0) {\r
      continue;\r
    }\r
\r
    //\r
    // For the sharing caches, clear their CacheSize.\r
    //\r
    for (NextIndex = Index + 1; NextIndex < NumberOfProcessors * MAX_NUM_OF_CACHE_PARAMS_LEAF; NextIndex++) {\r
      if (CacheData[NextIndex].CacheSizeinKB == 0) {\r
        continue;\r
      }\r
\r
      if ((CacheData[Index].CacheLevel == CacheData[NextIndex].CacheLevel) &&\r
          (CacheData[Index].CacheType == CacheData[NextIndex].CacheType) &&\r
          (ProcessorInfo[Index / MAX_NUM_OF_CACHE_PARAMS_LEAF].Package == ProcessorInfo[NextIndex / MAX_NUM_OF_CACHE_PARAMS_LEAF].Package) &&\r
          (ProcessorInfo[Index / MAX_NUM_OF_CACHE_PARAMS_LEAF].CoreType == ProcessorInfo[NextIndex / MAX_NUM_OF_CACHE_PARAMS_LEAF].CoreType) &&\r
          ((ProcessorInfo[Index / MAX_NUM_OF_CACHE_PARAMS_LEAF].ApicId & ~CacheData[Index].CacheShareBits) ==\r
           (ProcessorInfo[NextIndex / MAX_NUM_OF_CACHE_PARAMS_LEAF].ApicId & ~CacheData[NextIndex].CacheShareBits)))\r
      {\r
        CacheData[NextIndex].CacheSizeinKB = 0; // uses the sharing cache\r
      }\r
    }\r
\r
    //\r
    // For the cache that already exists in LocalCacheInfo, increase its CacheCount.\r
    //\r
    for (CacheInfoIndex = 0; CacheInfoIndex < LocalCacheInfoCount; CacheInfoIndex++) {\r
      if ((LocalCacheInfo[CacheInfoIndex].Package    == ProcessorInfo[Index / MAX_NUM_OF_CACHE_PARAMS_LEAF].Package) &&\r
          (LocalCacheInfo[CacheInfoIndex].CoreType   == ProcessorInfo[Index / MAX_NUM_OF_CACHE_PARAMS_LEAF].CoreType) &&\r
          (LocalCacheInfo[CacheInfoIndex].CacheLevel == CacheData[Index].CacheLevel) &&\r
          (LocalCacheInfo[CacheInfoIndex].CacheType  == CacheData[Index].CacheType))\r
      {\r
        LocalCacheInfo[CacheInfoIndex].CacheCount++;\r
        break;\r
      }\r
    }\r
\r
    //\r
    // For the new cache with different Package, CoreType, CacheLevel or CacheType, copy its\r
    // data into LocalCacheInfo buffer.\r
    //\r
    if (CacheInfoIndex == LocalCacheInfoCount) {\r
      ASSERT (LocalCacheInfoCount < MaxCacheInfoCount);\r
\r
      LocalCacheInfo[LocalCacheInfoCount].Package               = ProcessorInfo[Index / MAX_NUM_OF_CACHE_PARAMS_LEAF].Package;\r
      LocalCacheInfo[LocalCacheInfoCount].CoreType              = ProcessorInfo[Index / MAX_NUM_OF_CACHE_PARAMS_LEAF].CoreType;\r
      LocalCacheInfo[LocalCacheInfoCount].CacheLevel            = CacheData[Index].CacheLevel;\r
      LocalCacheInfo[LocalCacheInfoCount].CacheType             = CacheData[Index].CacheType;\r
      LocalCacheInfo[LocalCacheInfoCount].CacheWays             = CacheData[Index].CacheWays;\r
      LocalCacheInfo[LocalCacheInfoCount].FullyAssociativeCache = CacheData[Index].FullyAssociativeCache;\r
      LocalCacheInfo[LocalCacheInfoCount].DirectMappedCache     = CacheData[Index].DirectMappedCache;\r
      LocalCacheInfo[LocalCacheInfoCount].CacheSizeinKB         = CacheData[Index].CacheSizeinKB;\r
      LocalCacheInfo[LocalCacheInfoCount].CacheCount            = 1;\r
\r
      LocalCacheInfoCount++;\r
    }\r
  }\r
\r
  if (*CacheInfoCount < LocalCacheInfoCount) {\r
    Status = EFI_BUFFER_TOO_SMALL;\r
  } else {\r
    //\r
    // Sort LocalCacheInfo array by CPU package ID, core type, cache level and cache type.\r
    //\r
    QuickSort (LocalCacheInfo, LocalCacheInfoCount, sizeof (*LocalCacheInfo), CpuCacheInfoCompare, (VOID *)&SortBuffer);\r
    CopyMem (CacheInfo, LocalCacheInfo, sizeof (*CacheInfo) * LocalCacheInfoCount);\r
    DEBUG_CODE (\r
      CpuCacheInfoPrintCpuCacheInfoTable (CacheInfo, LocalCacheInfoCount);\r
      );\r
    Status = EFI_SUCCESS;\r
  }\r
\r
  *CacheInfoCount = LocalCacheInfoCount;\r
\r
  FreePages (LocalCacheInfo, EFI_SIZE_TO_PAGES (MaxCacheInfoCount * sizeof (*LocalCacheInfo)));\r
\r
  return Status;\r
}\r
\r
/**\r
  Get CpuCacheInfo data array. The array is sorted by CPU package ID, core type, cache level and cache type.\r
\r
  @param[in, out] CpuCacheInfo        Pointer to the CpuCacheInfo array.\r
  @param[in, out] CpuCacheInfoCount   As input, point to the length of response CpuCacheInfo array.\r
                                      As output, point to the actual length of response CpuCacheInfo array.\r
\r
  @retval         EFI_SUCCESS             Function completed successfully.\r
  @retval         EFI_INVALID_PARAMETER   CpuCacheInfoCount is NULL.\r
  @retval         EFI_INVALID_PARAMETER   CpuCacheInfo is NULL while CpuCacheInfoCount contains the value\r
                                          greater than zero.\r
  @retval         EFI_UNSUPPORTED         Processor does not support CPUID_CACHE_PARAMS Leaf.\r
  @retval         EFI_OUT_OF_RESOURCES    Required resources could not be allocated.\r
  @retval         EFI_BUFFER_TOO_SMALL    CpuCacheInfoCount is too small to hold the response CpuCacheInfo\r
                                          array. CpuCacheInfoCount has been updated with the length needed\r
                                          to complete the request.\r
**/\r
EFI_STATUS\r
EFIAPI\r
GetCpuCacheInfo (\r
  IN OUT CPU_CACHE_INFO  *CpuCacheInfo,\r
  IN OUT UINTN           *CpuCacheInfoCount\r
  )\r
{\r
  EFI_STATUS                        Status;\r
  UINT32                            CpuidMaxInput;\r
  UINT32                            NumberOfProcessors;\r
  UINTN                             CacheDataCount;\r
  UINTN                             ProcessorIndex;\r
  EFI_PROCESSOR_INFORMATION         ProcessorInfo;\r
  COLLECT_CPUID_CACHE_DATA_CONTEXT  Context;\r
\r
  if (CpuCacheInfoCount == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if ((*CpuCacheInfoCount != 0) && (CpuCacheInfo == NULL)) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  AsmCpuid (CPUID_SIGNATURE, &CpuidMaxInput, NULL, NULL, NULL);\r
  if (CpuidMaxInput < CPUID_CACHE_PARAMS) {\r
    return EFI_UNSUPPORTED;\r
  }\r
\r
  //\r
  // Initialize COLLECT_CPUID_CACHE_DATA_CONTEXT.MpServices.\r
  //\r
  CpuCacheInfoGetMpServices (&Context.MpServices);\r
\r
  NumberOfProcessors = CpuCacheInfoGetNumberOfProcessors (Context.MpServices);\r
\r
  //\r
  // Initialize COLLECT_CPUID_CACHE_DATA_CONTEXT.ProcessorInfo.\r
  //\r
  Context.ProcessorInfo = AllocatePages (EFI_SIZE_TO_PAGES (NumberOfProcessors * sizeof (*Context.ProcessorInfo)));\r
  ASSERT (Context.ProcessorInfo != NULL);\r
  if (Context.ProcessorInfo == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  //\r
  // Initialize COLLECT_CPUID_CACHE_DATA_CONTEXT.CacheData.\r
  // CacheData array consists of CPUID_CACHE_DATA data structure for each Cpuid Cache Parameter Leaf\r
  // per logical processor. The array begin with data of each Cache Parameter Leaf of processor 0, followed\r
  // by data of each Cache Parameter Leaf of processor 1 ...\r
  //\r
  CacheDataCount    = NumberOfProcessors * MAX_NUM_OF_CACHE_PARAMS_LEAF;\r
  Context.CacheData = AllocatePages (EFI_SIZE_TO_PAGES (CacheDataCount * sizeof (*Context.CacheData)));\r
  ASSERT (Context.CacheData != NULL);\r
  if (Context.CacheData == NULL) {\r
    FreePages (Context.ProcessorInfo, EFI_SIZE_TO_PAGES (NumberOfProcessors * sizeof (*Context.ProcessorInfo)));\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  ZeroMem (Context.CacheData, CacheDataCount * sizeof (*Context.CacheData));\r
\r
  //\r
  // Collect Package ID and APIC ID of all processors.\r
  //\r
  for (ProcessorIndex = 0; ProcessorIndex < NumberOfProcessors; ProcessorIndex++) {\r
    CpuCacheInfoGetProcessorInfo (Context.MpServices, ProcessorIndex, &ProcessorInfo);\r
    Context.ProcessorInfo[ProcessorIndex].Package = ProcessorInfo.Location.Package;\r
    Context.ProcessorInfo[ProcessorIndex].ApicId  = (UINT32)ProcessorInfo.ProcessorId;\r
  }\r
\r
  //\r
  // Wakeup all processors for CacheData(core type and cache data) collection.\r
  //\r
  CpuCacheInfoStartupAllCPUs (Context.MpServices, CpuCacheInfoCollectCoreAndCacheData, &Context);\r
\r
  //\r
  // Collect CpuCacheInfo data from CacheData.\r
  //\r
  Status = CpuCacheInfoCollectCpuCacheInfoData (Context.CacheData, Context.ProcessorInfo, NumberOfProcessors, CpuCacheInfo, CpuCacheInfoCount);\r
\r
  FreePages (Context.CacheData, EFI_SIZE_TO_PAGES (CacheDataCount * sizeof (*Context.CacheData)));\r
  FreePages (Context.ProcessorInfo, EFI_SIZE_TO_PAGES (NumberOfProcessors * sizeof (*Context.ProcessorInfo)));\r
\r
  return Status;\r
}\r