FwVolRead.c

Go to the documentation of this file.

 
#include "DxeMain.h"
#include "FwVolDriver.h"
 
UINT8  mFvAttributes[]  = { 0, 4, 7, 9, 10, 12, 15, 16 };
UINT8  mFvAttributes2[] = { 17, 18, 19, 20, 21, 22, 23, 24 };
 
EFI_FV_FILE_ATTRIBUTES
FfsAttributes2FvFileAttributes (
  IN EFI_FFS_FILE_ATTRIBUTES  FfsAttributes
  )
{
  UINT8                   DataAlignment;
  EFI_FV_FILE_ATTRIBUTES  FileAttribute;
 
  DataAlignment = (UINT8)((FfsAttributes & FFS_ATTRIB_DATA_ALIGNMENT) >> 3);
  ASSERT (DataAlignment < 8);
 
  if ((FfsAttributes & FFS_ATTRIB_DATA_ALIGNMENT_2) != 0) {
    FileAttribute = (EFI_FV_FILE_ATTRIBUTES)mFvAttributes2[DataAlignment];
  } else {
    FileAttribute = (EFI_FV_FILE_ATTRIBUTES)mFvAttributes[DataAlignment];
  }
 
  if ((FfsAttributes & FFS_ATTRIB_FIXED) == FFS_ATTRIB_FIXED) {
    FileAttribute |= EFI_FV_FILE_ATTRIB_FIXED;
  }
 
  return FileAttribute;
}
 
