1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
|
/** @file
Unit tests of the CpuExceptionHandlerLib.
Copyright (c) 2022, Intel Corporation. All rights reserved.<BR>
SPDX-License-Identifier: BSD-2-Clause-Patent
**/
#include "CpuExceptionHandlerTest.h"
#include <Library/PeimEntryPoint.h>
#include <Library/PeiServicesLib.h>
#include <Library/PeiServicesTablePointerLib.h>
/**
Initialize Bsp Idt with a new Idt table and return the IA32_DESCRIPTOR buffer.
In PEIM, store original PeiServicePointer before new Idt table.
@return Pointer to the allocated IA32_DESCRIPTOR buffer.
**/
VOID *
InitializeBspIdt (
VOID
)
{
UINTN *NewIdtTable;
IA32_DESCRIPTOR *Idtr;
Idtr = AllocateZeroPool (sizeof (IA32_DESCRIPTOR));
ASSERT (Idtr != NULL);
NewIdtTable = AllocateZeroPool (sizeof (IA32_IDT_GATE_DESCRIPTOR) * CPU_INTERRUPT_NUM + sizeof (UINTN));
ASSERT (NewIdtTable != NULL);
//
// Store original PeiServicePointer before new Idt table
//
*NewIdtTable = (UINTN)GetPeiServicesTablePointer ();
NewIdtTable = (UINTN *)((UINTN)NewIdtTable + sizeof (UINTN));
Idtr->Base = (UINTN)NewIdtTable;
Idtr->Limit = (UINT16)(sizeof (IA32_IDT_GATE_DESCRIPTOR) * CPU_INTERRUPT_NUM - 1);
AsmWriteIdtr (Idtr);
return Idtr;
}
/**
Retrieve the number of logical processor in the platform and the number of those logical processors that
are enabled on this boot.
@param[in] MpServices MP_SERVICES structure.
@param[out] NumberOfProcessors 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 processors in the system that are enabled.
@retval EFI_SUCCESS Retrieve the number of logical processor successfully
@retval Others Retrieve the number of logical processor unsuccessfully
**/
EFI_STATUS
MpServicesUnitTestGetNumberOfProcessors (
IN MP_SERVICES MpServices,
OUT UINTN *NumberOfProcessors,
OUT UINTN *NumberOfEnabledProcessors
)
{
return MpServices.Ppi->GetNumberOfProcessors (MpServices.Ppi, NumberOfProcessors, NumberOfEnabledProcessors);
}
/**
Caller gets one enabled AP to execute a caller-provided function.
@param[in] MpServices MP_SERVICES structure.
@param[in] Procedure Pointer to the function to be run on enabled APs of the system.
@param[in] ProcessorNumber The handle number of the AP.
@param[in] TimeoutInMicroSeconds Indicates the time limit in microseconds for APs to return from Procedure,
for blocking mode only. Zero means infinity.
@param[in] ProcedureArgument The parameter passed into Procedure for all APs.
@retval EFI_SUCCESS Caller gets one enabled AP to execute a caller-provided function successfully
@retval Others Caller gets one enabled AP to execute a caller-provided function unsuccessfully
**/
EFI_STATUS
MpServicesUnitTestStartupThisAP (
IN MP_SERVICES MpServices,
IN EFI_AP_PROCEDURE Procedure,
IN UINTN ProcessorNumber,
IN UINTN TimeoutInMicroSeconds,
IN VOID *ProcedureArgument
)
{
return MpServices.Ppi->StartupThisAP (MpServices.Ppi, Procedure, ProcessorNumber, TimeoutInMicroSeconds, ProcedureArgument);
}
/**
Execute a caller provided function on all enabled APs.
@param[in] MpServices MP_SERVICES structure.
@param[in] Procedure Pointer to the function to be run on enabled APs of the system.
@param[in] SingleThread If TRUE, then all the enabled APs execute the function specified by Procedure
one by one, in ascending order of processor handle number.
If FALSE, then all the enabled APs execute the function specified by Procedure
simultaneously.
@param[in] TimeoutInMicroSeconds Indicates the time limit in microseconds for APs to return from Procedure,
for blocking mode only. Zero means infinity.
@param[in] ProcedureArgument The parameter passed into Procedure for all APs.
@retval EFI_SUCCESS Execute a caller provided function on all enabled APs successfully
@retval Others Execute a caller provided function on all enabled APs unsuccessfully
**/
EFI_STATUS
MpServicesUnitTestStartupAllAPs (
IN MP_SERVICES MpServices,
IN EFI_AP_PROCEDURE Procedure,
IN BOOLEAN SingleThread,
IN UINTN TimeoutInMicroSeconds,
IN VOID *ProcedureArgument
)
{
return MpServices.Ppi->StartupAllAPs (MpServices.Ppi, Procedure, SingleThread, TimeoutInMicroSeconds, ProcedureArgument);
}
/**
Get the handle number for the calling processor.
@param[in] MpServices MP_SERVICES structure.
@param[out] ProcessorNumber The handle number for the calling processor.
@retval EFI_SUCCESS Get the handle number for the calling processor successfully.
@retval Others Get the handle number for the calling processor unsuccessfully.
**/
EFI_STATUS
MpServicesUnitTestWhoAmI (
IN MP_SERVICES MpServices,
OUT UINTN *ProcessorNumber
)
{
return MpServices.Ppi->WhoAmI (MpServices.Ppi, ProcessorNumber);
}
/**
Get EFI_PEI_MP_SERVICES2_PPI pointer.
@param[out] MpServices Pointer to the buffer where EFI_PEI_MP_SERVICES2_PPI is stored
@retval EFI_SUCCESS EFI_PEI_MP_SERVICES2_PPI interface is returned
@retval EFI_NOT_FOUND EFI_PEI_MP_SERVICES2_PPI interface is not found
**/
EFI_STATUS
GetMpServices (
OUT MP_SERVICES *MpServices
)
{
return PeiServicesLocatePpi (&gEfiPeiMpServices2PpiGuid, 0, NULL, (VOID **)&MpServices->Ppi);
}
/**
Entry point of CpuExceptionHandlerPeiTest PEIM.
@param[in] FileHandle Handle of the file being invoked.
@param[in] PeiServices Describes the list of possible PEI Services.
@retval EFI_SUCCESS The PEIM executed normally.
**/
EFI_STATUS
EFIAPI
PeiEntryPoint (
IN EFI_PEI_FILE_HANDLE FileHandle,
IN CONST EFI_PEI_SERVICES **PeiServices
)
{
EFI_STATUS Status;
UNIT_TEST_FRAMEWORK_HANDLE Framework;
Framework = NULL;
DEBUG ((DEBUG_INFO, "%a v%a\n", UNIT_TEST_APP_NAME, UNIT_TEST_APP_VERSION));
//
// Start setting up the test framework for running the tests.
//
Status = InitUnitTestFramework (&Framework, UNIT_TEST_APP_NAME, gEfiCallerBaseName, UNIT_TEST_APP_VERSION);
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_ERROR, "Failed in InitUnitTestFramework. Status = %r\n", Status));
goto EXIT;
}
Status = AddCommonTestCase (Framework);
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_ERROR, "Failed in AddCommonTestCase. Status = %r\n", Status));
goto EXIT;
}
//
// Execute the tests.
//
Status = RunAllTestSuites (Framework);
EXIT:
if (Framework) {
FreeUnitTestFramework (Framework);
}
return Status;
}
|
