b3c71b472d
V4 changes include:
1. Serial debug message for different threads when program the register table.
V3 changes include:
1. Use global variable instead of internal function to return string for register type
and dependence type.
2. Add comments for some complicated logic.
V2 changes include:
1. Add more description for the code part which need easy to understand.
2. Refine some code base on feedback for V1 changes.
V1 changes include:
In a system which has multiple cores, current set register value task costs huge times.
After investigation, current set MSR task costs most of the times. Current logic uses
SpinLock to let set MSR task as an single thread task for all cores. Because MSR has
scope attribute which may cause GP fault if multiple APs set MSR at the same time,
current logic use an easiest solution (use SpinLock) to avoid this issue, but it will
cost huge times.
In order to fix this performance issue, new solution will set MSRs base on their scope
attribute. After this, the SpinLock will not needed. Without SpinLock, new issue raised
which is caused by MSR dependence. For example, MSR A depends on MSR B which means MSR A
must been set after MSR B has been set. Also MSR B is package scope level and MSR A is
thread scope level. If system has multiple threads, Thread 1 needs to set the thread level
MSRs and thread 2 needs to set thread and package level MSRs. Set MSRs task for thread 1
and thread 2 like below:
Thread 1 Thread 2
MSR B N Y
MSR A Y Y
If driver don't control execute MSR order, for thread 1, it will execute MSR A first, but
at this time, MSR B not been executed yet by thread 2. system may trig exception at this
time.
In order to fix the above issue, driver introduces semaphore logic to control the MSR
execute sequence. For the above case, a semaphore will be add between MSR A and B for
all threads. Semaphore has scope info for it. The possible scope value is core or package.
For each thread, when it meets a semaphore during it set registers, it will 1) release
semaphore (+1) for each threads in this core or package(based on the scope info for this
semaphore) 2) acquire semaphore (-1) for all the threads in this core or package(based
on the scope info for this semaphore). With these two steps, driver can control MSR
sequence. Sample code logic like below:
//
// First increase semaphore count by 1 for processors in this package.
//
for (ProcessorIndex = 0; ProcessorIndex < PackageThreadsCount ; ProcessorIndex ++) {
LibReleaseSemaphore ((UINT32 *) &SemaphorePtr[PackageOffset + ProcessorIndex]);
}
//
// Second, check whether the count has reach the check number.
//
for (ProcessorIndex = 0; ProcessorIndex < ValidApCount; ProcessorIndex ++) {
LibWaitForSemaphore (&SemaphorePtr[ApOffset]);
}
Platform Requirement:
1. This change requires register MSR setting base on MSR scope info. If still register MSR
for all threads, exception may raised.
Known limitation:
1. Current CpuFeatures driver supports DXE instance and PEI instance. But semaphore logic
requires Aps execute in async mode which is not supported by PEI driver. So CpuFeature
PEI instance not works after this change. We plan to support async mode for PEI in phase
2 for this task.
Cc: Ruiyu Ni <ruiyu.ni@intel.com>
Cc: Laszlo Ersek <lersek@redhat.com>
Contributed-under: TianoCore Contribution Agreement 1.1
Signed-off-by: Eric Dong <eric.dong@intel.com>
Reviewed-by: Ruiyu Ni <ruiyu.ni@intel.com>
230 lines
6.6 KiB
C
230 lines
6.6 KiB
C
/** @file
|
|
CPU Register Table Library definitions.
|
|
|
|
Copyright (c) 2017, Intel Corporation. All rights reserved.<BR>
|
|
This program and the accompanying materials
|
|
are licensed and made available under the terms and conditions of the BSD License
|
|
which accompanies this distribution. The full text of the license may be found at
|
|
http://opensource.org/licenses/bsd-license.php
|
|
|
|
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
|
|
|
**/
|
|
|
|
#ifndef _REGISTER_CPU_FEATURES_H_
|
|
#define _REGISTER_CPU_FEATURES_H_
|
|
|
|
#include <Library/BaseLib.h>
|
|
#include <Library/DebugLib.h>
|
|
#include <Library/PcdLib.h>
|
|
#include <Library/RegisterCpuFeaturesLib.h>
|
|
#include <Library/BaseMemoryLib.h>
|
|
#include <Library/MemoryAllocationLib.h>
|
|
#include <Library/SynchronizationLib.h>
|
|
#include <Library/IoLib.h>
|
|
#include <Library/LocalApicLib.h>
|
|
|
|
#include <AcpiCpuData.h>
|
|
|
|
#define CPU_FEATURE_ENTRY_SIGNATURE SIGNATURE_32 ('C', 'F', 'E', 'S')
|
|
|
|
#define CPU_FEATURE_NAME_SIZE 128
|
|
|
|
typedef struct {
|
|
REGISTER_CPU_FEATURE_INFORMATION CpuInfo;
|
|
UINT8 *FeaturesSupportedMask;
|
|
LIST_ENTRY OrderList;
|
|
} CPU_FEATURES_INIT_ORDER;
|
|
|
|
typedef struct {
|
|
UINT32 Signature;
|
|
LIST_ENTRY Link;
|
|
UINT8 *FeatureMask;
|
|
CHAR8 *FeatureName;
|
|
CPU_FEATURE_GET_CONFIG_DATA GetConfigDataFunc;
|
|
CPU_FEATURE_SUPPORT SupportFunc;
|
|
CPU_FEATURE_INITIALIZE InitializeFunc;
|
|
UINT8 *BeforeFeatureBitMask;
|
|
UINT8 *AfterFeatureBitMask;
|
|
UINT8 *CoreBeforeFeatureBitMask;
|
|
UINT8 *CoreAfterFeatureBitMask;
|
|
UINT8 *PackageBeforeFeatureBitMask;
|
|
UINT8 *PackageAfterFeatureBitMask;
|
|
VOID *ConfigData;
|
|
BOOLEAN BeforeAll;
|
|
BOOLEAN AfterAll;
|
|
} CPU_FEATURES_ENTRY;
|
|
|
|
//
|
|
// Flags used when program the register.
|
|
//
|
|
typedef struct {
|
|
volatile UINTN ConsoleLogLock; // Spinlock used to control console.
|
|
volatile UINTN MemoryMappedLock; // Spinlock used to program mmio
|
|
volatile UINT32 *SemaphoreCount; // Semaphore used to program semaphore.
|
|
} PROGRAM_CPU_REGISTER_FLAGS;
|
|
|
|
typedef struct {
|
|
UINTN FeaturesCount;
|
|
UINT32 BitMaskSize;
|
|
LIST_ENTRY FeatureList;
|
|
|
|
CPU_FEATURES_INIT_ORDER *InitOrder;
|
|
UINT8 *SupportPcd;
|
|
UINT8 *CapabilityPcd;
|
|
UINT8 *ConfigurationPcd;
|
|
UINT8 *SettingPcd;
|
|
|
|
UINT32 NumberOfCpus;
|
|
ACPI_CPU_DATA *AcpiCpuData;
|
|
|
|
CPU_REGISTER_TABLE *RegisterTable;
|
|
CPU_REGISTER_TABLE *PreSmmRegisterTable;
|
|
UINTN BspNumber;
|
|
|
|
PROGRAM_CPU_REGISTER_FLAGS CpuFlags;
|
|
} CPU_FEATURES_DATA;
|
|
|
|
#define CPU_FEATURE_ENTRY_FROM_LINK(a) \
|
|
CR ( \
|
|
(a), \
|
|
CPU_FEATURES_ENTRY, \
|
|
Link, \
|
|
CPU_FEATURE_ENTRY_SIGNATURE \
|
|
)
|
|
|
|
/**
|
|
Worker function to get CPU_FEATURES_DATA pointer.
|
|
|
|
@return Pointer to CPU_FEATURES_DATA.
|
|
**/
|
|
CPU_FEATURES_DATA *
|
|
GetCpuFeaturesData (
|
|
VOID
|
|
);
|
|
|
|
/**
|
|
Worker function to return processor index.
|
|
|
|
@return The processor index.
|
|
**/
|
|
UINTN
|
|
GetProcessorIndex (
|
|
VOID
|
|
);
|
|
|
|
/**
|
|
Gets detailed MP-related information on the requested processor at the
|
|
instant this call is made.
|
|
|
|
@param[in] ProcessorNumber The handle number of processor.
|
|
@param[out] ProcessorInfoBuffer A pointer to the buffer where information for
|
|
the requested processor is deposited.
|
|
|
|
@return Status of MpServices->GetProcessorInfo().
|
|
**/
|
|
EFI_STATUS
|
|
GetProcessorInformation (
|
|
IN UINTN ProcessorNumber,
|
|
OUT EFI_PROCESSOR_INFORMATION *ProcessorInfoBuffer
|
|
);
|
|
|
|
/**
|
|
Worker function to execute a caller provided function on all enabled APs.
|
|
|
|
@param[in] Procedure A pointer to the function to be run on
|
|
enabled APs of the system.
|
|
@param[in] MpEvent A pointer to the event to be used later
|
|
to check whether procedure has done.
|
|
**/
|
|
VOID
|
|
StartupAPsWorker (
|
|
IN EFI_AP_PROCEDURE Procedure,
|
|
IN EFI_EVENT MpEvent
|
|
);
|
|
|
|
/**
|
|
Worker function to retrieve the number of logical processor in the platform.
|
|
|
|
@param[out] NumberOfCpus Pointer to the total number of logical
|
|
processors in the system, including the BSP
|
|
and disabled APs.
|
|
@param[out] NumberOfEnabledProcessors Pointer to the number of enabled logical
|
|
processors that exist in system, including
|
|
the BSP.
|
|
**/
|
|
VOID
|
|
GetNumberOfProcessor (
|
|
OUT UINTN *NumberOfCpus,
|
|
OUT UINTN *NumberOfEnabledProcessors
|
|
);
|
|
|
|
/**
|
|
Worker function to switch the requested AP to be the BSP from that point onward.
|
|
|
|
@param[in] ProcessorNumber The handle number of AP that is to become the new BSP.
|
|
**/
|
|
VOID
|
|
SwitchNewBsp (
|
|
IN UINTN ProcessorNumber
|
|
);
|
|
|
|
/**
|
|
Function that uses DEBUG() macros to display the contents of a a CPU feature bit mask.
|
|
|
|
@param[in] FeatureMask A pointer to the CPU feature bit mask.
|
|
**/
|
|
VOID
|
|
DumpCpuFeatureMask (
|
|
IN UINT8 *FeatureMask
|
|
);
|
|
|
|
/**
|
|
Dump CPU feature name or CPU feature bit mask.
|
|
|
|
@param[in] CpuFeature Pointer to CPU_FEATURES_ENTRY
|
|
**/
|
|
VOID
|
|
DumpCpuFeature (
|
|
IN CPU_FEATURES_ENTRY *CpuFeature
|
|
);
|
|
|
|
/**
|
|
Return feature dependence result.
|
|
|
|
@param[in] CpuFeature Pointer to CPU feature.
|
|
@param[in] Before Check before dependence or after.
|
|
|
|
@retval return the dependence result.
|
|
**/
|
|
CPU_FEATURE_DEPENDENCE_TYPE
|
|
DetectFeatureScope (
|
|
IN CPU_FEATURES_ENTRY *CpuFeature,
|
|
IN BOOLEAN Before
|
|
);
|
|
|
|
/**
|
|
Programs registers for the calling processor.
|
|
|
|
@param[in,out] Buffer The pointer to private data buffer.
|
|
|
|
**/
|
|
VOID
|
|
EFIAPI
|
|
SetProcessorRegister (
|
|
IN OUT VOID *Buffer
|
|
);
|
|
|
|
/**
|
|
Return ACPI_CPU_DATA data.
|
|
|
|
@return Pointer to ACPI_CPU_DATA data.
|
|
**/
|
|
ACPI_CPU_DATA *
|
|
GetAcpiCpuData (
|
|
VOID
|
|
);
|
|
|
|
#endif
|