Add MonotonicCounter driver, which produces MonotonicCounter arch protocols
[mirror_edk2.git] / MdeModulePkg / Universal / MonotonicCounterDxe / MonotonicCounter.c
1 /*++
2
3 Copyright (c) 2006 - 2007, Intel Corporation
4 All rights reserved. This program and the accompanying materials
5 are licensed and made available under the terms and conditions of the BSD License
6 which accompanies this distribution. The full text of the license may be found at
7 http://opensource.org/licenses/bsd-license.php
8
9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
11
12 Module Name:
13
14 MonotonicCounter.c
15
16 Abstract:
17
18 Produced the Monotonic Counter Services as defined in the DXE CIS
19
20 Revision History:
21
22 --*/
23
24 #include "MonotonicCounter.h"
25
26 //
27 // The Monotonic Counter Handle
28 //
29 EFI_HANDLE mMonotonicCounterHandle = NULL;
30
31 //
32 // The current Monotonic count value
33 //
34 UINT64 mEfiMtc;
35
36 //
37 // Event to use to update the Mtc's high part when wrapping
38 //
39 EFI_EVENT mEfiMtcEvent;
40
41 //
42 // EfiMtcName - Variable name of the MTC value
43 //
44 CHAR16 *mEfiMtcName = (CHAR16 *) L"MTC";
45
46 //
47 // EfiMtcGuid - Guid of the MTC value
48 //
49 EFI_GUID mEfiMtcGuid = { 0xeb704011, 0x1402, 0x11d3, { 0x8e, 0x77, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b } };
50
51 //
52 // Worker functions
53 //
54 STATIC
55 EFI_STATUS
56 EFIAPI
57 MonotonicCounterDriverGetNextMonotonicCount (
58 OUT UINT64 *Count
59 )
60 /*++
61
62 Routine Description:
63
64 Arguments:
65
66 Returns:
67
68 --*/
69 {
70 EFI_TPL OldTpl;
71
72 //
73 // Can not be called after ExitBootServices()
74 //
75 if (EfiAtRuntime ()) {
76 return EFI_UNSUPPORTED;
77 }
78 //
79 // Check input parameters
80 //
81 if (Count == NULL) {
82 return EFI_INVALID_PARAMETER;
83 }
84 //
85 // Update the monotonic counter with a lock
86 //
87 OldTpl = gBS->RaiseTPL (TPL_HIGH_LEVEL);
88 *Count = mEfiMtc;
89 mEfiMtc++;
90 gBS->RestoreTPL (OldTpl);
91
92 //
93 // If the MSB bit of the low part toggled, then signal that the high
94 // part needs updated now
95 //
96 if ((((UINT32) mEfiMtc) ^ ((UINT32) *Count)) & 0x80000000) {
97 gBS->SignalEvent (mEfiMtcEvent);
98 }
99
100 return EFI_SUCCESS;
101 }
102
103
104 /**
105 Returns the next high 32 bits of the platform's monotonic counter.
106
107 The GetNextHighMonotonicCount() function returns the next high 32 bits
108 of the platform's monotonic counter. The platform's monotonic counter is
109 comprised of two 32 bit quantities: the high 32 bits and the low 32 bits.
110 During boot service time the low 32 bit value is volatile: it is reset to
111 zero on every system reset and is increased by 1 on every call to GetNextMonotonicCount().
112 The high 32 bit value is non-volatile and is increased by 1 whenever the system resets
113 or whenever the low 32 bit count [returned by GetNextMonoticCount()] overflows.
114 The GetNextMonotonicCount() function is only available at boot services time.
115 If the operating system wishes to extend the platform monotonic counter to runtime,
116 it may do so by utilizing GetNextHighMonotonicCount(). To do this, before calling
117 ExitBootServices() the operating system would call GetNextMonotonicCount() to obtain
118 the current platform monotonic count. The operating system would then provide an
119 interface that returns the next count by:
120 Adding 1 to the last count.
121 Before the lower 32 bits of the count overflows, call GetNextHighMonotonicCount().
122 This will increase the high 32 bits of the platform's non-volatile portion of the monotonic
123 count by 1.
124
125 This function may only be called at Runtime.
126
127 @param[out] HighCount Pointer to returned value.
128
129 @retval EFI_INVALID_PARAMETER If HighCount is NULL.
130 @retval EFI_SUCCESS Operation is successful.
131 @retval EFI_OUT_OF_RESOURCES If variable service reports that not enough storage
132 is available to hold the variable and its data.
133 @retval EFI_DEVICE_ERROR The variable could not be saved due to a hardware failure.
134
135 **/
136 STATIC
137 EFI_STATUS
138 EFIAPI
139 MonotonicCounterDriverGetNextHighMonotonicCount (
140 OUT UINT32 *HighCount
141 )
142 /*++
143
144 Routine Description:
145
146 Arguments:
147
148 Returns:
149
150 --*/
151 {
152 EFI_TPL OldTpl;
153
154 //
155 // Check input parameters
156 //
157 if (HighCount == NULL) {
158 return EFI_INVALID_PARAMETER;
159 }
160
161 if (!EfiAtRuntime ()) {
162 //
163 // Use a lock if called before ExitBootServices()
164 //
165 OldTpl = gBS->RaiseTPL (TPL_HIGH_LEVEL);
166 *HighCount = (UINT32) RShiftU64 (mEfiMtc, 32) + 1;
167 mEfiMtc = LShiftU64 (*HighCount, 32);
168 gBS->RestoreTPL (OldTpl);
169 } else {
170 *HighCount = (UINT32) RShiftU64 (mEfiMtc, 32) + 1;
171 mEfiMtc = LShiftU64 (*HighCount, 32);
172 }
173 //
174 // Update the NvRam store to match the new high part
175 //
176 return EfiSetVariable (
177 mEfiMtcName,
178 &mEfiMtcGuid,
179 EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS,
180 sizeof (UINT32),
181 HighCount
182 );
183
184 }
185
186 STATIC
187 VOID
188 EFIAPI
189 EfiMtcEventHandler (
190 IN EFI_EVENT Event,
191 IN VOID *Context
192 )
193 /*++
194
195 Routine Description:
196
197 Monotonic count event handler. This handler updates the high monotonic count.
198
199 Arguments:
200
201 Event The event to handle
202 Context The event context
203
204 Returns:
205
206 EFI_SUCCESS The event has been handled properly
207 EFI_NOT_FOUND An error occurred updating the variable.
208
209 --*/
210 {
211 UINT32 HighCount;
212
213 MonotonicCounterDriverGetNextHighMonotonicCount (&HighCount);
214 }
215
216 EFI_STATUS
217 EFIAPI
218 MonotonicCounterDriverInitialize (
219 IN EFI_HANDLE ImageHandle,
220 IN EFI_SYSTEM_TABLE *SystemTable
221 )
222 /*++
223
224 Routine Description:
225
226 Arguments:
227 (Standard EFI Image entry - EFI_IMAGE_ENTRY_POINT)
228
229 Returns:
230
231 --*/
232 {
233 EFI_STATUS Status;
234 UINT32 HighCount;
235 UINTN BufferSize;
236
237 //
238 // Make sure the Monotonic Counter Architectural Protocol is not already installed in the system
239 //
240 ASSERT_PROTOCOL_ALREADY_INSTALLED (NULL, &gEfiMonotonicCounterArchProtocolGuid);
241
242 //
243 // Initialize event to handle overflows
244 //
245 Status = gBS->CreateEvent (
246 EVT_NOTIFY_SIGNAL,
247 TPL_CALLBACK,
248 EfiMtcEventHandler,
249 NULL,
250 &mEfiMtcEvent
251 );
252
253 ASSERT_EFI_ERROR (Status);
254
255 //
256 // Read the last high part
257 //
258 BufferSize = sizeof (UINT32);
259 Status = EfiGetVariable (
260 mEfiMtcName,
261 &mEfiMtcGuid,
262 NULL,
263 &BufferSize,
264 &HighCount
265 );
266 if (EFI_ERROR (Status)) {
267 HighCount = 0;
268 }
269 //
270 // Set the current value
271 //
272 mEfiMtc = LShiftU64 (HighCount, 32);
273
274 //
275 // Increment the upper 32 bits for this boot
276 // Continue even if it fails. It will only fail if the variable services are
277 // not functional.
278 //
279 Status = MonotonicCounterDriverGetNextHighMonotonicCount (&HighCount);
280
281 //
282 // Fill in the EFI Boot Services and EFI Runtime Services Monotonic Counter Fields
283 //
284 gBS->GetNextMonotonicCount = MonotonicCounterDriverGetNextMonotonicCount;
285 gRT->GetNextHighMonotonicCount = MonotonicCounterDriverGetNextHighMonotonicCount;
286
287 //
288 // Install the Monotonic Counter Architctural Protocol onto a new handle
289 //
290 Status = gBS->InstallMultipleProtocolInterfaces (
291 &mMonotonicCounterHandle,
292 &gEfiMonotonicCounterArchProtocolGuid,
293 NULL,
294 NULL
295 );
296 ASSERT_EFI_ERROR (Status);
297
298 return EFI_SUCCESS;
299 }