EFI_STATUS
EFIAPI
FvGetNextFile (
  IN CONST   EFI_FIRMWARE_VOLUME2_PROTOCOL  *This,
  IN OUT     VOID                           *Key,
  IN OUT     EFI_FV_FILETYPE                *FileType,
  OUT        EFI_GUID                       *NameGuid,
  OUT        EFI_FV_FILE_ATTRIBUTES         *Attributes,
  OUT        UINTN                          *Size
  )
{
  EFI_STATUS           Status;
  FV_DEVICE            *FvDevice;
  EFI_FV_ATTRIBUTES    FvAttributes;
  EFI_FFS_FILE_HEADER  *FfsFileHeader;
  UINTN                *KeyValue;
  LIST_ENTRY           *Link;
  FFS_FILE_LIST_ENTRY  *FfsFileEntry;
 
  FvDevice = FV_DEVICE_FROM_THIS (This);
 
  Status = FvGetVolumeAttributes (This, &FvAttributes);
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  //
  // Check if read operation is enabled
  //
  if ((FvAttributes & EFI_FV2_READ_STATUS) == 0) {
    return EFI_ACCESS_DENIED;
  }
 
  if (*FileType > EFI_FV_FILETYPE_MM_CORE_STANDALONE) {
    //
    // File type needs to be in 0 - 0x0F
    //
    return EFI_NOT_FOUND;
  }
 
  KeyValue = (UINTN *)Key;
  for ( ; ;) {
    if (*KeyValue == 0) {
      //
      // Search for 1st matching file
      //
      Link = &FvDevice->FfsFileListHeader;
    } else {
      //
      // Key is pointer to FFsFileEntry, so get next one
      //
      Link = (LIST_ENTRY *)(*KeyValue);
    }
 
    if (Link->ForwardLink == &FvDevice->FfsFileListHeader) {
      //
      // Next is end of list so we did not find data
      //
      return EFI_NOT_FOUND;
    }
 
    FfsFileEntry  = (FFS_FILE_LIST_ENTRY *)Link->ForwardLink;
    FfsFileHeader = (EFI_FFS_FILE_HEADER *)FfsFileEntry->FfsHeader;
 
    //
    // remember the key
    //
    *KeyValue = (UINTN)FfsFileEntry;
 
    if (FfsFileHeader->Type == EFI_FV_FILETYPE_FFS_PAD) {
      //
      // we ignore pad files
      //
      continue;
    }
 
    if (*FileType == EFI_FV_FILETYPE_ALL) {
      //
      // Process all file types so we have a match
      //
      break;
    }
 
    if (*FileType == FfsFileHeader->Type) {
      //
      // Found a matching file type
      //
      break;
    }
  }
 
  //
  // Return FileType, NameGuid, and Attributes
  //
  *FileType = FfsFileHeader->Type;
  CopyGuid (NameGuid, &FfsFileHeader->Name);
  *Attributes = FfsAttributes2FvFileAttributes (FfsFileHeader->Attributes);
  if ((FvDevice->FwVolHeader->Attributes & EFI_FVB2_MEMORY_MAPPED) == EFI_FVB2_MEMORY_MAPPED) {
    *Attributes |= EFI_FV_FILE_ATTRIB_MEMORY_MAPPED;
  }
 
  //
  // we need to substract the header size
  //
  if (IS_FFS_FILE2 (FfsFileHeader)) {
    *Size = FFS_FILE2_SIZE (FfsFileHeader) - sizeof (EFI_FFS_FILE_HEADER2);
  } else {
    *Size = FFS_FILE_SIZE (FfsFileHeader) - sizeof (EFI_FFS_FILE_HEADER);
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
FvReadFile (
  IN CONST EFI_FIRMWARE_VOLUME2_PROTOCOL  *This,
  IN CONST EFI_GUID                       *NameGuid,
  IN OUT   VOID                           **Buffer,
  IN OUT   UINTN                          *BufferSize,
  OUT      EFI_FV_FILETYPE                *FoundType,
  OUT      EFI_FV_FILE_ATTRIBUTES         *FileAttributes,
  OUT      UINT32                         *AuthenticationStatus
  )
{
  EFI_STATUS              Status;
  FV_DEVICE               *FvDevice;
  EFI_GUID                SearchNameGuid;
  EFI_FV_FILETYPE         LocalFoundType;
  EFI_FV_FILE_ATTRIBUTES  LocalAttributes;
  UINTN                   FileSize;
  UINT8                   *SrcPtr;
  EFI_FFS_FILE_HEADER     *FfsHeader;
  UINTN                   InputBufferSize;
  UINTN                   WholeFileSize;
 
  if (NameGuid == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  FvDevice = FV_DEVICE_FROM_THIS (This);
 
  //
  // Keep looking until we find the matching NameGuid.
  // The Key is really a FfsFileEntry
  //
  FvDevice->LastKey = 0;
  do {
    LocalFoundType = 0;
    Status         = FvGetNextFile (
                       This,
                       &FvDevice->LastKey,
                       &LocalFoundType,
                       &SearchNameGuid,
                       &LocalAttributes,
                       &FileSize
                       );
    if (EFI_ERROR (Status)) {
      return EFI_NOT_FOUND;
    }
  } while (!CompareGuid (&SearchNameGuid, NameGuid));
 
  //
  // Get a pointer to the header
  //
  FfsHeader = FvDevice->LastKey->FfsHeader;
  if (FvDevice->IsMemoryMapped) {
    //
    // Memory mapped FV has not been cached, so here is to cache by file.
    //
    if (!FvDevice->LastKey->FileCached) {
      //
      // Cache FFS file to memory buffer.
      //
      WholeFileSize = IS_FFS_FILE2 (FfsHeader) ? FFS_FILE2_SIZE (FfsHeader) : FFS_FILE_SIZE (FfsHeader);
      FfsHeader     = AllocateCopyPool (WholeFileSize, FfsHeader);
      if (FfsHeader == NULL) {
        return EFI_OUT_OF_RESOURCES;
      }
 
      //
      // Let FfsHeader in FfsFileEntry point to the cached file buffer.
      //
      FvDevice->LastKey->FfsHeader  = FfsHeader;
      FvDevice->LastKey->FileCached = TRUE;
    }
  }
 
  //
  // Remember callers buffer size
  //
  InputBufferSize = *BufferSize;
 
  //
  // Calculate return values
  //
  *FoundType      = FfsHeader->Type;
  *FileAttributes = FfsAttributes2FvFileAttributes (FfsHeader->Attributes);
  if ((FvDevice->FwVolHeader->Attributes & EFI_FVB2_MEMORY_MAPPED) == EFI_FVB2_MEMORY_MAPPED) {
    *FileAttributes |= EFI_FV_FILE_ATTRIB_MEMORY_MAPPED;
  }
 
  //
  // Inherit the authentication status.
  //
  *AuthenticationStatus = FvDevice->AuthenticationStatus;
  *BufferSize           = FileSize;
 
  if (Buffer == NULL) {
    //
    // If Buffer is NULL, we only want to get the information collected so far
    //
    return EFI_SUCCESS;
  }
 
  //
  // Skip over file header
  //
  if (IS_FFS_FILE2 (FfsHeader)) {
    SrcPtr = ((UINT8 *)FfsHeader) + sizeof (EFI_FFS_FILE_HEADER2);
  } else {
    SrcPtr = ((UINT8 *)FfsHeader) + sizeof (EFI_FFS_FILE_HEADER);
  }
 
  Status = EFI_SUCCESS;
  if (*Buffer == NULL) {
    //
    // Caller passed in a pointer so allocate buffer for them
    //
    *Buffer = AllocatePool (FileSize);
    if (*Buffer == NULL) {
      return EFI_OUT_OF_RESOURCES;
    }
  } else if (FileSize > InputBufferSize) {
    //
    // Callers buffer was not big enough
    //
    Status   = EFI_WARN_BUFFER_TOO_SMALL;
    FileSize = InputBufferSize;
  }
 
  //
  // Copy data into callers buffer
  //
  CopyMem (*Buffer, SrcPtr, FileSize);
 
  return Status;
}
 
EFI_STATUS
EFIAPI
FvReadFileSection (
  IN CONST  EFI_FIRMWARE_VOLUME2_PROTOCOL  *This,
  IN CONST  EFI_GUID                       *NameGuid,
  IN        EFI_SECTION_TYPE               SectionType,
  IN        UINTN                          SectionInstance,
  IN OUT    VOID                           **Buffer,
  IN OUT    UINTN                          *BufferSize,
  OUT       UINT32                         *AuthenticationStatus
  )
{
  EFI_STATUS              Status;
  FV_DEVICE               *FvDevice;
  EFI_FV_FILETYPE         FileType;
  EFI_FV_FILE_ATTRIBUTES  FileAttributes;
  UINTN                   FileSize;
  UINT8                   *FileBuffer;
  FFS_FILE_LIST_ENTRY     *FfsEntry;
 
  if ((NameGuid == NULL) || (Buffer == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  FvDevice = FV_DEVICE_FROM_THIS (This);
 
  //
  // Read the file
  //
  Status = FvReadFile (
             This,
             NameGuid,
             NULL,
             &FileSize,
             &FileType,
             &FileAttributes,
             AuthenticationStatus
             );
  //
  // Get the last key used by our call to FvReadFile as it is the FfsEntry for this file.
  //
  FfsEntry = (FFS_FILE_LIST_ENTRY *)FvDevice->LastKey;
 
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  if (IS_FFS_FILE2 (FfsEntry->FfsHeader)) {
    FileBuffer = ((UINT8 *)FfsEntry->FfsHeader) + sizeof (EFI_FFS_FILE_HEADER2);
  } else {
    FileBuffer = ((UINT8 *)FfsEntry->FfsHeader) + sizeof (EFI_FFS_FILE_HEADER);
  }
 
  //
  // Check to see that the file actually HAS sections before we go any further.
  //
  if (FileType == EFI_FV_FILETYPE_RAW) {
    Status = EFI_NOT_FOUND;
    goto Done;
  }
 
  //
  // Use FfsEntry to cache Section Extraction Protocol Information
  //
  if (FfsEntry->StreamHandle == 0) {
    Status = OpenSectionStream (
               FileSize,
               FileBuffer,
               &FfsEntry->StreamHandle
               );
    if (EFI_ERROR (Status)) {
      goto Done;
    }
  }
 
  //
  // If SectionType == 0 We need the whole section stream
  //
  Status = GetSection (
             FfsEntry->StreamHandle,
             (SectionType == 0) ? NULL : &SectionType,
             NULL,
             (SectionType == 0) ? 0 : SectionInstance,
             Buffer,
             BufferSize,
             AuthenticationStatus,
             FvDevice->IsFfs3Fv
             );
 
  if (!EFI_ERROR (Status)) {
    //
    // Inherit the authentication status.
    //
    *AuthenticationStatus |= FvDevice->AuthenticationStatus;
  }
 
  //
  // Close of stream defered to close of FfsHeader list to allow SEP to cache data
  //
 
Done:
  return Status;
}