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
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
|
/** @file
Debug Print Error Level library instance that provide compatibility with the
"err" shell command. This includes support for the Debug Mask Protocol
supports for global debug print error level mask stored in an EFI Variable.
This library instance only support DXE Phase modules.
Copyright (c) 2011 - 2018, Intel Corporation. All rights reserved.<BR>
SPDX-License-Identifier: BSD-2-Clause-Patent
**/
#include <PiDxe.h>
#include <Library/DebugPrintErrorLevelLib.h>
#include <Library/PcdLib.h>
#include <Library/HobLib.h>
#include <Guid/DebugMask.h>
///
/// Debug Mask Protocol function prototypes
///
/**
Retrieves the current debug print error level mask for a module are returns
it in CurrentDebugMask.
@param This The protocol instance pointer.
@param CurrentDebugMask Pointer to the debug print error level mask that
is returned.
@retval EFI_SUCCESS The current debug print error level mask was
returned in CurrentDebugMask.
@retval EFI_INVALID_PARAMETER CurrentDebugMask is NULL.
@retval EFI_DEVICE_ERROR The current debug print error level mask could
not be retrieved.
**/
EFI_STATUS
EFIAPI
GetDebugMask (
IN EFI_DEBUG_MASK_PROTOCOL *This,
IN OUT UINTN *CurrentDebugMask
);
/**
Sets the current debug print error level mask for a module to the value
specified by NewDebugMask.
@param This The protocol instance pointer.
@param NewDebugMask The new debug print error level mask for this module.
@retval EFI_SUCCESS The current debug print error level mask was
set to the value specified by NewDebugMask.
@retval EFI_DEVICE_ERROR The current debug print error level mask could
not be set to the value specified by NewDebugMask.
**/
EFI_STATUS
EFIAPI
SetDebugMask (
IN EFI_DEBUG_MASK_PROTOCOL *This,
IN UINTN NewDebugMask
);
///
/// Debug Mask Protocol instance
///
EFI_DEBUG_MASK_PROTOCOL mDebugMaskProtocol = {
EFI_DEBUG_MASK_REVISION,
GetDebugMask,
SetDebugMask
};
///
/// Global variable that is set to TRUE after the first attempt is made to
/// retrieve the global error level mask through the EFI Varibale Services.
/// This variable prevents the EFI Variable Services from being called fort
/// every DEBUG() macro.
///
BOOLEAN mGlobalErrorLevelInitialized = FALSE;
///
/// Global variable that contains the current debug error level mask for the
/// module that is using this library instance. This variable is initially
/// set to the PcdDebugPrintErrorLevel value. If the EFI Variable exists that
/// contains the global debug print error level mask, then that overrides the
/// PcdDebugPrintErrorLevel value. The EFI Variable can optionally be
/// discovered via a HOB so early DXE drivers can access the variable. If the
/// Debug Mask Protocol SetDebugMask() service is called, then that overrides
/// the PcdDebugPrintErrorLevel and the EFI Variable setting.
///
UINT32 mDebugPrintErrorLevel = 0;
///
/// Global variable that is used to cache a pointer to the EFI System Table
/// that is required to access the EFI Variable Services to get and set
/// the global debug print error level mask value. The UefiBootServicesTableLib
/// is not used to prevent a circular dependency between these libraries.
///
EFI_SYSTEM_TABLE *mSystemTable = NULL;
/**
The constructor function caches the PCI Express Base Address and creates a
Set Virtual Address Map event to convert physical address to virtual addresses.
@param ImageHandle The firmware allocated handle for the EFI image.
@param SystemTable A pointer to the EFI System Table.
@retval EFI_SUCCESS The constructor completed successfully.
@retval Other value The constructor did not complete successfully.
**/
EFI_STATUS
EFIAPI
DxeDebugPrintErrorLevelLibConstructor (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
{
EFI_STATUS Status;
//
// Initialize the error level mask from PCD setting.
//
mDebugPrintErrorLevel = PcdGet32 (PcdDebugPrintErrorLevel);
//
// Install Debug Mask Protocol onto ImageHandle
//
mSystemTable = SystemTable;
Status = SystemTable->BootServices->InstallMultipleProtocolInterfaces (
&ImageHandle,
&gEfiDebugMaskProtocolGuid,
&mDebugMaskProtocol,
NULL
);
//
// Attempt to retrieve the global debug print error level mask from the EFI Variable
// If the EFI Variable can not be accessed when this module's library constructors are
// executed a HOB can be used to set the global debug print error level. If no value
// was found then the EFI Variable access will be reattempted on every DEBUG() print
// from this module until the EFI Variable services are available.
//
GetDebugPrintErrorLevel ();
return Status;
}
/**
The destructor function frees any allocated buffers and closes the Set Virtual
Address Map event.
@param ImageHandle The firmware allocated handle for the EFI image.
@param SystemTable A pointer to the EFI System Table.
@retval EFI_SUCCESS The destructor completed successfully.
@retval Other value The destructor did not complete successfully.
**/
EFI_STATUS
EFIAPI
DxeDebugPrintErrorLevelLibDestructor (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
{
//
// Uninstall the Debug Mask Protocol from ImageHandle
//
return SystemTable->BootServices->UninstallMultipleProtocolInterfaces (
ImageHandle,
&gEfiDebugMaskProtocolGuid,
&mDebugMaskProtocol,
NULL
);
}
/**
Returns the debug print error level mask for the current module.
@return Debug print error level mask for the current module.
**/
UINT32
EFIAPI
GetDebugPrintErrorLevel (
VOID
)
{
EFI_STATUS Status;
EFI_TPL CurrentTpl;
UINTN Size;
UINTN GlobalErrorLevel;
VOID *Hob;
//
// If the constructor has not been executed yet, then just return the PCD value.
// This case should only occur if debug print is generated by a library
// constructor for this module
//
if (mSystemTable == NULL) {
return PcdGet32 (PcdDebugPrintErrorLevel);
}
//
// Check to see if an attempt has been made to retrieve the global debug print
// error level mask. Since this library instance stores the global debug print
// error level mask in an EFI Variable, the EFI Variable should only be accessed
// once to reduce the overhead of reading the EFI Variable on every debug print
//
if (!mGlobalErrorLevelInitialized) {
//
// Make sure the TPL Level is low enough for EFI Variable Services to be called
//
CurrentTpl = mSystemTable->BootServices->RaiseTPL (TPL_HIGH_LEVEL);
mSystemTable->BootServices->RestoreTPL (CurrentTpl);
if (CurrentTpl <= TPL_CALLBACK) {
//
// Attempt to retrieve the global debug print error level mask from the
// EFI Variable
//
Size = sizeof (GlobalErrorLevel);
Status = mSystemTable->RuntimeServices->GetVariable (
DEBUG_MASK_VARIABLE_NAME,
&gEfiGenericVariableGuid,
NULL,
&Size,
&GlobalErrorLevel
);
if (Status != EFI_NOT_AVAILABLE_YET) {
//
// If EFI Variable Services are available, then set a flag so the EFI
// Variable will not be read again by this module.
//
mGlobalErrorLevelInitialized = TRUE;
if (!EFI_ERROR (Status)) {
//
// If the EFI Varible exists, then set this module's module's mask to
// the global debug print error level mask value.
//
mDebugPrintErrorLevel = (UINT32)GlobalErrorLevel;
}
} else {
//
// If variable services are not yet available optionally get the global
// debug print error level mask from a HOB.
//
Hob = GetFirstGuidHob (&gEfiGenericVariableGuid);
if (Hob != NULL) {
if (GET_GUID_HOB_DATA_SIZE (Hob) == sizeof (UINT32)) {
mDebugPrintErrorLevel = *(UINT32 *)GET_GUID_HOB_DATA (Hob);
mGlobalErrorLevelInitialized = TRUE;
}
}
}
}
}
//
// Return the current mask value for this module.
//
return mDebugPrintErrorLevel;
}
/**
Sets the global debug print error level mask fpr the entire platform.
@param ErrorLevel Global debug print error level
@retval TRUE The debug print error level mask was sucessfully set.
@retval FALSE The debug print error level mask could not be set.
**/
BOOLEAN
EFIAPI
SetDebugPrintErrorLevel (
UINT32 ErrorLevel
)
{
EFI_STATUS Status;
EFI_TPL CurrentTpl;
UINTN Size;
UINTN GlobalErrorLevel;
//
// Make sure the constructor has been executed
//
if (mSystemTable != NULL) {
//
// Make sure the TPL Level is low enough for EFI Variable Services
//
CurrentTpl = mSystemTable->BootServices->RaiseTPL (TPL_HIGH_LEVEL);
mSystemTable->BootServices->RestoreTPL (CurrentTpl);
if (CurrentTpl <= TPL_CALLBACK) {
//
// Attempt to store the global debug print error level mask in an EFI Variable
//
GlobalErrorLevel = (UINTN)ErrorLevel;
Size = sizeof (GlobalErrorLevel);
Status = mSystemTable->RuntimeServices->SetVariable (
DEBUG_MASK_VARIABLE_NAME,
&gEfiGenericVariableGuid,
(EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS),
Size,
&GlobalErrorLevel
);
if (!EFI_ERROR (Status)) {
//
// If the EFI Variable was updated, then update the mask value for this
// module and return TRUE.
//
mGlobalErrorLevelInitialized = TRUE;
mDebugPrintErrorLevel = ErrorLevel;
return TRUE;
}
}
}
//
// Return FALSE since the EFI Variable could not be updated.
//
return FALSE;
}
/**
Retrieves the current debug print error level mask for a module are returns
it in CurrentDebugMask.
@param This The protocol instance pointer.
@param CurrentDebugMask Pointer to the debug print error level mask that
is returned.
@retval EFI_SUCCESS The current debug print error level mask was
returned in CurrentDebugMask.
@retval EFI_INVALID_PARAMETER CurrentDebugMask is NULL.
@retval EFI_DEVICE_ERROR The current debug print error level mask could
not be retrieved.
**/
EFI_STATUS
EFIAPI
GetDebugMask (
IN EFI_DEBUG_MASK_PROTOCOL *This,
IN OUT UINTN *CurrentDebugMask
)
{
if (CurrentDebugMask == NULL) {
return EFI_INVALID_PARAMETER;
}
//
// Retrieve the current debug mask from mDebugPrintErrorLevel
//
*CurrentDebugMask = (UINTN)mDebugPrintErrorLevel;
return EFI_SUCCESS;
}
/**
Sets the current debug print error level mask for a module to the value
specified by NewDebugMask.
@param This The protocol instance pointer.
@param NewDebugMask The new debug print error level mask for this module.
@retval EFI_SUCCESS The current debug print error level mask was
set to the value specified by NewDebugMask.
@retval EFI_DEVICE_ERROR The current debug print error level mask could
not be set to the value specified by NewDebugMask.
**/
EFI_STATUS
EFIAPI
SetDebugMask (
IN EFI_DEBUG_MASK_PROTOCOL *This,
IN UINTN NewDebugMask
)
{
//
// Store the new debug mask into mDebugPrintErrorLevel
//
mDebugPrintErrorLevel = (UINT32)NewDebugMask;
return EFI_SUCCESS;
}
|
