2 UEFI variable support functions for Firmware Management Protocol based
5 Copyright (c) 2016, Microsoft Corporation. All rights reserved.<BR>
6 Copyright (c) 2018 - 2019, Intel Corporation. All rights reserved.<BR>
8 SPDX-License-Identifier: BSD-2-Clause-Patent
13 #include "VariableSupport.h"
16 Retrieve the value of a 32-bit UEFI Variable specified by VariableName and
17 a GUID of gEfiCallerIdGuid.
19 @param[in] VariableName Pointer to the UEFI Variable name to retrieve.
20 @param[out] Valid Set to TRUE if UEFI Variable is present and the size
21 of the UEFI Variable value is 32-bits. Otherwise
23 @param[out] Value If Valid is set to TRUE, then the 32-bit value of
24 the UEFI Variable. Otherwise 0.
29 IN CHAR16
*VariableName
,
42 Status
= GetVariable2 (
48 if (!EFI_ERROR (Status
) && Size
== sizeof (*Value
) && Buffer
!= NULL
) {
58 Delete the UEFI Variable with name specified by VariableName and GUID of
59 gEfiCallerIdGuid. If the variable can not be deleted, then print a
62 @param[in] VariableName Pointer to the UEFI Variable name to delete.
67 IN CHAR16
*VariableName
74 GetFmpVariable (VariableName
, &Valid
, &Value
);
76 Status
= gRT
->SetVariable (VariableName
, &gEfiCallerIdGuid
, 0, 0, NULL
);
77 if (EFI_ERROR (Status
)) {
78 DEBUG ((DEBUG_ERROR
, "FmpDxe(%s): Failed to delete variable %s. Status = %r\n", mImageIdName
, VariableName
, Status
));
80 DEBUG ((DEBUG_INFO
, "FmpDxe(%s): Deleted variable %s\n", mImageIdName
, VariableName
));
86 Retrieve the FMP Controller State UEFI Variable value. Return NULL if
87 the variable does not exist or if the size of the UEFI Variable is not the
88 size of FMP_CONTROLLER_STATE. The buffer for the UEFI Variable value
89 if allocated using the UEFI Boot Service AllocatePool().
91 @param[in] Private Private context structure for the managed controller.
93 @return Pointer to the allocated FMP Controller State. Returns NULL
94 if the variable does not exist or is a different size than expected.
97 FMP_CONTROLLER_STATE
*
98 GetFmpControllerState (
99 IN FIRMWARE_MANAGEMENT_PRIVATE_DATA
*Private
103 FMP_CONTROLLER_STATE
*FmpControllerState
;
106 FmpControllerState
= NULL
;
108 Status
= GetVariable2 (
109 Private
->FmpStateVariableName
,
111 (VOID
**)&FmpControllerState
,
114 if (EFI_ERROR (Status
) || FmpControllerState
== NULL
) {
115 DEBUG ((DEBUG_ERROR
, "FmpDxe(%s): Failed to get the controller state. Status = %r\n", mImageIdName
, Status
));
117 if (Size
== sizeof (*FmpControllerState
)) {
118 return FmpControllerState
;
120 DEBUG ((DEBUG_ERROR
, "FmpDxe(%s): Getting controller state returned a size different than expected. Size = 0x%x\n", mImageIdName
, Size
));
122 if (FmpControllerState
!= NULL
) {
123 FreePool (FmpControllerState
);
129 Generates a Null-terminated Unicode string UEFI Variable name from a base name
130 and a hardware instance. If the hardware instance value is 0, then the base
131 name is returned. If the hardware instance value is non-zero, then the 64-bit
132 hardware instance value is converted to a 16 character hex string and appended
133 to base name. The UEFI Variable name returned is allocated using the UEFI
134 Boot Service AllocatePool().
136 @param[in] HardwareInstance 64-bit hardware instance value.
137 @param[in] BaseVariableName Null-terminated Unicode string that is the base
138 name of the UEFI Variable.
140 @return Pointer to the allocated UEFI Variable name. Returns NULL if the
141 UEFI Variable can not be allocated.
145 GenerateFmpVariableName (
146 IN UINT64 HardwareInstance
,
147 IN CHAR16
*BaseVariableName
151 CHAR16
*VariableName
;
154 // Allocate Unicode string with room for BaseVariableName and a 16 digit
155 // hexadecimal value for the HardwareInstance value.
157 Size
= StrSize (BaseVariableName
) + 16 * sizeof (CHAR16
);
158 VariableName
= AllocateCopyPool (Size
, BaseVariableName
);
159 if (VariableName
== NULL
) {
160 DEBUG ((DEBUG_ERROR
, "FmpDxe(%s): Failed to generate variable name %s.\n", mImageIdName
, BaseVariableName
));
163 if (HardwareInstance
== 0) {
166 UnicodeValueToStringS (
167 &VariableName
[StrLen(BaseVariableName
)],
169 PREFIX_ZERO
| RADIX_HEX
,
177 Generate the names of the UEFI Variables used to store state information for
178 a managed controller. The UEFI Variables names are a combination of a base
179 name and an optional hardware instance value as a 16 character hex value. If
180 the hardware instance value is 0, then the 16 character hex value is not
181 included. These storage for the UEFI Variable names are allocated using the
182 UEFI Boot Service AllocatePool() and the pointers are stored in the Private.
183 The following are examples of variable names produces for hardware instance
184 value 0 and value 0x1234567812345678.
192 FmpVersion1234567812345678
193 FmpLsv1234567812345678
194 LastAttemptStatus1234567812345678
195 LastAttemptVersion1234567812345678
196 FmpState1234567812345678
198 @param[in,out] Private Private context structure for the managed controller.
201 GenerateFmpVariableNames (
202 IN OUT FIRMWARE_MANAGEMENT_PRIVATE_DATA
*Private
207 FMP_CONTROLLER_STATE FmpControllerState
;
209 if (Private
->VersionVariableName
!= NULL
) {
210 FreePool (Private
->VersionVariableName
);
212 if (Private
->LsvVariableName
!= NULL
) {
213 FreePool (Private
->LsvVariableName
);
215 if (Private
->LastAttemptStatusVariableName
!= NULL
) {
216 FreePool (Private
->LastAttemptStatusVariableName
);
218 if (Private
->LastAttemptVersionVariableName
!= NULL
) {
219 FreePool (Private
->LastAttemptVersionVariableName
);
221 if (Private
->FmpStateVariableName
!= NULL
) {
222 FreePool (Private
->FmpStateVariableName
);
225 Private
->VersionVariableName
= GenerateFmpVariableName (
226 Private
->Descriptor
.HardwareInstance
,
229 Private
->LsvVariableName
= GenerateFmpVariableName (
230 Private
->Descriptor
.HardwareInstance
,
233 Private
->LastAttemptStatusVariableName
= GenerateFmpVariableName (
234 Private
->Descriptor
.HardwareInstance
,
235 VARNAME_LASTATTEMPTSTATUS
237 Private
->LastAttemptVersionVariableName
= GenerateFmpVariableName (
238 Private
->Descriptor
.HardwareInstance
,
239 VARNAME_LASTATTEMPTVERSION
241 Private
->FmpStateVariableName
= GenerateFmpVariableName (
242 Private
->Descriptor
.HardwareInstance
,
246 DEBUG ((DEBUG_INFO
, "FmpDxe(%s): Variable %g %s\n", mImageIdName
, &gEfiCallerIdGuid
, Private
->VersionVariableName
));
247 DEBUG ((DEBUG_INFO
, "FmpDxe(%s): Variable %g %s\n", mImageIdName
, &gEfiCallerIdGuid
, Private
->LsvVariableName
));
248 DEBUG ((DEBUG_INFO
, "FmpDxe(%s): Variable %g %s\n", mImageIdName
, &gEfiCallerIdGuid
, Private
->LastAttemptStatusVariableName
));
249 DEBUG ((DEBUG_INFO
, "FmpDxe(%s): Variable %g %s\n", mImageIdName
, &gEfiCallerIdGuid
, Private
->LastAttemptVersionVariableName
));
250 DEBUG ((DEBUG_INFO
, "FmpDxe(%s): Variable %g %s\n", mImageIdName
, &gEfiCallerIdGuid
, Private
->FmpStateVariableName
));
252 Buffer
= GetFmpControllerState (Private
);
253 if (Buffer
!= NULL
) {
255 // FMP Controller State was found with correct size.
256 // Delete old variables if they exist.
259 DeleteFmpVariable (Private
->VersionVariableName
);
260 DeleteFmpVariable (Private
->LsvVariableName
);
261 DeleteFmpVariable (Private
->LastAttemptStatusVariableName
);
262 DeleteFmpVariable (Private
->LastAttemptVersionVariableName
);
267 // FMP Controller State was either not found or is wrong size.
268 // Create a new FMP Controller State variable with the correct size.
270 DEBUG ((DEBUG_INFO
, "FmpDxe(%s): Create controller state\n", mImageIdName
));
272 Private
->VersionVariableName
,
273 &FmpControllerState
.VersionValid
,
274 &FmpControllerState
.Version
277 Private
->LsvVariableName
,
278 &FmpControllerState
.LsvValid
,
279 &FmpControllerState
.Lsv
282 Private
->LastAttemptStatusVariableName
,
283 &FmpControllerState
.LastAttemptStatusValid
,
284 &FmpControllerState
.LastAttemptStatus
287 Private
->LastAttemptVersionVariableName
,
288 &FmpControllerState
.LastAttemptVersionValid
,
289 &FmpControllerState
.LastAttemptVersion
291 Status
= gRT
->SetVariable (
292 Private
->FmpStateVariableName
,
294 EFI_VARIABLE_NON_VOLATILE
| EFI_VARIABLE_BOOTSERVICE_ACCESS
,
295 sizeof (FmpControllerState
),
298 if (EFI_ERROR (Status
)) {
300 // Failed to create FMP Controller State. In this case, do not
301 // delete the individual variables. They can be used again on next boot
302 // to create the FMP Controller State.
304 DEBUG ((DEBUG_ERROR
, "FmpDxe(%s): Failed to create controller state. Status = %r\n", mImageIdName
, Status
));
306 DeleteFmpVariable (Private
->VersionVariableName
);
307 DeleteFmpVariable (Private
->LsvVariableName
);
308 DeleteFmpVariable (Private
->LastAttemptStatusVariableName
);
309 DeleteFmpVariable (Private
->LastAttemptVersionVariableName
);
314 Returns the value used to fill in the Version field of the
315 EFI_FIRMWARE_IMAGE_DESCRIPTOR structure that is returned by the GetImageInfo()
316 service of the Firmware Management Protocol. The value is read from a UEFI
317 variable. If the UEFI variables does not exist, then a default version value
320 UEFI Variable accessed: GUID = gEfiCallerIdGuid, Name = L"FmpState"
322 @param[in] Private Private context structure for the managed controller.
324 @return The version of the firmware image in the firmware device.
327 GetVersionFromVariable (
328 IN FIRMWARE_MANAGEMENT_PRIVATE_DATA
*Private
331 FMP_CONTROLLER_STATE
*FmpControllerState
;
334 Value
= DEFAULT_VERSION
;
335 FmpControllerState
= GetFmpControllerState (Private
);
336 if (FmpControllerState
!= NULL
) {
337 if (FmpControllerState
->VersionValid
) {
338 Value
= FmpControllerState
->Version
;
339 DEBUG ((DEBUG_INFO
, "FmpDxe(%s): Get variable %g %s Version %08x\n",
342 Private
->FmpStateVariableName
,
346 FreePool (FmpControllerState
);
352 Returns the value used to fill in the LowestSupportedVersion field of the
353 EFI_FIRMWARE_IMAGE_DESCRIPTOR structure that is returned by the GetImageInfo()
354 service of the Firmware Management Protocol. The value is read from a UEFI
355 variable. If the UEFI variables does not exist, then a default lowest
356 supported version value is returned.
358 UEFI Variable accessed: GUID = gEfiCallerIdGuid, Name = L"FmpState"
360 @param[in] Private Private context structure for the managed controller.
362 @return The lowest supported version of the firmware image in the firmware
366 GetLowestSupportedVersionFromVariable (
367 IN FIRMWARE_MANAGEMENT_PRIVATE_DATA
*Private
370 FMP_CONTROLLER_STATE
*FmpControllerState
;
373 Value
= DEFAULT_LOWESTSUPPORTEDVERSION
;
374 FmpControllerState
= GetFmpControllerState (Private
);
375 if (FmpControllerState
!= NULL
) {
376 if (FmpControllerState
->LsvValid
) {
377 Value
= FmpControllerState
->Lsv
;
378 DEBUG ((DEBUG_INFO
, "FmpDxe(%s): Get variable %g %s LowestSupportedVersion %08x\n",
381 Private
->FmpStateVariableName
,
385 FreePool (FmpControllerState
);
391 Returns the value used to fill in the LastAttemptStatus field of the
392 EFI_FIRMWARE_IMAGE_DESCRIPTOR structure that is returned by the GetImageInfo()
393 service of the Firmware Management Protocol. The value is read from a UEFI
394 variable. If the UEFI variables does not exist, then a default last attempt
395 status value is returned.
397 UEFI Variable accessed: GUID = gEfiCallerIdGuid, Name = L"FmpState"
399 @param[in] Private Private context structure for the managed controller.
401 @return The last attempt status value for the most recent capsule update.
404 GetLastAttemptStatusFromVariable (
405 IN FIRMWARE_MANAGEMENT_PRIVATE_DATA
*Private
408 FMP_CONTROLLER_STATE
*FmpControllerState
;
411 Value
= DEFAULT_LASTATTEMPTSTATUS
;
412 FmpControllerState
= GetFmpControllerState (Private
);
413 if (FmpControllerState
!= NULL
) {
414 if (FmpControllerState
->LastAttemptStatusValid
) {
415 Value
= FmpControllerState
->LastAttemptStatus
;
416 DEBUG ((DEBUG_INFO
, "FmpDxe(%s): Get variable %g %s LastAttemptStatus %08x\n",
419 Private
->FmpStateVariableName
,
423 FreePool (FmpControllerState
);
429 Returns the value used to fill in the LastAttemptVersion field of the
430 EFI_FIRMWARE_IMAGE_DESCRIPTOR structure that is returned by the GetImageInfo()
431 service of the Firmware Management Protocol. The value is read from a UEFI
432 variable. If the UEFI variables does not exist, then a default last attempt
433 version value is returned.
435 UEFI Variable accessed: GUID = gEfiCallerIdGuid, Name = L"FmpState"
437 @param[in] Private Private context structure for the managed controller.
439 @return The last attempt version value for the most recent capsule update.
442 GetLastAttemptVersionFromVariable (
443 IN FIRMWARE_MANAGEMENT_PRIVATE_DATA
*Private
446 FMP_CONTROLLER_STATE
*FmpControllerState
;
449 Value
= DEFAULT_LASTATTEMPTVERSION
;
450 FmpControllerState
= GetFmpControllerState (Private
);
451 if (FmpControllerState
!= NULL
) {
452 if (FmpControllerState
->LastAttemptVersionValid
) {
453 Value
= FmpControllerState
->LastAttemptVersion
;
454 DEBUG ((DEBUG_INFO
, "FmpDxe(%s): Get variable %g %s LastAttemptVersion %08x\n",
457 Private
->FmpStateVariableName
,
461 FreePool (FmpControllerState
);
467 Saves the version current of the firmware image in the firmware device to a
470 UEFI Variable accessed: GUID = gEfiCallerIdGuid, Name = L"FmpState"
472 @param[in] Private Private context structure for the managed controller.
473 @param[in] Version The version of the firmware image in the firmware device.
476 SetVersionInVariable (
477 IN FIRMWARE_MANAGEMENT_PRIVATE_DATA
*Private
,
482 FMP_CONTROLLER_STATE
*FmpControllerState
;
485 FmpControllerState
= GetFmpControllerState (Private
);
486 if (FmpControllerState
== NULL
) {
488 // Can not update value if FMP Controller State does not exist.
489 // This variable is guaranteed to be created by GenerateFmpVariableNames().
495 if (!FmpControllerState
->VersionValid
) {
498 if (FmpControllerState
->Version
!= Version
) {
502 DEBUG ((DEBUG_INFO
, "FmpDxe(%s): No need to update controller state. Same value as before.\n", mImageIdName
));
504 FmpControllerState
->VersionValid
= TRUE
;
505 FmpControllerState
->Version
= Version
;
506 Status
= gRT
->SetVariable (
507 Private
->FmpStateVariableName
,
509 EFI_VARIABLE_NON_VOLATILE
| EFI_VARIABLE_BOOTSERVICE_ACCESS
,
510 sizeof (*FmpControllerState
),
513 if (EFI_ERROR (Status
)) {
514 DEBUG ((DEBUG_ERROR
, "FmpDxe(%s): Failed to update controller state. Status = %r\n", mImageIdName
, Status
));
516 DEBUG ((DEBUG_INFO
, "FmpDxe(%s): Set variable %g %s Version %08x\n",
519 Private
->FmpStateVariableName
,
524 FreePool (FmpControllerState
);
528 Saves the lowest supported version current of the firmware image in the
529 firmware device to a UEFI variable.
531 UEFI Variable accessed: GUID = gEfiCallerIdGuid, Name = L"FmpState"
533 @param[in] Private Private context structure for the managed
535 @param[in] LowestSupportedVersion The lowest supported version of the
536 firmware image in the firmware device.
539 SetLowestSupportedVersionInVariable (
540 IN FIRMWARE_MANAGEMENT_PRIVATE_DATA
*Private
,
541 IN UINT32 LowestSupportedVersion
545 FMP_CONTROLLER_STATE
*FmpControllerState
;
548 FmpControllerState
= GetFmpControllerState (Private
);
549 if (FmpControllerState
== NULL
) {
551 // Can not update value if FMP Controller State does not exist.
552 // This variable is guaranteed to be created by GenerateFmpVariableNames().
558 if (!FmpControllerState
->LsvValid
) {
561 if (FmpControllerState
->Lsv
< LowestSupportedVersion
) {
565 DEBUG ((DEBUG_INFO
, "FmpDxe(%s): No need to update controller state. Same value as before.\n", mImageIdName
));
567 FmpControllerState
->LsvValid
= TRUE
;
568 FmpControllerState
->Lsv
= LowestSupportedVersion
;
569 Status
= gRT
->SetVariable (
570 Private
->FmpStateVariableName
,
572 EFI_VARIABLE_NON_VOLATILE
| EFI_VARIABLE_BOOTSERVICE_ACCESS
,
573 sizeof (*FmpControllerState
),
576 if (EFI_ERROR (Status
)) {
577 DEBUG ((DEBUG_ERROR
, "FmpDxe(%s): Failed to update controller state. Status = %r\n", mImageIdName
, Status
));
579 DEBUG ((DEBUG_INFO
, "FmpDxe(%s): Set variable %g %s LowestSupportedVersion %08x\n",
582 Private
->FmpStateVariableName
,
583 LowestSupportedVersion
587 FreePool (FmpControllerState
);
591 Saves the last attempt status value of the most recent FMP capsule update to a
594 UEFI Variable accessed: GUID = gEfiCallerIdGuid, Name = L"FmpState"
596 @param[in] Private Private context structure for the managed
598 @param[in] LastAttemptStatus The last attempt status of the most recent FMP
602 SetLastAttemptStatusInVariable (
603 IN FIRMWARE_MANAGEMENT_PRIVATE_DATA
*Private
,
604 IN UINT32 LastAttemptStatus
608 FMP_CONTROLLER_STATE
*FmpControllerState
;
611 FmpControllerState
= GetFmpControllerState (Private
);
612 if (FmpControllerState
== NULL
) {
614 // Can not update value if FMP Controller State does not exist.
615 // This variable is guaranteed to be created by GenerateFmpVariableNames().
621 if (!FmpControllerState
->LastAttemptStatusValid
) {
624 if (FmpControllerState
->LastAttemptStatus
!= LastAttemptStatus
) {
628 DEBUG ((DEBUG_INFO
, "FmpDxe(%s): No need to update controller state. Same value as before.\n", mImageIdName
));
630 FmpControllerState
->LastAttemptStatusValid
= TRUE
;
631 FmpControllerState
->LastAttemptStatus
= LastAttemptStatus
;
632 Status
= gRT
->SetVariable (
633 Private
->FmpStateVariableName
,
635 EFI_VARIABLE_NON_VOLATILE
| EFI_VARIABLE_BOOTSERVICE_ACCESS
,
636 sizeof (*FmpControllerState
),
639 if (EFI_ERROR (Status
)) {
640 DEBUG ((DEBUG_ERROR
, "FmpDxe(%s): Failed to update controller state. Status = %r\n", mImageIdName
, Status
));
642 DEBUG ((DEBUG_INFO
, "FmpDxe(%s): Set variable %g %s LastAttemptStatus %08x\n",
645 Private
->FmpStateVariableName
,
650 FreePool (FmpControllerState
);
654 Saves the last attempt version value of the most recent FMP capsule update to
657 UEFI Variable accessed: GUID = gEfiCallerIdGuid, Name = L"FmpState"
659 @param[in] Private Private context structure for the managed
661 @param[in] LastAttemptVersion The last attempt version value of the most
662 recent FMP capsule update.
665 SetLastAttemptVersionInVariable (
666 IN FIRMWARE_MANAGEMENT_PRIVATE_DATA
*Private
,
667 IN UINT32 LastAttemptVersion
671 FMP_CONTROLLER_STATE
*FmpControllerState
;
674 FmpControllerState
= GetFmpControllerState (Private
);
675 if (FmpControllerState
== NULL
) {
677 // Can not update value if FMP Controller State does not exist.
678 // This variable is guaranteed to be created by GenerateFmpVariableNames().
684 if (!FmpControllerState
->LastAttemptVersionValid
) {
687 if (FmpControllerState
->LastAttemptVersion
!= LastAttemptVersion
) {
691 DEBUG ((DEBUG_INFO
, "FmpDxe(%s): No need to update controller state. Same value as before.\n", mImageIdName
));
693 FmpControllerState
->LastAttemptVersionValid
= TRUE
;
694 FmpControllerState
->LastAttemptVersion
= LastAttemptVersion
;
695 Status
= gRT
->SetVariable (
696 Private
->FmpStateVariableName
,
698 EFI_VARIABLE_NON_VOLATILE
| EFI_VARIABLE_BOOTSERVICE_ACCESS
,
699 sizeof (*FmpControllerState
),
702 if (EFI_ERROR (Status
)) {
703 DEBUG ((DEBUG_ERROR
, "FmpDxe(%s): Failed to update controller state. Status = %r\n", mImageIdName
, Status
));
705 DEBUG ((DEBUG_INFO
, "FmpDxe(%s): Set variable %g %s LastAttemptVersion %08x\n",
708 Private
->FmpStateVariableName
,
713 FreePool (FmpControllerState
);
717 Attempts to lock a single UEFI Variable propagating the error state of the
718 first lock attempt that fails. Uses gEfiCallerIdGuid as the variable GUID.
720 @param[in] PreviousStatus The previous UEFI Variable lock attempt status.
721 @param[in] VariableLock The EDK II Variable Lock Protocol instance.
722 @param[in] VariableName The name of the UEFI Variable to lock.
724 @retval EFI_SUCCESS The UEFI Variable was locked and the previous variable
725 lock attempt also succeeded.
726 @retval Other The UEFI Variable could not be locked or the previous
727 variable lock attempt failed.
732 IN EFI_STATUS PreviousStatus
,
733 IN EDKII_VARIABLE_LOCK_PROTOCOL
*VariableLock
,
734 IN CHAR16
*VariableName
739 Status
= VariableLock
->RequestToLock (
744 if (!EFI_ERROR (Status
)) {
745 return PreviousStatus
;
748 DEBUG ((DEBUG_ERROR
, "FmpDxe(%s): Failed to lock variable %g %s. Status = %r\n",
755 if (EFI_ERROR (PreviousStatus
)) {
756 return PreviousStatus
;
762 Locks all the UEFI Variables that use gEfiCallerIdGuid of the currently
765 @param[in] Private Private context structure for the managed controller.
767 @retval EFI_SUCCESS All UEFI variables are locked.
768 @retval EFI_UNSUPPORTED Variable Lock Protocol not found.
769 @retval Other One of the UEFI variables could not be locked.
772 LockAllFmpVariables (
773 FIRMWARE_MANAGEMENT_PRIVATE_DATA
*Private
777 EDKII_VARIABLE_LOCK_PROTOCOL
*VariableLock
;
780 Status
= gBS
->LocateProtocol (
781 &gEdkiiVariableLockProtocolGuid
,
783 (VOID
**)&VariableLock
785 if (EFI_ERROR (Status
) || VariableLock
== NULL
) {
786 DEBUG ((DEBUG_ERROR
, "FmpDxe(%s): Failed to locate Variable Lock Protocol (%r).\n", mImageIdName
, Status
));
787 return EFI_UNSUPPORTED
;
790 Status
= EFI_SUCCESS
;
791 Status
= LockFmpVariable (Status
, VariableLock
, Private
->VersionVariableName
);
792 Status
= LockFmpVariable (Status
, VariableLock
, Private
->LsvVariableName
);
793 Status
= LockFmpVariable (Status
, VariableLock
, Private
->LastAttemptStatusVariableName
);
794 Status
= LockFmpVariable (Status
, VariableLock
, Private
->LastAttemptVersionVariableName
);
795 Status
= LockFmpVariable (Status
, VariableLock
, Private
->FmpStateVariableName
);