RamDiskBlockIo.c

Go to the documentation of this file.

 
#include "RamDiskImpl.h"
 
//
// The EFI_BLOCK_IO_PROTOCOL instances that is installed onto the handle
// for newly registered RAM disks
//
EFI_BLOCK_IO_PROTOCOL  mRamDiskBlockIoTemplate = {
  EFI_BLOCK_IO_PROTOCOL_REVISION,
  (EFI_BLOCK_IO_MEDIA *)0,
  RamDiskBlkIoReset,
  RamDiskBlkIoReadBlocks,
  RamDiskBlkIoWriteBlocks,
  RamDiskBlkIoFlushBlocks
};
 
//
// The EFI_BLOCK_IO_PROTOCOL2 instances that is installed onto the handle
// for newly registered RAM disks
//
EFI_BLOCK_IO2_PROTOCOL  mRamDiskBlockIo2Template = {
  (EFI_BLOCK_IO_MEDIA *)0,
  RamDiskBlkIo2Reset,
  RamDiskBlkIo2ReadBlocksEx,
  RamDiskBlkIo2WriteBlocksEx,
  RamDiskBlkIo2FlushBlocksEx
};
 
VOID
RamDiskInitBlockIo (
  IN     RAM_DISK_PRIVATE_DATA  *PrivateData
  )
{
  EFI_BLOCK_IO_PROTOCOL   *BlockIo;
  EFI_BLOCK_IO2_PROTOCOL  *BlockIo2;
  EFI_BLOCK_IO_MEDIA      *Media;
  UINT32                  Remainder;
 
  BlockIo  = &PrivateData->BlockIo;
  BlockIo2 = &PrivateData->BlockIo2;
  Media    = &PrivateData->Media;
 
  CopyMem (BlockIo, &mRamDiskBlockIoTemplate, sizeof (EFI_BLOCK_IO_PROTOCOL));
  CopyMem (BlockIo2, &mRamDiskBlockIo2Template, sizeof (EFI_BLOCK_IO2_PROTOCOL));
 
  BlockIo->Media          = Media;
  BlockIo2->Media         = Media;
  Media->RemovableMedia   = FALSE;
  Media->MediaPresent     = TRUE;
  Media->LogicalPartition = FALSE;
  Media->ReadOnly         = FALSE;
  Media->WriteCaching     = FALSE;
 
  for (Media->BlockSize = RAM_DISK_DEFAULT_BLOCK_SIZE;
       Media->BlockSize >= 1;
       Media->BlockSize = Media->BlockSize >> 1)
  {
    Media->LastBlock = DivU64x32Remainder (PrivateData->Size, Media->BlockSize, &Remainder) - 1;
    if (Remainder == 0) {
      break;
    }
  }
 
  ASSERT (Media->BlockSize != 0);
 
  return;
}
 
