X-Git-Url: https://git.proxmox.com/?p=mirror_edk2.git;a=blobdiff_plain;f=EdkModulePkg%2FUniversal%2FPCD%2FDxe%2FPcd.c;h=57c67d67136672c518f5caac1fd84b78e42815e4;hp=4ed7eb0cd02e37e0bd0e9dbfabb6249925fd9e09;hb=a696a78c371709fc6a74295296c92c4e94b23a1d;hpb=878ddf1fc3540a715f63594ed22b6929e881afb4

diff --git a/EdkModulePkg/Universal/PCD/Dxe/Pcd.c b/EdkModulePkg/Universal/PCD/Dxe/Pcd.c
index 4ed7eb0cd0..57c67d6713 100644
--- a/EdkModulePkg/Universal/PCD/Dxe/Pcd.c
+++ b/EdkModulePkg/Universal/PCD/Dxe/Pcd.c
@@ -15,9 +15,9 @@ Module Name: Pcd.c
 
 **/
 
-#include "../Common/PcdCommon.h"
 #include "Service.h"
 
+EFI_LOCK mPcdDatabaseLock = EFI_INITIALIZE_LOCK_VARIABLE(EFI_TPL_CALLBACK);
 
 PCD_PROTOCOL mPcdInstance = {
   DxePcdSetSku,
@@ -52,16 +52,17 @@ PCD_PROTOCOL mPcdInstance = {
   DxePcdSetPtrEx,
   DxePcdSetBoolEx,
 
-  PcdRegisterCallBackOnSet,
-  PcdUnRegisterCallBackOnSet,
-  DxePcdGetNextToken
+  DxeRegisterCallBackOnSet,
+  DxeUnRegisterCallBackOnSet,
+  DxePcdGetNextToken,
+  DxePcdGetNextTokenSpace
 };
 
 
 //
 // Static global to reduce the code size
 //
-static EFI_HANDLE NewHandle = NULL;
+static EFI_HANDLE mNewHandle = NULL;
 
 EFI_STATUS
 EFIAPI
@@ -70,12 +71,18 @@ PcdDxeInit (
   IN EFI_SYSTEM_TABLE     *SystemTable
   )
 {
-  EFI_STATUS  Status;
-  
-  InitPcdDxeDataBase ();
-  
+  EFI_STATUS          Status;
+
+  //
+  // Make sure the Pcd Protocol is not already installed in the system
+  //
+
+  ASSERT_PROTOCOL_ALREADY_INSTALLED (NULL, &gPcdProtocolGuid);
+
+  BuildPcdDxeDataBase ();
+
   Status = gBS->InstallProtocolInterface (
-                  &NewHandle,
+                  &mNewHandle,
                   &gPcdProtocolGuid,
                   EFI_NATIVE_INTERFACE,
                   &mPcdInstance
@@ -88,13 +95,15 @@ PcdDxeInit (
 }
 
 
-EFI_STATUS
+VOID
 EFIAPI
 DxePcdSetSku (
-  IN  UINTN                  SkuId
+  IN  UINTN         SkuId
   )
 {
-  return DxeSetSku(SkuId);
+  mPcdDatabase->PeiDb.Init.SystemSkuId = (SKU_ID) SkuId;
+  
+  return;
 }
 
 
@@ -102,10 +111,10 @@ DxePcdSetSku (
 UINT8
 EFIAPI
 DxePcdGet8 (
-  IN UINTN  TokenNumber
+  IN UINTN                    TokenNumber
   )
 {
-  return DxePcdGet8Ex (NULL, TokenNumber);
+  return *((UINT8 *) GetWorker (TokenNumber, sizeof (UINT8)));
 }
 
 
@@ -113,10 +122,10 @@ DxePcdGet8 (
 UINT16
 EFIAPI
 DxePcdGet16 (
-  IN UINTN  TokenNumber
+  IN UINTN                    TokenNumber
   )
 {
-  return DxePcdGet16Ex (NULL, TokenNumber);
+  return ReadUnaligned16 (GetWorker (TokenNumber, sizeof (UINT16)));
 }
 
 
@@ -124,10 +133,10 @@ DxePcdGet16 (
 UINT32
 EFIAPI
 DxePcdGet32 (
-  IN UINTN  TokenNumber
+  IN UINTN                    TokenNumber
   )
 {
-  return DxePcdGet32Ex (NULL, TokenNumber);
+  return ReadUnaligned32 (GetWorker (TokenNumber, sizeof (UINT32)));
 }
 
 
@@ -135,10 +144,10 @@ DxePcdGet32 (
 UINT64
 EFIAPI
 DxePcdGet64 (
-  IN UINTN  TokenNumber
+  IN UINTN                     TokenNumber
   )
 {
-  return DxePcdGet32Ex (NULL, TokenNumber);
+  return ReadUnaligned64(GetWorker (TokenNumber, sizeof (UINT64)));
 }
 
 
@@ -146,10 +155,10 @@ DxePcdGet64 (
 VOID *
 EFIAPI
 DxePcdGetPtr (
-  IN UINTN  TokenNumber
+  IN UINTN                     TokenNumber
   )
 {
-  return DxePcdGetPtrEx (NULL, TokenNumber);
+  return GetWorker (TokenNumber, 0);
 }
 
 
@@ -157,10 +166,10 @@ DxePcdGetPtr (
 BOOLEAN
 EFIAPI
 DxePcdGetBool (
-  IN UINTN  TokenNumber
+  IN UINTN                     TokenNumber
   )
 {
-  return DxePcdGetBoolEx (NULL, TokenNumber);
+  return *((BOOLEAN *) GetWorker (TokenNumber, sizeof (BOOLEAN)));
 }
 
 
@@ -168,10 +177,53 @@ DxePcdGetBool (
 UINTN
 EFIAPI
 DxePcdGetSize (
-  IN UINTN  TokenNumber
+  IN UINTN                     TokenNumber
   )
 {
-  return  DxePcdGetSizeEx (NULL, TokenNumber);
+  UINTN   Size;
+  UINT32  *LocalTokenNumberTable;
+  BOOLEAN IsPeiDb;
+  UINTN   MaxSize;
+  UINTN   TmpTokenNumber;
+  //
+  // TokenNumber Zero is reserved as PCD_INVALID_TOKEN_NUMBER.
+  // We have to decrement TokenNumber by 1 to make it usable
+  // as the array index.
+  //
+  TokenNumber--;
+
+  //
+  // Backup the TokenNumber passed in as GetPtrTypeSize need the original TokenNumber
+  // 
+  TmpTokenNumber = TokenNumber;
+
+  // EBC compiler is very choosy. It may report warning about comparison
+  // between UINTN and 0 . So we add 1 in each size of the 
+  // comparison.
+  ASSERT (TokenNumber + 1 < PCD_TOTAL_TOKEN_NUMBER + 1);
+
+  // EBC compiler is very choosy. It may report warning about comparison
+  // between UINTN and 0 . So we add 1 in each size of the 
+  // comparison.
+  IsPeiDb = (BOOLEAN) (TokenNumber + 1 < PEI_LOCAL_TOKEN_NUMBER + 1);
+  
+  TokenNumber = IsPeiDb ? TokenNumber : 
+                          (TokenNumber - PEI_LOCAL_TOKEN_NUMBER);
+
+  LocalTokenNumberTable = IsPeiDb ? mPcdDatabase->PeiDb.Init.LocalTokenNumberTable 
+                                  : mPcdDatabase->DxeDb.Init.LocalTokenNumberTable;
+
+  Size = (LocalTokenNumberTable[TokenNumber] & PCD_DATUM_TYPE_ALL_SET) >> PCD_DATUM_TYPE_SHIFT;
+
+  if (Size == 0) {
+    //
+    // For pointer type, we need to scan the SIZE_TABLE to get the current size.
+    //
+    return GetPtrTypeSize (TmpTokenNumber, &MaxSize);
+  } else {
+    return Size;
+  }
+
 }
 
 
@@ -179,15 +231,11 @@ DxePcdGetSize (
 UINT8
 EFIAPI
 DxePcdGet8Ex (
-  IN CONST EFI_GUID        *Guid,
-  IN UINTN  TokenNumber
+  IN CONST EFI_GUID         *Guid,
+  IN UINTN                 ExTokenNumber
   )
 {
-  UINT8 Data;
-
-  DxeGetPcdEntryWorker (TokenNumber, Guid, PcdByte8, &Data);
-
-  return Data;
+  return *((UINT8 *) ExGetWorker (Guid, ExTokenNumber, sizeof(UINT8)));
 }
 
 
@@ -196,14 +244,10 @@ UINT16
 EFIAPI
 DxePcdGet16Ex (
   IN CONST EFI_GUID        *Guid,
-  IN UINTN  TokenNumber
+  IN UINTN                ExTokenNumber
   )
 {
-  UINT16 Data;
-
-  DxeGetPcdEntryWorker (TokenNumber, Guid, PcdByte16, &Data);
-
-  return Data;
+  return ReadUnaligned16 (ExGetWorker (Guid, ExTokenNumber, sizeof(UINT16)));
 }
 
 
@@ -212,14 +256,10 @@ UINT32
 EFIAPI
 DxePcdGet32Ex (
   IN CONST EFI_GUID        *Guid,
-  IN UINTN  TokenNumber
+  IN UINTN                 ExTokenNumber
   )
 {
-  UINT32 Data;
-
-  DxeGetPcdEntryWorker (TokenNumber, Guid, PcdByte32, &Data);
-
-  return Data;
+  return ReadUnaligned32 (ExGetWorker (Guid, ExTokenNumber, sizeof(UINT32)));
 }
 
 
@@ -228,14 +268,10 @@ UINT64
 EFIAPI
 DxePcdGet64Ex (
   IN CONST EFI_GUID        *Guid,
-  IN UINTN  TokenNumber
+  IN UINTN                 ExTokenNumber
   )
 {
-  UINT64 Data;
-
-  DxeGetPcdEntryWorker (TokenNumber, Guid, PcdByte64, &Data);
-
-  return Data;
+  return ReadUnaligned64 (ExGetWorker (Guid, ExTokenNumber, sizeof(UINT64)));
 }
 
 
@@ -244,14 +280,10 @@ VOID *
 EFIAPI
 DxePcdGetPtrEx (
   IN CONST EFI_GUID        *Guid,
-  IN UINTN  TokenNumber
+  IN UINTN                 ExTokenNumber
   )
 {
-  VOID *Data;
-
-  DxeGetPcdEntryWorker (TokenNumber, Guid, PcdPointer, &Data);
-
-  return Data;
+  return  ExGetWorker (Guid, ExTokenNumber, 0);
 }
 
 
@@ -260,12 +292,10 @@ BOOLEAN
 EFIAPI
 DxePcdGetBoolEx (
   IN CONST EFI_GUID        *Guid,
-  IN UINTN  TokenNumber
+  IN UINTN                 ExTokenNumber
   )
 {
-  BOOLEAN Data;
-  DxeGetPcdEntryWorker (TokenNumber, Guid, PcdBoolean, &Data);
-  return Data;
+  return *((BOOLEAN *) ExGetWorker (Guid, ExTokenNumber, sizeof(BOOLEAN)));
 }
 
 
@@ -274,10 +304,10 @@ UINTN
 EFIAPI
 DxePcdGetSizeEx (
   IN CONST EFI_GUID        *Guid,
-  IN UINTN  TokenNumber
+  IN UINTN                 ExTokenNumber
   )
 {
-  return DxeGetPcdEntrySizeWorker (TokenNumber, Guid);
+  return DxePcdGetSize(GetExPcdTokenNumber (Guid, (UINT32) ExTokenNumber));
 }
 
 
@@ -285,11 +315,11 @@ DxePcdGetSizeEx (
 EFI_STATUS
 EFIAPI
 DxePcdSet8 (
-  IN UINTN  TokenNumber,
-  IN UINT8             Value
+  IN UINTN              TokenNumber,
+  IN UINT8              Value
   )
 {
-  return DxePcdSet8Ex (NULL, TokenNumber, Value);
+  return SetValueWorker (TokenNumber, &Value, sizeof (Value));
 }
 
 
@@ -297,11 +327,11 @@ DxePcdSet8 (
 EFI_STATUS
 EFIAPI
 DxePcdSet16 (
-  IN UINTN  TokenNumber,
+  IN UINTN              TokenNumber,
   IN UINT16             Value
   )
 {
-  return DxePcdSet16Ex (NULL, TokenNumber, Value);
+  return SetValueWorker (TokenNumber, &Value, sizeof (Value));
 }
 
 
@@ -309,11 +339,11 @@ DxePcdSet16 (
 EFI_STATUS
 EFIAPI
 DxePcdSet32 (
-  IN UINTN  TokenNumber,
+  IN UINTN              TokenNumber,
   IN UINT32             Value
   )
 {
-  return DxePcdSet32Ex (NULL, TokenNumber, Value);
+  return SetValueWorker (TokenNumber, &Value, sizeof (Value));
 }
 
 
@@ -321,11 +351,11 @@ DxePcdSet32 (
 EFI_STATUS
 EFIAPI
 DxePcdSet64 (
-  IN UINTN  TokenNumber,
-  IN UINT64            Value
+  IN UINTN              TokenNumber,
+  IN UINT64             Value
   )
 {
-  return DxePcdSet64Ex (NULL, TokenNumber, Value);
+  return SetValueWorker (TokenNumber, &Value, sizeof (Value));
 }
 
 
@@ -333,11 +363,12 @@ DxePcdSet64 (
 EFI_STATUS
 EFIAPI
 DxePcdSetPtr (
-  IN UINTN  TokenNumber,
-  IN CONST VOID        *Value
+  IN          UINTN              TokenNumber,
+  IN OUT      UINTN              *SizeOfBuffer,
+  IN          VOID               *Buffer
   )
 {
-  return DxePcdSetPtrEx (NULL, TokenNumber, Value);
+  return SetWorker (TokenNumber, Buffer, SizeOfBuffer, TRUE);
 }
 
 
@@ -345,11 +376,11 @@ DxePcdSetPtr (
 EFI_STATUS
 EFIAPI
 DxePcdSetBool (
-  IN UINTN  TokenNumber,
-  IN BOOLEAN           Value
+  IN UINTN              TokenNumber,
+  IN BOOLEAN            Value
   )
 {
-  return DxePcdSetBoolEx (NULL, TokenNumber, Value);
+  return SetValueWorker (TokenNumber, &Value, sizeof (Value));
 }
 
 
@@ -357,12 +388,12 @@ DxePcdSetBool (
 EFI_STATUS
 EFIAPI
 DxePcdSet8Ex (
-  IN CONST EFI_GUID        *Guid,
-  IN UINTN  TokenNumber,
-  IN UINT8             Value
+  IN CONST EFI_GUID         *Guid,
+  IN UINTN                  ExTokenNumber,
+  IN UINT8                  Value
   )
 {
-  return DxeSetPcdEntryWorker (TokenNumber, Guid, PcdByte8, &Value);
+  return  ExSetValueWorker (ExTokenNumber, Guid, &Value, sizeof (Value));
 }
 
 
@@ -370,12 +401,12 @@ DxePcdSet8Ex (
 EFI_STATUS
 EFIAPI
 DxePcdSet16Ex (
-  IN CONST EFI_GUID        *Guid,
-  IN UINTN  TokenNumber,
+  IN CONST EFI_GUID    *Guid,
+  IN UINTN             ExTokenNumber,
   IN UINT16            Value
   )
 {
-  return DxeSetPcdEntryWorker (TokenNumber, Guid, PcdByte16, &Value);
+  return  ExSetValueWorker (ExTokenNumber, Guid, &Value, sizeof (Value));
 }
 
 
@@ -383,12 +414,12 @@ DxePcdSet16Ex (
 EFI_STATUS
 EFIAPI
 DxePcdSet32Ex (
-  IN CONST EFI_GUID        *Guid,
-  IN UINTN  TokenNumber,
+  IN CONST EFI_GUID     *Guid,
+  IN UINTN              ExTokenNumber,
   IN UINT32             Value
   )
 {
-  return DxeSetPcdEntryWorker (TokenNumber, Guid, PcdByte32, &Value);
+  return  ExSetValueWorker (ExTokenNumber, Guid, &Value, sizeof (Value));
 }
 
 
@@ -396,12 +427,12 @@ DxePcdSet32Ex (
 EFI_STATUS
 EFIAPI
 DxePcdSet64Ex (
-  IN CONST EFI_GUID        *Guid,
-  IN UINTN  TokenNumber,
+  IN CONST EFI_GUID    *Guid,
+  IN UINTN             ExTokenNumber,
   IN UINT64            Value
   )
 {
-  return DxeSetPcdEntryWorker (TokenNumber, Guid, PcdByte64, &Value);
+  return  ExSetValueWorker (ExTokenNumber, Guid, &Value, sizeof (Value));
 }
 
 
@@ -409,12 +440,13 @@ DxePcdSet64Ex (
 EFI_STATUS
 EFIAPI
 DxePcdSetPtrEx (
-  IN CONST EFI_GUID        *Guid,
-  IN UINTN  TokenNumber,
-  IN CONST VOID        *Value
+  IN            CONST EFI_GUID         *Guid,
+  IN            UINTN                  ExTokenNumber,
+  IN OUT        UINTN                  *SizeOfBuffer,
+  IN            VOID                   *Buffer
   )
 {
-  return DxeSetPcdEntryWorker (TokenNumber, Guid, PcdPointer, Value);
+  return  ExSetWorker(ExTokenNumber, Guid, Buffer, SizeOfBuffer, TRUE);
 }
 
 
@@ -422,13 +454,12 @@ DxePcdSetPtrEx (
 EFI_STATUS
 EFIAPI
 DxePcdSetBoolEx (
-  IN CONST EFI_GUID        *Guid,
-  IN UINTN  TokenNumber,
+  IN CONST EFI_GUID    *Guid,
+  IN UINTN             ExTokenNumber,
   IN BOOLEAN           Value
   )
 {
-  return DxeSetPcdEntryWorker (TokenNumber, Guid, PcdBoolean, &Value);
-
+  return  ExSetValueWorker (ExTokenNumber, Guid, &Value, sizeof (Value));
 }
 
 
@@ -436,26 +467,52 @@ DxePcdSetBoolEx (
 
 EFI_STATUS
 EFIAPI
-PcdRegisterCallBackOnSet (
-  IN  UINTN        TokenNumber,
-  IN  CONST EFI_GUID              *Guid, OPTIONAL
+DxeRegisterCallBackOnSet (
+  IN  CONST EFI_GUID          *Guid, OPTIONAL
+  IN  UINTN                   TokenNumber,
   IN  PCD_PROTOCOL_CALLBACK   CallBackFunction
   )
 {
-  return DxeRegisterCallBackWorker (TokenNumber, Guid, CallBackFunction, TRUE);
+  EFI_STATUS Status;
+  
+  ASSERT (CallBackFunction != NULL);
+  
+  //
+  // Aquire lock to prevent reentrance from TPL_CALLBACK level
+  //
+  EfiAcquireLock (&mPcdDatabaseLock);
+
+  Status = DxeRegisterCallBackWorker (TokenNumber, Guid, CallBackFunction);
+
+  EfiReleaseLock (&mPcdDatabaseLock);
+  
+  return Status;
 }
 
 
 
 EFI_STATUS
 EFIAPI
-PcdUnRegisterCallBackOnSet (
-  IN  UINTN        TokenNumber,
-  IN  CONST EFI_GUID              *Guid, OPTIONAL
+DxeUnRegisterCallBackOnSet (
+  IN  CONST EFI_GUID          *Guid, OPTIONAL
+  IN  UINTN                   TokenNumber,
   IN  PCD_PROTOCOL_CALLBACK   CallBackFunction
   )
 {
-  return DxeRegisterCallBackWorker (TokenNumber, Guid, CallBackFunction, FALSE);
+  EFI_STATUS Status;
+  
+  ASSERT (CallBackFunction != NULL);
+
+  //
+  // Aquire lock to prevent reentrance from TPL_CALLBACK level
+  //
+  EfiAcquireLock (&mPcdDatabaseLock);
+  
+  Status = DxeUnRegisterCallBackWorker (TokenNumber, Guid, CallBackFunction);
+
+  EfiReleaseLock (&mPcdDatabaseLock);
+  
+  return Status;
 }
 
 
@@ -463,10 +520,203 @@ PcdUnRegisterCallBackOnSet (
 EFI_STATUS
 EFIAPI
 DxePcdGetNextToken (
-  IN CONST EFI_GUID               *Guid, OPTIONAL
-  IN OUT  UINTN    *TokenNumber
+  IN CONST EFI_GUID         *Guid, OPTIONAL
+  IN OUT   UINTN            *TokenNumber
+  )
+{
+  EFI_STATUS          Status;
+
+  if (!FeaturePcdGet (PcdDxePcdDatabaseTraverseEnabled)) {
+    return EFI_UNSUPPORTED;
+  }
+
+  Status = EFI_NOT_FOUND;
+  //
+  // Scan the local token space
+  //
+  if (Guid == NULL) {
+    // EBC compiler is very choosy. It may report warning about comparison
+    // between UINTN and 0 . So we add 1 in each size of the 
+    // comparison.
+    if (((*TokenNumber + 1 > PEI_NEX_TOKEN_NUMBER + 1) && (*TokenNumber + 1 < PEI_LOCAL_TOKEN_NUMBER + 1)) ||
+        ((*TokenNumber + 1 > (PEI_LOCAL_TOKEN_NUMBER + DXE_NEX_TOKEN_NUMBER + 1)))) {
+        return EFI_NOT_FOUND;
+    }
+    
+    (*TokenNumber)++;
+    if ((*TokenNumber + 1 > PEI_NEX_TOKEN_NUMBER + 1) &&
+        (*TokenNumber <= PEI_LOCAL_TOKEN_NUMBER)) {
+      //
+      // The first Non-Ex type Token Number for DXE PCD 
+      // database is PEI_LOCAL_TOKEN_NUMBER
+      //
+      *TokenNumber = PEI_LOCAL_TOKEN_NUMBER;
+    } else if (*TokenNumber + 1 > DXE_NEX_TOKEN_NUMBER + PEI_LOCAL_TOKEN_NUMBER + 1) {
+      *TokenNumber = PCD_INVALID_TOKEN_NUMBER;
+    }
+    return EFI_SUCCESS;
+  }
+
+  if (PEI_EXMAP_TABLE_EMPTY && DXE_EXMAP_TABLE_EMPTY) {
+    *TokenNumber = PCD_INVALID_TOKEN_NUMBER;
+    return EFI_NOT_FOUND;
+  }
+
+  if (!PEI_EXMAP_TABLE_EMPTY) {
+    Status = ExGetNextTokeNumber (
+                        Guid,
+                        TokenNumber,
+                        mPcdDatabase->PeiDb.Init.GuidTable,
+                        sizeof(mPcdDatabase->PeiDb.Init.GuidTable),
+                        mPcdDatabase->PeiDb.Init.ExMapTable,
+                        sizeof(mPcdDatabase->PeiDb.Init.ExMapTable)
+                        );
+  }
+
+  if (Status == EFI_SUCCESS) {
+    return Status;
+  }
+
+  if (!DXE_EXMAP_TABLE_EMPTY) {
+    Status = ExGetNextTokeNumber (
+                        Guid,
+                        TokenNumber,
+                        mPcdDatabase->DxeDb.Init.GuidTable,
+                        sizeof(mPcdDatabase->DxeDb.Init.GuidTable),
+                        mPcdDatabase->DxeDb.Init.ExMapTable,
+                        sizeof(mPcdDatabase->DxeDb.Init.ExMapTable)
+                        );
+  }
+
+  return Status;
+}
+
+
+EFI_GUID **
+GetDistinctTokenSpace (
+  IN OUT    UINTN             *ExMapTableSize,
+  IN        DYNAMICEX_MAPPING *ExMapTable,
+  IN        EFI_GUID          *GuidTable
   )
 {
-  return DxeGetNextTokenWorker (TokenNumber, Guid);
+  EFI_GUID  **DistinctTokenSpace;
+  UINTN     OldGuidIndex;
+  UINTN     TsIdx;
+  UINTN     Idx;
+
+
+  DistinctTokenSpace = AllocateZeroPool (*ExMapTableSize * sizeof (EFI_GUID *));
+  ASSERT (DistinctTokenSpace != NULL);
+
+  TsIdx = 0;
+  OldGuidIndex = ExMapTable[0].ExGuidIndex;
+  DistinctTokenSpace[TsIdx] = &GuidTable[OldGuidIndex];
+  for (Idx = 1; Idx < *ExMapTableSize; Idx++) {
+    if (ExMapTable[Idx].ExGuidIndex != OldGuidIndex) {
+      OldGuidIndex = ExMapTable[Idx].ExGuidIndex;
+      DistinctTokenSpace[++TsIdx] = &GuidTable[OldGuidIndex];
+    }
+  }
+
+  //
+  // The total number of Distinct Token Space
+  // is TsIdx + 1 because we use TsIdx as a index
+  // to the DistinctTokenSpace[]
+  //
+  *ExMapTableSize = TsIdx + 1;
+  return DistinctTokenSpace;
+    
 }
+  
+//
+// Just pre-allocate a memory buffer that is big enough to
+// host all distinct TokenSpace guid in both
+// PEI ExMap and DXE ExMap.
+//
+STATIC EFI_GUID *TmpTokenSpaceBuffer[PEI_EXMAPPING_TABLE_SIZE + DXE_EXMAPPING_TABLE_SIZE] = { 0 };
+
+EFI_STATUS
+EFIAPI
+DxePcdGetNextTokenSpace (
+  IN OUT CONST EFI_GUID               **Guid
+  )
+{
+  UINTN               Idx;
+  UINTN               Idx2;
+  UINTN               Idx3;
+  UINTN               PeiTokenSpaceTableSize;
+  UINTN               DxeTokenSpaceTableSize;
+  EFI_GUID            **PeiTokenSpaceTable;
+  EFI_GUID            **DxeTokenSpaceTable;
+  BOOLEAN             Match;
+
+  if (!FeaturePcdGet (PcdDxePcdDatabaseTraverseEnabled)) {
+    return EFI_UNSUPPORTED;
+  }
+
+  ASSERT (Guid != NULL);
+  
+  if (PEI_EXMAP_TABLE_EMPTY && DXE_EXMAP_TABLE_EMPTY) {
+    if (*Guid != NULL) {
+      return EFI_NOT_FOUND;
+    } else {
+      return EFI_SUCCESS;
+    }
+  }
+  
+  
+  if (TmpTokenSpaceBuffer[0] == NULL) {
+    PeiTokenSpaceTableSize = 0;
+
+    if (!PEI_EXMAP_TABLE_EMPTY) {
+      PeiTokenSpaceTableSize = PEI_EXMAPPING_TABLE_SIZE;
+      PeiTokenSpaceTable = GetDistinctTokenSpace (&PeiTokenSpaceTableSize,
+                            mPcdDatabase->PeiDb.Init.ExMapTable,
+                            mPcdDatabase->PeiDb.Init.GuidTable
+                            );
+      CopyMem (TmpTokenSpaceBuffer, PeiTokenSpaceTable, sizeof (EFI_GUID*) * PeiTokenSpaceTableSize);
+    }
+
+    if (!DXE_EXMAP_TABLE_EMPTY) {
+      DxeTokenSpaceTableSize = DXE_EXMAPPING_TABLE_SIZE;
+      DxeTokenSpaceTable = GetDistinctTokenSpace (&DxeTokenSpaceTableSize,
+                            mPcdDatabase->DxeDb.Init.ExMapTable,
+                            mPcdDatabase->DxeDb.Init.GuidTable
+                            );
+
+      //
+      // Make sure EFI_GUID in DxeTokenSpaceTable does not exist in PeiTokenSpaceTable
+      //
+      for (Idx2 = 0, Idx3 = PeiTokenSpaceTableSize; Idx2 < DxeTokenSpaceTableSize; Idx2++) {
+        Match = FALSE;
+        for (Idx = 0; Idx < PeiTokenSpaceTableSize; Idx++) {
+          if (CompareGuid (TmpTokenSpaceBuffer[Idx], DxeTokenSpaceTable[Idx2])) {
+            Match = TRUE;
+            break;
+          }
+        }
+        if (!Match) {
+          TmpTokenSpaceBuffer[Idx3++] = DxeTokenSpaceTable[Idx2];
+        }
+      }
+    }
+  }
+
+  if (*Guid == NULL) {
+    *Guid = TmpTokenSpaceBuffer[0];
+    return EFI_SUCCESS;
+  }
+  
+  for (Idx = 0; Idx < (PEI_EXMAPPING_TABLE_SIZE + DXE_EXMAPPING_TABLE_SIZE); Idx++) {
+    if(CompareGuid (*Guid, TmpTokenSpaceBuffer[Idx])) {
+      Idx++;
+      *Guid = TmpTokenSpaceBuffer[Idx];
+      return EFI_SUCCESS;
+    }
+  }
+
+  return EFI_NOT_FOUND;
+
+}
+