1. According to PI errata 0000840 and PI 1.2c Vol 3 3.2.3, remove description rows...

[mirror_edk2.git] / IntelFrameworkModulePkg / Universal / FirmwareVolume / FwVolDxe / FwVolRead.c

/** @file\r
  Implements functions to read firmware file.\r
\r
  Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>\r
\r
  This program and the accompanying materials\r
  are licensed and made available under the terms and conditions\r
  of the BSD License which accompanies this distribution.  The\r
  full text of the license may be found at\r
  http://opensource.org/licenses/bsd-license.php\r
\r
  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
\r
**/\r
\r
#include "FwVolDriver.h"\r
\r
/**\r
Required Alignment             Alignment Value in FFS         Alignment Value in\r
(bytes)                        Attributes Field               Firmware Volume Interfaces\r
1                                    0                                     0\r
16                                   1                                     4\r
128                                  2                                     7\r
512                                  3                                     9\r
1 KB                                 4                                     10\r
4 KB                                 5                                     12\r
32 KB                                6                                     15\r
64 KB                                7                                     16\r
**/\r
UINT8 mFvAttributes[] = {0, 4, 7, 9, 10, 12, 15, 16};\r
\r
/**\r
  Convert the FFS File Attributes to FV File Attributes.\r
\r
  @param  FfsAttributes              The attributes of UINT8 type.\r
\r
  @return The attributes of EFI_FV_FILE_ATTRIBUTES\r
\r
**/\r
EFI_FV_FILE_ATTRIBUTES\r
FfsAttributes2FvFileAttributes (\r
  IN EFI_FFS_FILE_ATTRIBUTES FfsAttributes\r
  )\r
{\r
  UINT8                     DataAlignment;\r
  EFI_FV_FILE_ATTRIBUTES    FileAttribute;\r
\r
  DataAlignment = (UINT8) ((FfsAttributes & FFS_ATTRIB_DATA_ALIGNMENT) >> 3);\r
  ASSERT (DataAlignment < 8);\r
\r
  FileAttribute = (EFI_FV_FILE_ATTRIBUTES) mFvAttributes[DataAlignment];\r
\r
  if ((FfsAttributes & FFS_ATTRIB_FIXED) == FFS_ATTRIB_FIXED) {\r
    FileAttribute |= EFI_FV_FILE_ATTRIB_FIXED;\r
  }\r
\r
  return FileAttribute;\r
}\r
\r
/**\r
  Given the input key, search for the next matching file in the volume.\r
\r
  @param  This                       Indicates the calling context.\r
  @param  Key                        Key is a pointer to a caller allocated\r
                                     buffer that contains implementation specific\r
                                     data that is used to track where to begin\r
                                     the search for the next file. The size of\r
                                     the buffer must be at least This->KeySize\r
                                     bytes long. To reinitialize the search and\r
                                     begin from the beginning of the firmware\r
                                     volume, the entire buffer must be cleared to\r
                                     zero. Other than clearing the buffer to\r
                                     initiate a new search, the caller must not\r
                                     modify the data in the buffer between calls\r
                                     to GetNextFile().\r
  @param  FileType                   FileType is a pointer to a caller allocated\r
                                     EFI_FV_FILETYPE. The GetNextFile() API can\r
                                     filter it's search for files based on the\r
                                     value of *FileType input. A *FileType input\r
                                     of 0 causes GetNextFile() to search for\r
                                     files of all types.  If a file is found, the\r
                                     file's type is returned in *FileType.\r
                                     *FileType is not modified if no file is\r
                                     found.\r
  @param  NameGuid                   NameGuid is a pointer to a caller allocated\r
                                     EFI_GUID. If a file is found, the file's\r
                                     name is returned in *NameGuid.  *NameGuid is\r
                                     not modified if no file is found.\r
  @param  Attributes                 Attributes is a pointer to a caller\r
                                     allocated EFI_FV_FILE_ATTRIBUTES.  If a file\r
                                     is found, the file's attributes are returned\r
                                     in *Attributes. *Attributes is not modified\r
                                     if no file is found.\r
  @param  Size                       Size is a pointer to a caller allocated\r
                                     UINTN. If a file is found, the file's size\r
                                     is returned in *Size. *Size is not modified\r
                                     if no file is found.\r
\r
  @retval EFI_SUCCESS                Successfully find the file.\r
  @retval EFI_DEVICE_ERROR           Device error.\r
  @retval EFI_ACCESS_DENIED          Fv could not read.\r
  @retval EFI_NOT_FOUND              No matching file found.\r
  @retval EFI_INVALID_PARAMETER      Invalid parameter\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
FvGetNextFile (\r
  IN CONST EFI_FIRMWARE_VOLUME2_PROTOCOL   *This,\r
  IN OUT VOID                       *Key,\r
  IN OUT EFI_FV_FILETYPE            *FileType,\r
  OUT EFI_GUID                      *NameGuid,\r
  OUT EFI_FV_FILE_ATTRIBUTES        *Attributes,\r
  OUT UINTN                         *Size\r
  )\r
{\r
  EFI_STATUS          Status;\r
  FV_DEVICE           *FvDevice;\r
  EFI_FV_ATTRIBUTES   FvAttributes;\r
  EFI_FFS_FILE_HEADER *FfsFileHeader;\r
  UINTN               *KeyValue;\r
  LIST_ENTRY      *Link;\r
  FFS_FILE_LIST_ENTRY *FfsFileEntry;\r
\r
  FvDevice  = FV_DEVICE_FROM_THIS (This);\r
\r
  Status    = This->GetVolumeAttributes (This, &FvAttributes);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  KeyValue      = (UINTN *) Key;\r
  FfsFileHeader = NULL;\r
\r
  //\r
  // Check if read operation is enabled\r
  //\r
  if ((FvAttributes & EFI_FV2_READ_STATUS) == 0) {\r
    return EFI_ACCESS_DENIED;\r
  }\r
\r
  if (*FileType > EFI_FV_FILETYPE_SMM_CORE) {\r
    //\r
    // File type needs to be in 0 - 0x0D\r
    //\r
    return EFI_NOT_FOUND;\r
  }\r
\r
  do {\r
    if (*KeyValue == 0) {\r
      //\r
      // Search for 1st matching file\r
      //\r
      Link = &FvDevice->FfsFileListHeader;\r
      if (Link->ForwardLink == &FvDevice->FfsFileListHeader) {\r
        return EFI_NOT_FOUND;\r
      }\r
\r
      FfsFileEntry  = (FFS_FILE_LIST_ENTRY *) Link->ForwardLink;\r
      FfsFileHeader = (EFI_FFS_FILE_HEADER *) FfsFileEntry->FfsHeader;\r
\r
      //\r
      // remember the key\r
      //\r
      *KeyValue = (UINTN) FfsFileEntry;\r
\r
      //\r
      // we ignore pad files\r
      //\r
      if (FfsFileHeader->Type == EFI_FV_FILETYPE_FFS_PAD) {\r
        continue;\r
      }\r
\r
      if (*FileType == 0) {\r
        break;\r
      }\r
\r
      if (*FileType == FfsFileHeader->Type) {\r
        break;\r
      }\r
\r
    } else {\r
      //\r
      // Getting link from last Ffs\r
      //\r
      Link = (LIST_ENTRY *) (*KeyValue);\r
      if (Link->ForwardLink == &FvDevice->FfsFileListHeader) {\r
        return EFI_NOT_FOUND;\r
      }\r
\r
      FfsFileEntry  = (FFS_FILE_LIST_ENTRY *) Link->ForwardLink;\r
      FfsFileHeader = (EFI_FFS_FILE_HEADER *) FfsFileEntry->FfsHeader;\r
\r
      //\r
      // remember the key\r
      //\r
      *KeyValue = (UINTN) FfsFileEntry;\r
\r
      //\r
      // we ignore pad files\r
      //\r
      if (FfsFileHeader->Type == EFI_FV_FILETYPE_FFS_PAD) {\r
        continue;\r
      }\r
\r
      if (*FileType == EFI_FV_FILETYPE_ALL) {\r
        break;\r
      }\r
\r
      if (*FileType == FfsFileHeader->Type) {\r
        break;\r
      }\r
    }\r
  } while (Link->ForwardLink != &FvDevice->FfsFileListHeader);\r
\r
  //\r
  // Cache this file entry\r
  //\r
  FvDevice->CurrentFfsFile  = FfsFileEntry;\r
\r
  *FileType                 = FfsFileHeader->Type;\r
  CopyGuid (NameGuid, &FfsFileHeader->Name);\r
  *Attributes = FfsAttributes2FvFileAttributes (FfsFileHeader->Attributes);\r
   if ((FvDevice->FwVolHeader->Attributes & EFI_FVB2_MEMORY_MAPPED) == EFI_FVB2_MEMORY_MAPPED) {\r
     *Attributes |= EFI_FV_FILE_ATTRIB_MEMORY_MAPPED;\r
   }\r
\r
  //\r
  // we need to substract the header size\r
  //\r
  if (IS_FFS_FILE2 (FfsFileHeader)) {\r
    *Size = FFS_FILE2_SIZE (FfsFileHeader) - sizeof (EFI_FFS_FILE_HEADER2);\r
  } else {\r
    *Size = FFS_FILE_SIZE (FfsFileHeader) - sizeof (EFI_FFS_FILE_HEADER);\r
  }\r
\r
  if (CompareGuid (&gEfiFirmwareVolumeTopFileGuid, NameGuid)) {\r
    //\r
    // specially deal with VTF file\r
    //\r
    UINT8   *SrcPtr;\r
    UINT32  Tmp;\r
\r
    if (IS_FFS_FILE2 (FfsFileHeader)) {\r
      SrcPtr = ((UINT8 *) FfsFileHeader) + sizeof (EFI_FFS_FILE_HEADER2);\r
    } else {\r
      SrcPtr = ((UINT8 *) FfsFileHeader) + sizeof (EFI_FFS_FILE_HEADER);\r
    }\r
\r
    while (*Size >= 4) {\r
      Tmp = *(UINT32 *) SrcPtr;\r
      if (Tmp == 0) {\r
        SrcPtr += 4;\r
        (*Size) -= 4;\r
      } else {\r
        break;\r
      }\r
    }\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Locates a file in the firmware volume and\r
  copies it to the supplied buffer.\r
\r
  @param  This                       Indicates the calling context.\r
  @param  NameGuid                   Pointer to an EFI_GUID, which is the\r
                                     filename.\r
  @param  Buffer                     Buffer is a pointer to pointer to a buffer\r
                                     in which the file or section contents or are\r
                                     returned.\r
  @param  BufferSize                 BufferSize is a pointer to caller allocated\r
                                     UINTN. On input *BufferSize indicates the\r
                                     size in bytes of the memory region pointed\r
                                     to by Buffer. On output, *BufferSize\r
                                     contains the number of bytes required to\r
                                     read the file.\r
  @param  FoundType                  FoundType is a pointer to a caller allocated\r
                                     EFI_FV_FILETYPE that on successful return\r
                                     from Read() contains the type of file read.\r
                                     This output reflects the file type\r
                                     irrespective of the value of the SectionType\r
                                     input.\r
  @param  FileAttributes             FileAttributes is a pointer to a caller\r
                                     allocated EFI_FV_FILE_ATTRIBUTES.  On\r
                                     successful return from Read(),\r
                                     *FileAttributes contains the attributes of\r
                                     the file read.\r
  @param  AuthenticationStatus       AuthenticationStatus is a pointer to a\r
                                     caller allocated UINTN in which the\r
                                     authentication status is returned.\r
\r
  @retval EFI_SUCCESS                Successfully read to memory buffer.\r
  @retval EFI_WARN_BUFFER_TOO_SMALL  Buffer too small.\r
  @retval EFI_NOT_FOUND              Not found.\r
  @retval EFI_DEVICE_ERROR           Device error.\r
  @retval EFI_ACCESS_DENIED          Could not read.\r
  @retval EFI_INVALID_PARAMETER      Invalid parameter.\r
  @retval EFI_OUT_OF_RESOURCES       Not enough buffer to be allocated.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
FvReadFile (\r
  IN CONST EFI_FIRMWARE_VOLUME2_PROTOCOL   *This,\r
  IN CONST EFI_GUID                       *NameGuid,\r
  IN OUT VOID                       **Buffer,\r
  IN OUT UINTN                      *BufferSize,\r
  OUT EFI_FV_FILETYPE               *FoundType,\r
  OUT EFI_FV_FILE_ATTRIBUTES        *FileAttributes,\r
  OUT UINT32                        *AuthenticationStatus\r
  )\r
{\r
  EFI_STATUS              Status;\r
  FV_DEVICE               *FvDevice;\r
  UINTN                   Key;\r
  EFI_GUID                SearchNameGuid;\r
  EFI_FV_ATTRIBUTES       FvAttributes;\r
  EFI_FV_FILETYPE         LocalFoundType;\r
  EFI_FV_FILE_ATTRIBUTES  LocalAttributes;\r
  UINTN                   FileSize;\r
  UINT8                   *SrcPtr;\r
  FFS_FILE_LIST_ENTRY     *FfsFileEntry;\r
  EFI_FFS_FILE_HEADER     *FfsHeader;\r
  UINT8                   *FileBuffer;\r
\r
  if (NULL == This || NULL == NameGuid) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  FvDevice  = FV_DEVICE_FROM_THIS (This);\r
\r
  Status    = This->GetVolumeAttributes (This, &FvAttributes);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
  //\r
  // First check to see that FV is enabled for reads...\r
  //\r
  if (0 == (FvAttributes & EFI_FV2_READ_STATUS)) {\r
    return EFI_ACCESS_DENIED;\r
  }\r
\r
  FfsHeader = NULL;\r
\r
  //\r
  // Check if the file was read last time.\r
  //\r
  FfsFileEntry = FvDevice->CurrentFfsFile;\r
\r
  if (FfsFileEntry != NULL) {\r
    FfsHeader = (EFI_FFS_FILE_HEADER *) FfsFileEntry->FfsHeader;\r
  }\r
\r
  if ((FfsFileEntry == NULL) || (!CompareGuid (&FfsHeader->Name, NameGuid))) {\r
    //\r
    // If not match or no file cached, search this file\r
    //\r
    Key = 0;\r
    do {\r
      LocalFoundType = 0;\r
      Status = This->GetNextFile (\r
                      This,\r
                      &Key,\r
                      &LocalFoundType,\r
                      &SearchNameGuid,\r
                      &LocalAttributes,\r
                      &FileSize\r
                      );\r
      if (EFI_ERROR (Status)) {\r
        return EFI_NOT_FOUND;\r
      }\r
    } while (!CompareGuid (&SearchNameGuid, NameGuid));\r
\r
    //\r
    // Get file entry\r
    //\r
    FfsFileEntry = (FFS_FILE_LIST_ENTRY *) Key;\r
\r
    //\r
    // Update the cache\r
    //\r
    FvDevice->CurrentFfsFile  = FfsFileEntry;\r
\r
    FfsHeader                 = (EFI_FFS_FILE_HEADER *) FfsFileEntry->FfsHeader;\r
\r
  } else {\r
    //\r
    // Get File Size of the cached file\r
    //\r
    if (IS_FFS_FILE2 (FfsHeader)) {\r
      FileSize = FFS_FILE2_SIZE (FfsHeader) - sizeof (EFI_FFS_FILE_HEADER2);\r
    } else {\r
      FileSize = FFS_FILE_SIZE (FfsHeader) - sizeof (EFI_FFS_FILE_HEADER);\r
    }\r
  }\r
  //\r
  // Get file info\r
  //\r
  *FoundType            = FfsHeader->Type;\r
  *FileAttributes       = FfsAttributes2FvFileAttributes (FfsHeader->Attributes);\r
   if ((FvDevice->FwVolHeader->Attributes & EFI_FVB2_MEMORY_MAPPED) == EFI_FVB2_MEMORY_MAPPED) {\r
     *FileAttributes |= EFI_FV_FILE_ATTRIB_MEMORY_MAPPED;\r
   }\r
  *AuthenticationStatus = 0;\r
\r
  //\r
  // If Buffer is NULL, we only want to get some information\r
  //\r
  if (Buffer == NULL) {\r
    *BufferSize = FileSize;\r
    return EFI_SUCCESS;\r
  }\r
\r
  if (IS_FFS_FILE2 (FfsHeader)) {\r
    SrcPtr = ((UINT8 *) FfsHeader) + sizeof (EFI_FFS_FILE_HEADER2);\r
  } else {\r
    SrcPtr = ((UINT8 *) FfsHeader) + sizeof (EFI_FFS_FILE_HEADER);\r
  }\r
\r
  if (CompareGuid (&gEfiFirmwareVolumeTopFileGuid, NameGuid)) {\r
    //\r
    // specially deal with VTF file\r
    //\r
    UINT32  Tmp;\r
\r
    while (FileSize >= 4) {\r
      Tmp = *(UINT32 *) SrcPtr;\r
      if (Tmp == 0) {\r
        SrcPtr += 4;\r
        FileSize -= 4;\r
      } else {\r
        break;\r
      }\r
    }\r
  }\r
  //\r
  // If we drop out of the above loop, we've found the correct file header...\r
  //\r
  if (*Buffer == NULL) {\r
    FileBuffer = AllocateCopyPool (FileSize, SrcPtr);\r
    if (FileBuffer == NULL) {\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
\r
    *BufferSize = FileSize;\r
    *Buffer     = FileBuffer;\r
\r
    return EFI_SUCCESS;\r
  }\r
  //\r
  // If the user's buffer is smaller than the file size, then copy as much\r
  // as we can and return an appropriate status.\r
  //\r
  if (FileSize > *BufferSize) {\r
    CopyMem (*Buffer, SrcPtr, *BufferSize);\r
    *BufferSize = FileSize;\r
    return EFI_WARN_BUFFER_TOO_SMALL;\r
  }\r
  //\r
  // User's buffer size is ok, so copy the entire file to their buffer.\r
  //\r
  *BufferSize = FileSize;\r
  CopyMem (*Buffer, SrcPtr, *BufferSize);\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Locates a section in a given FFS File and\r
  copies it to the supplied buffer (not including section header).\r
\r
  @param  This                       Indicates the calling context.\r
  @param  NameGuid                   Pointer to an EFI_GUID, which is the\r
                                     filename.\r
  @param  SectionType                Indicates the section type to return.\r
  @param  SectionInstance            Indicates which instance of sections with a\r
                                     type of SectionType to return.\r
  @param  Buffer                     Buffer is a pointer to pointer to a buffer\r
                                     in which the file or section contents or are\r
                                     returned.\r
  @param  BufferSize                 BufferSize is a pointer to caller allocated\r
                                     UINTN.\r
  @param  AuthenticationStatus       AuthenticationStatus is a pointer to a\r
                                     caller allocated UINT32 in which the\r
                                     authentication status is returned.\r
\r
  @retval EFI_SUCCESS                Successfully read the file section into\r
                                     buffer.\r
  @retval EFI_WARN_BUFFER_TOO_SMALL  Buffer too small.\r
  @retval EFI_NOT_FOUND              Section not found.\r
  @retval EFI_DEVICE_ERROR           Device error.\r
  @retval EFI_ACCESS_DENIED          Could not read.\r
  @retval EFI_INVALID_PARAMETER      Invalid parameter.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
FvReadFileSection (\r
  IN CONST EFI_FIRMWARE_VOLUME2_PROTOCOL   *This,\r
  IN CONST EFI_GUID                       *NameGuid,\r
  IN EFI_SECTION_TYPE               SectionType,\r
  IN UINTN                          SectionInstance,\r
  IN OUT VOID                       **Buffer,\r
  IN OUT UINTN                      *BufferSize,\r
  OUT UINT32                        *AuthenticationStatus\r
  )\r
{\r
  EFI_STATUS                      Status;\r
  EFI_FV_ATTRIBUTES               FvAttributes;\r
  EFI_FV_FILETYPE                 FileType;\r
  EFI_FV_FILE_ATTRIBUTES          FileAttributes;\r
  UINTN                           FileSize;\r
  UINT8                           *FileBuffer;\r
  EFI_SECTION_EXTRACTION_PROTOCOL *Sep;\r
  UINTN                           StreamHandle;\r
\r
  if (NULL == This || NULL == NameGuid || Buffer == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  Status    = This->GetVolumeAttributes (This, &FvAttributes);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
  //\r
  // First check to see that FV is enabled for reads...\r
  //\r
  if (0 == (FvAttributes & EFI_FV2_READ_STATUS)) {\r
    return EFI_ACCESS_DENIED;\r
  }\r
  //\r
  // Read the whole file into buffer\r
  //\r
  FileBuffer = NULL;\r
  Status = This->ReadFile (\r
                  This,\r
                  NameGuid,\r
                  (VOID **) &FileBuffer,\r
                  &FileSize,\r
                  &FileType,\r
                  &FileAttributes,\r
                  AuthenticationStatus\r
                  );\r
\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
  //\r
  // Check to see that the file actually HAS sections before we go any further.\r
  //\r
  if (FileType == EFI_FV_FILETYPE_RAW) {\r
    FreePool (FileBuffer);\r
    return EFI_NOT_FOUND;\r
  }\r
  //\r
  // Located the protocol\r
  //\r
  Status = gBS->LocateProtocol (\r
                  &gEfiSectionExtractionProtocolGuid,\r
                  NULL,\r
                  (VOID **) &Sep\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    FreePool (FileBuffer);\r
    return Status;\r
  }\r
\r
  Status = Sep->OpenSectionStream (\r
                  Sep,\r
                  FileSize,\r
                  FileBuffer,\r
                  &StreamHandle\r
                  );\r
\r
  if (EFI_ERROR (Status)) {\r
    FreePool (FileBuffer);\r
    return Status;\r
  }\r
\r
  if (SectionType == 0) {\r
    //\r
    // We need the whole section stream\r
    //\r
    Status = Sep->GetSection (\r
                    Sep,\r
                    StreamHandle,\r
                    NULL,\r
                    NULL,\r
                    0,\r
                    Buffer,\r
                    BufferSize,\r
                    AuthenticationStatus\r
                    );\r
  } else {\r
    Status = Sep->GetSection (\r
                    Sep,\r
                    StreamHandle,\r
                    &SectionType,\r
                    NULL,\r
                    SectionInstance,\r
                    Buffer,\r
                    BufferSize,\r
                    AuthenticationStatus\r
                    );\r
  }\r
  //\r
  // Handle AuthenticationStatus if necessary\r
  //\r
  Sep->CloseSectionStream (Sep, StreamHandle);\r
\r
  FreePool (FileBuffer);\r
\r
  return Status;\r
}\r