EFI_STATUS
EFIAPI
RamDiskBlkIoReset (
  IN EFI_BLOCK_IO_PROTOCOL  *This,
  IN BOOLEAN                ExtendedVerification
  )
{
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
RamDiskBlkIoReadBlocks (
  IN EFI_BLOCK_IO_PROTOCOL  *This,
  IN UINT32                 MediaId,
  IN EFI_LBA                Lba,
  IN UINTN                  BufferSize,
  OUT VOID                  *Buffer
  )
{
  RAM_DISK_PRIVATE_DATA  *PrivateData;
  UINTN                  NumberOfBlocks;
 
  PrivateData = RAM_DISK_PRIVATE_FROM_BLKIO (This);
 
  if (MediaId != PrivateData->Media.MediaId) {
    return EFI_MEDIA_CHANGED;
  }
 
  if (Buffer == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  if (BufferSize == 0) {
    return EFI_SUCCESS;
  }
 
  if ((BufferSize % PrivateData->Media.BlockSize) != 0) {
    return EFI_BAD_BUFFER_SIZE;
  }
 
  if (Lba > PrivateData->Media.LastBlock) {
    return EFI_INVALID_PARAMETER;
  }
 
  NumberOfBlocks = BufferSize / PrivateData->Media.BlockSize;
  if ((Lba + NumberOfBlocks - 1) > PrivateData->Media.LastBlock) {
    return EFI_INVALID_PARAMETER;
  }
 
  CopyMem (
    Buffer,
    (VOID *)(UINTN)(PrivateData->StartingAddr + MultU64x32 (Lba, PrivateData->Media.BlockSize)),
    BufferSize
    );
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
RamDiskBlkIoWriteBlocks (
  IN EFI_BLOCK_IO_PROTOCOL  *This,
  IN UINT32                 MediaId,
  IN EFI_LBA                Lba,
  IN UINTN                  BufferSize,
  IN VOID                   *Buffer
  )
{
  RAM_DISK_PRIVATE_DATA  *PrivateData;
  UINTN                  NumberOfBlocks;
 
  PrivateData = RAM_DISK_PRIVATE_FROM_BLKIO (This);
 
  if (MediaId != PrivateData->Media.MediaId) {
    return EFI_MEDIA_CHANGED;
  }
 
  if (TRUE == PrivateData->Media.ReadOnly) {
    return EFI_WRITE_PROTECTED;
  }
 
  if (Buffer == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  if (BufferSize == 0) {
    return EFI_SUCCESS;
  }
 
  if ((BufferSize % PrivateData->Media.BlockSize) != 0) {
    return EFI_BAD_BUFFER_SIZE;
  }
 
  if (Lba > PrivateData->Media.LastBlock) {
    return EFI_INVALID_PARAMETER;
  }
 
  NumberOfBlocks = BufferSize / PrivateData->Media.BlockSize;
  if ((Lba + NumberOfBlocks - 1) > PrivateData->Media.LastBlock) {
    return EFI_INVALID_PARAMETER;
  }
 
  CopyMem (
    (VOID *)(UINTN)(PrivateData->StartingAddr + MultU64x32 (Lba, PrivateData->Media.BlockSize)),
    Buffer,
    BufferSize
    );
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
RamDiskBlkIoFlushBlocks (
  IN EFI_BLOCK_IO_PROTOCOL  *This
  )
{
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
RamDiskBlkIo2Reset (
  IN EFI_BLOCK_IO2_PROTOCOL  *This,
  IN BOOLEAN                 ExtendedVerification
  )
{
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
RamDiskBlkIo2ReadBlocksEx (
  IN     EFI_BLOCK_IO2_PROTOCOL  *This,
  IN     UINT32                  MediaId,
  IN     EFI_LBA                 Lba,
  IN OUT EFI_BLOCK_IO2_TOKEN     *Token,
  IN     UINTN                   BufferSize,
  OUT VOID                       *Buffer
  )
{
  RAM_DISK_PRIVATE_DATA  *PrivateData;
  EFI_STATUS             Status;
 
  PrivateData = RAM_DISK_PRIVATE_FROM_BLKIO2 (This);
 
  Status = RamDiskBlkIoReadBlocks (
             &PrivateData->BlockIo,
             MediaId,
             Lba,
             BufferSize,
             Buffer
             );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  //
  // If caller's event is given, signal it after the memory read completes.
  //
  if ((Token != NULL) && (Token->Event != NULL)) {
    Token->TransactionStatus = EFI_SUCCESS;
    gBS->SignalEvent (Token->Event);
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
RamDiskBlkIo2WriteBlocksEx (
  IN     EFI_BLOCK_IO2_PROTOCOL  *This,
  IN     UINT32                  MediaId,
  IN     EFI_LBA                 Lba,
  IN OUT EFI_BLOCK_IO2_TOKEN     *Token,
  IN     UINTN                   BufferSize,
  IN     VOID                    *Buffer
  )
{
  RAM_DISK_PRIVATE_DATA  *PrivateData;
  EFI_STATUS             Status;
 
  PrivateData = RAM_DISK_PRIVATE_FROM_BLKIO2 (This);
 
  Status = RamDiskBlkIoWriteBlocks (
             &PrivateData->BlockIo,
             MediaId,
             Lba,
             BufferSize,
             Buffer
             );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  //
  // If caller's event is given, signal it after the memory write completes.
  //
  if ((Token != NULL) && (Token->Event != NULL)) {
    Token->TransactionStatus = EFI_SUCCESS;
    gBS->SignalEvent (Token->Event);
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
RamDiskBlkIo2FlushBlocksEx (
  IN     EFI_BLOCK_IO2_PROTOCOL  *This,
  IN OUT EFI_BLOCK_IO2_TOKEN     *Token
  )
{
  RAM_DISK_PRIVATE_DATA  *PrivateData;
 
  PrivateData = RAM_DISK_PRIVATE_FROM_BLKIO2 (This);
 
  if (TRUE == PrivateData->Media.ReadOnly) {
    return EFI_WRITE_PROTECTED;
  }
 
  //
  // If caller's event is given, signal it directly.
  //
  if ((Token != NULL) && (Token->Event != NULL)) {
    Token->TransactionStatus = EFI_SUCCESS;
    gBS->SignalEvent (Token->Event);
  }
 
  return EFI_SUCCESS;
}