BootScript.c

Go to the documentation of this file.

 
#include <Library/AcpiPlatformLib.h>
#include <Library/BaseLib.h>             // CpuDeadLoop()
#include <Library/DebugLib.h>            // DEBUG()
#include <Library/MemoryAllocationLib.h> // AllocatePool()
#include <Library/QemuFwCfgS3Lib.h>      // QemuFwCfgS3ScriptSkipBytes()
 
//
// Condensed structure for capturing the fw_cfg operations -- select, skip,
// write -- inherent in executing a QEMU_LOADER_WRITE_POINTER command.
//
typedef struct {
  UINT16    PointerItem;   // resolved from QEMU_LOADER_WRITE_POINTER.PointerFile
  UINT8     PointerSize;   // copied as-is from QEMU_LOADER_WRITE_POINTER
  UINT32    PointerOffset; // copied as-is from QEMU_LOADER_WRITE_POINTER
  UINT64    PointerValue;  // resolved from QEMU_LOADER_WRITE_POINTER.PointeeFile
                           //   and QEMU_LOADER_WRITE_POINTER.PointeeOffset
} CONDENSED_WRITE_POINTER;
 
//
// Context structure to accumulate CONDENSED_WRITE_POINTER objects from
// QEMU_LOADER_WRITE_POINTER commands.
//
// Any pointers in this structure own the pointed-to objects; that is, when the
// context structure is released, all pointed-to objects must be released too.
//
struct S3_CONTEXT {
  CONDENSED_WRITE_POINTER    *WritePointers; // one array element per processed
                                             //   QEMU_LOADER_WRITE_POINTER
                                             //   command
  UINTN                      Allocated;      // number of elements allocated for
                                             //   WritePointers
  UINTN                      Used;           // number of elements populated in
                                             //   WritePointers
};
 
//
// Scratch buffer, allocated in EfiReservedMemoryType type memory, for the ACPI
// S3 Boot Script opcodes to work on.
//
#pragma pack (1)
typedef union {
  UINT64    PointerValue; // filled in from CONDENSED_WRITE_POINTER.PointerValue
} SCRATCH_BUFFER;
#pragma pack ()
 
EFI_STATUS
AllocateS3Context (
  OUT S3_CONTEXT  **S3Context,
  IN  UINTN       WritePointerCount
  )
{
  EFI_STATUS  Status;
  S3_CONTEXT  *Context;
 
  if (WritePointerCount == 0) {
    return EFI_INVALID_PARAMETER;
  }
 
  Context = AllocateZeroPool (sizeof *Context);
  if (Context == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  Context->WritePointers = AllocatePool (
                             WritePointerCount *
                             sizeof *Context->WritePointers
                             );
  if (Context->WritePointers == NULL) {
    Status = EFI_OUT_OF_RESOURCES;
    goto FreeContext;
  }
 
  Context->Allocated = WritePointerCount;
  *S3Context         = Context;
  return EFI_SUCCESS;
 
FreeContext:
  FreePool (Context);
 
  return Status;
}
 
VOID
ReleaseS3Context (
  IN S3_CONTEXT  *S3Context
  )
{
  FreePool (S3Context->WritePointers);
  FreePool (S3Context);
}
 
EFI_STATUS
SaveCondensedWritePointerToS3Context (
  IN OUT S3_CONTEXT  *S3Context,
  IN     UINT16      PointerItem,
  IN     UINT8       PointerSize,
  IN     UINT32      PointerOffset,
  IN     UINT64      PointerValue
  )
{
  CONDENSED_WRITE_POINTER  *Condensed;
 
  if (S3Context->Used == S3Context->Allocated) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  Condensed                = S3Context->WritePointers + S3Context->Used;
  Condensed->PointerItem   = PointerItem;
  Condensed->PointerSize   = PointerSize;
  Condensed->PointerOffset = PointerOffset;
  Condensed->PointerValue  = PointerValue;
  DEBUG ((
    DEBUG_VERBOSE,
    "%a: 0x%04x/[0x%08x+%d] := 0x%Lx (%Lu)\n",
    __func__,
    PointerItem,
    PointerOffset,
    PointerSize,
    PointerValue,
    (UINT64)S3Context->Used
    ));
  ++S3Context->Used;
  return EFI_SUCCESS;
}
 
STATIC
VOID
EFIAPI
AppendFwCfgBootScript (
  IN OUT VOID  *Context               OPTIONAL,
  IN OUT VOID  *ExternalScratchBuffer
  )
{
  S3_CONTEXT      *S3Context;
  SCRATCH_BUFFER  *ScratchBuffer;
  UINTN           Index;
 
  S3Context     = Context;
  ScratchBuffer = ExternalScratchBuffer;
 
  for (Index = 0; Index < S3Context->Used; ++Index) {
    CONST CONDENSED_WRITE_POINTER  *Condensed;
    RETURN_STATUS                  Status;
 
    Condensed = &S3Context->WritePointers[Index];
 
    Status = QemuFwCfgS3ScriptSkipBytes (
               Condensed->PointerItem,
               Condensed->PointerOffset
               );
    if (RETURN_ERROR (Status)) {
      goto FatalError;
    }
 
    ScratchBuffer->PointerValue = Condensed->PointerValue;
    Status                      = QemuFwCfgS3ScriptWriteBytes (-1, Condensed->PointerSize);
    if (RETURN_ERROR (Status)) {
      goto FatalError;
    }
  }
 
  DEBUG ((DEBUG_VERBOSE, "%a: boot script fragment saved\n", __func__));
 
  ReleaseS3Context (S3Context);
  return;
 
FatalError:
  ASSERT (FALSE);
  CpuDeadLoop ();
}
 
EFI_STATUS
TransferS3ContextToBootScript (
  IN S3_CONTEXT  *S3Context
  )
{
  RETURN_STATUS  Status;
 
  if (S3Context->Used == 0) {
    ReleaseS3Context (S3Context);
    return EFI_SUCCESS;
  }
 
  Status = QemuFwCfgS3CallWhenBootScriptReady (
             AppendFwCfgBootScript,
             S3Context,
             sizeof (SCRATCH_BUFFER)
             );
  return (EFI_STATUS)Status;
}