MdeModulePkg/Universal/Disk/RamDiskDxe/RamDiskBlockIo.c

   1 /** @file
   2   Produce EFI_BLOCK_IO_PROTOCOL on a RAM disk device.
   3
   4   Copyright (c) 2016 - 2018, Intel Corporation. All rights reserved.<BR>
   5   This program and the accompanying materials
   6   are licensed and made available under the terms and conditions of the BSD License
   7   which accompanies this distribution.  The full text of the license may be found at
   8   http://opensource.org/licenses/bsd-license.php
   9
  10   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13 **/
  14
  15 #include "RamDiskImpl.h"
  16
  17 //
  18 // The EFI_BLOCK_IO_PROTOCOL instances that is installed onto the handle
  19 // for newly registered RAM disks
  20 //
  21 EFI_BLOCK_IO_PROTOCOL  mRamDiskBlockIoTemplate = {
  22   EFI_BLOCK_IO_PROTOCOL_REVISION,
  23   (EFI_BLOCK_IO_MEDIA *) 0,
  24   RamDiskBlkIoReset,
  25   RamDiskBlkIoReadBlocks,
  26   RamDiskBlkIoWriteBlocks,
  27   RamDiskBlkIoFlushBlocks
  28 };
  29
  30 //
  31 // The EFI_BLOCK_IO_PROTOCOL2 instances that is installed onto the handle
  32 // for newly registered RAM disks
  33 //
  34 EFI_BLOCK_IO2_PROTOCOL  mRamDiskBlockIo2Template = {
  35   (EFI_BLOCK_IO_MEDIA *) 0,
  36   RamDiskBlkIo2Reset,
  37   RamDiskBlkIo2ReadBlocksEx,
  38   RamDiskBlkIo2WriteBlocksEx,
  39   RamDiskBlkIo2FlushBlocksEx
  40 };
  41
  42
  43 /**
  44   Initialize the BlockIO & BlockIO2 protocol of a RAM disk device.
  45
  46   @param[in] PrivateData     Points to RAM disk private data.
  47
  48 **/
  49 VOID
  50 RamDiskInitBlockIo (
  51   IN     RAM_DISK_PRIVATE_DATA    *PrivateData
  52   )
  53 {
  54   EFI_BLOCK_IO_PROTOCOL           *BlockIo;
  55   EFI_BLOCK_IO2_PROTOCOL          *BlockIo2;
  56   EFI_BLOCK_IO_MEDIA              *Media;
  57
  58   BlockIo  = &PrivateData->BlockIo;
  59   BlockIo2 = &PrivateData->BlockIo2;
  60   Media    = &PrivateData->Media;
  61
  62   CopyMem (BlockIo, &mRamDiskBlockIoTemplate, sizeof (EFI_BLOCK_IO_PROTOCOL));
  63   CopyMem (BlockIo2, &mRamDiskBlockIo2Template, sizeof (EFI_BLOCK_IO2_PROTOCOL));
  64
  65   BlockIo->Media          = Media;
  66   BlockIo2->Media         = Media;
  67   Media->RemovableMedia   = FALSE;
  68   Media->MediaPresent     = TRUE;
  69   Media->LogicalPartition = FALSE;
  70   Media->ReadOnly         = FALSE;
  71   Media->WriteCaching     = FALSE;
  72   Media->BlockSize        = RAM_DISK_BLOCK_SIZE;
  73   Media->LastBlock        = DivU64x32 (
  74                               PrivateData->Size + RAM_DISK_BLOCK_SIZE - 1,
  75                               RAM_DISK_BLOCK_SIZE
  76                               ) - 1;
  77 }
  78
  79
  80 /**
  81   Reset the Block Device.
  82
  83   @param  This                 Indicates a pointer to the calling context.
  84   @param  ExtendedVerification Driver may perform diagnostics on reset.
  85
  86   @retval EFI_SUCCESS          The device was reset.
  87   @retval EFI_DEVICE_ERROR     The device is not functioning properly and could
  88                                not be reset.
  89
  90 **/
  91 EFI_STATUS
  92 EFIAPI
  93 RamDiskBlkIoReset (
  94   IN EFI_BLOCK_IO_PROTOCOL        *This,
  95   IN BOOLEAN                      ExtendedVerification
  96   )
  97 {
  98   return EFI_SUCCESS;
  99 }
 100
 101
 102 /**
 103   Read BufferSize bytes from Lba into Buffer.
 104
 105   @param[in]  This           Indicates a pointer to the calling context.
 106   @param[in]  MediaId        Id of the media, changes every time the media is
 107                              replaced.
 108   @param[in]  Lba            The starting Logical Block Address to read from.
 109   @param[in]  BufferSize     Size of Buffer, must be a multiple of device block
 110                              size.
 111   @param[out] Buffer         A pointer to the destination buffer for the data.
 112                              The caller is responsible for either having
 113                              implicit or explicit ownership of the buffer.
 114
 115   @retval EFI_SUCCESS             The data was read correctly from the device.
 116   @retval EFI_DEVICE_ERROR        The device reported an error while performing
 117                                   the read.
 118   @retval EFI_NO_MEDIA            There is no media in the device.
 119   @retval EFI_MEDIA_CHANGED       The MediaId does not matched the current
 120                                   device.
 121   @retval EFI_BAD_BUFFER_SIZE     The Buffer was not a multiple of the block
 122                                   size of the device.
 123   @retval EFI_INVALID_PARAMETER   The read request contains LBAs that are not
 124                                   valid, or the buffer is not on proper alignment.
 125
 126 **/
 127 EFI_STATUS
 128 EFIAPI
 129 RamDiskBlkIoReadBlocks (
 130   IN EFI_BLOCK_IO_PROTOCOL        *This,
 131   IN UINT32                       MediaId,
 132   IN EFI_LBA                      Lba,
 133   IN UINTN                        BufferSize,
 134   OUT VOID                        *Buffer
 135   )
 136 {
 137   RAM_DISK_PRIVATE_DATA           *PrivateData;
 138   UINTN                           NumberOfBlocks;
 139
 140   PrivateData = RAM_DISK_PRIVATE_FROM_BLKIO (This);
 141
 142   if (MediaId != PrivateData->Media.MediaId) {
 143     return EFI_MEDIA_CHANGED;
 144   }
 145
 146   if (Buffer == NULL) {
 147     return EFI_INVALID_PARAMETER;
 148   }
 149
 150   if (BufferSize == 0) {
 151     return EFI_SUCCESS;
 152   }
 153
 154   if ((BufferSize % PrivateData->Media.BlockSize) != 0) {
 155     return EFI_BAD_BUFFER_SIZE;
 156   }
 157
 158   if (Lba > PrivateData->Media.LastBlock) {
 159     return EFI_INVALID_PARAMETER;
 160   }
 161
 162   NumberOfBlocks = BufferSize / PrivateData->Media.BlockSize;
 163   if ((Lba + NumberOfBlocks - 1) > PrivateData->Media.LastBlock) {
 164     return EFI_INVALID_PARAMETER;
 165   }
 166
 167   CopyMem (
 168     Buffer,
 169     (VOID *)(UINTN)(PrivateData->StartingAddr + MultU64x32 (Lba, PrivateData->Media.BlockSize)),
 170     BufferSize
 171     );
 172
 173   return EFI_SUCCESS;
 174 }
 175
 176
 177 /**
 178   Write BufferSize bytes from Lba into Buffer.
 179
 180   @param[in] This            Indicates a pointer to the calling context.
 181   @param[in] MediaId         The media ID that the write request is for.
 182   @param[in] Lba             The starting logical block address to be written.
 183                              The caller is responsible for writing to only
 184                              legitimate locations.
 185   @param[in] BufferSize      Size of Buffer, must be a multiple of device block
 186                              size.
 187   @param[in] Buffer          A pointer to the source buffer for the data.
 188
 189   @retval EFI_SUCCESS             The data was written correctly to the device.
 190   @retval EFI_WRITE_PROTECTED     The device can not be written to.
 191   @retval EFI_DEVICE_ERROR        The device reported an error while performing
 192                                   the write.
 193   @retval EFI_NO_MEDIA            There is no media in the device.
 194   @retval EFI_MEDIA_CHNAGED       The MediaId does not matched the current
 195                                   device.
 196   @retval EFI_BAD_BUFFER_SIZE     The Buffer was not a multiple of the block
 197                                   size of the device.
 198   @retval EFI_INVALID_PARAMETER   The write request contains LBAs that are not
 199                                   valid, or the buffer is not on proper alignment.
 200
 201 **/
 202 EFI_STATUS
 203 EFIAPI
 204 RamDiskBlkIoWriteBlocks (
 205   IN EFI_BLOCK_IO_PROTOCOL        *This,
 206   IN UINT32                       MediaId,
 207   IN EFI_LBA                      Lba,
 208   IN UINTN                        BufferSize,
 209   IN VOID                         *Buffer
 210   )
 211 {
 212   RAM_DISK_PRIVATE_DATA           *PrivateData;
 213   UINTN                           NumberOfBlocks;
 214
 215   PrivateData = RAM_DISK_PRIVATE_FROM_BLKIO (This);
 216
 217   if (MediaId != PrivateData->Media.MediaId) {
 218     return EFI_MEDIA_CHANGED;
 219   }
 220
 221   if (TRUE == PrivateData->Media.ReadOnly) {
 222     return EFI_WRITE_PROTECTED;
 223   }
 224
 225   if (Buffer == NULL) {
 226     return EFI_INVALID_PARAMETER;
 227   }
 228
 229   if (BufferSize == 0) {
 230     return EFI_SUCCESS;
 231   }
 232
 233   if ((BufferSize % PrivateData->Media.BlockSize) != 0) {
 234     return EFI_BAD_BUFFER_SIZE;
 235   }
 236
 237   if (Lba > PrivateData->Media.LastBlock) {
 238     return EFI_INVALID_PARAMETER;
 239   }
 240
 241   NumberOfBlocks = BufferSize / PrivateData->Media.BlockSize;
 242   if ((Lba + NumberOfBlocks - 1) > PrivateData->Media.LastBlock) {
 243     return EFI_INVALID_PARAMETER;
 244   }
 245
 246   CopyMem (
 247     (VOID *)(UINTN)(PrivateData->StartingAddr + MultU64x32 (Lba, PrivateData->Media.BlockSize)),
 248     Buffer,
 249     BufferSize
 250     );
 251
 252   return EFI_SUCCESS;
 253 }
 254
 255
 256 /**
 257   Flush the Block Device.
 258
 259   @param[in] This            Indicates a pointer to the calling context.
 260
 261   @retval EFI_SUCCESS             All outstanding data was written to the device.
 262   @retval EFI_DEVICE_ERROR        The device reported an error while writting
 263                                   back the data
 264   @retval EFI_NO_MEDIA            There is no media in the device.
 265
 266 **/
 267 EFI_STATUS
 268 EFIAPI
 269 RamDiskBlkIoFlushBlocks (
 270   IN EFI_BLOCK_IO_PROTOCOL        *This
 271   )
 272 {
 273   return EFI_SUCCESS;
 274 }
 275
 276
 277 /**
 278   Resets the block device hardware.
 279
 280   @param[in] This                 The pointer of EFI_BLOCK_IO2_PROTOCOL.
 281   @param[in] ExtendedVerification The flag about if extend verificate.
 282
 283   @retval EFI_SUCCESS             The device was reset.
 284   @retval EFI_DEVICE_ERROR        The block device is not functioning correctly
 285                                   and could not be reset.
 286
 287 **/
 288 EFI_STATUS
 289 EFIAPI
 290 RamDiskBlkIo2Reset (
 291   IN EFI_BLOCK_IO2_PROTOCOL       *This,
 292   IN BOOLEAN                      ExtendedVerification
 293   )
 294 {
 295   return EFI_SUCCESS;
 296 }
 297
 298
 299 /**
 300   Reads the requested number of blocks from the device.
 301
 302   @param[in]      This            Indicates a pointer to the calling context.
 303   @param[in]      MediaId         The media ID that the read request is for.
 304   @param[in]      Lba             The starting logical block address to read
 305                                   from on the device.
 306   @param[in, out] Token           A pointer to the token associated with the
 307                                   transaction.
 308   @param[in]      BufferSize      The size of the Buffer in bytes. This must be
 309                                   a multiple of the intrinsic block size of the
 310                                   device.
 311   @param[out]     Buffer          A pointer to the destination buffer for the
 312                                   data. The caller is responsible for either
 313                                   having implicit or explicit ownership of the
 314                                   buffer.
 315
 316   @retval EFI_SUCCESS             The read request was queued if Token->Event
 317                                   is not NULL. The data was read correctly from
 318                                   the device if the Token->Event is NULL.
 319   @retval EFI_DEVICE_ERROR        The device reported an error while attempting
 320                                   to perform the read operation.
 321   @retval EFI_NO_MEDIA            There is no media in the device.
 322   @retval EFI_MEDIA_CHANGED       The MediaId is not for the current media.
 323   @retval EFI_BAD_BUFFER_SIZE     The BufferSize parameter is not a multiple of
 324                                   the intrinsic block size of the device.
 325   @retval EFI_INVALID_PARAMETER   The read request contains LBAs that are not
 326                                   valid, or the buffer is not on proper
 327                                   alignment.
 328   @retval EFI_OUT_OF_RESOURCES    The request could not be completed due to a
 329                                   lack of resources.
 330
 331 **/
 332 EFI_STATUS
 333 EFIAPI
 334 RamDiskBlkIo2ReadBlocksEx (
 335   IN     EFI_BLOCK_IO2_PROTOCOL   *This,
 336   IN     UINT32                   MediaId,
 337   IN     EFI_LBA                  Lba,
 338   IN OUT EFI_BLOCK_IO2_TOKEN      *Token,
 339   IN     UINTN                    BufferSize,
 340      OUT VOID                     *Buffer
 341   )
 342 {
 343   RAM_DISK_PRIVATE_DATA           *PrivateData;
 344   EFI_STATUS                      Status;
 345
 346   PrivateData = RAM_DISK_PRIVATE_FROM_BLKIO2 (This);
 347
 348   Status = RamDiskBlkIoReadBlocks (
 349               &PrivateData->BlockIo,
 350               MediaId,
 351               Lba,
 352               BufferSize,
 353               Buffer
 354               );
 355   if (EFI_ERROR (Status)) {
 356     return Status;
 357   }
 358
 359   //
 360   // If caller's event is given, signal it after the memory read completes.
 361   //
 362   if ((Token != NULL) && (Token->Event != NULL)) {
 363     Token->TransactionStatus = EFI_SUCCESS;
 364     gBS->SignalEvent (Token->Event);
 365   }
 366
 367   return EFI_SUCCESS;
 368 }
 369
 370
 371 /**
 372   Writes a specified number of blocks to the device.
 373
 374   @param[in]      This            Indicates a pointer to the calling context.
 375   @param[in]      MediaId         The media ID that the write request is for.
 376   @param[in]      Lba             The starting logical block address to be
 377                                   written. The caller is responsible for
 378                                   writing to only legitimate locations.
 379   @param[in, out] Token           A pointer to the token associated with the
 380                                   transaction.
 381   @param[in]      BufferSize      The size in bytes of Buffer. This must be a
 382                                   multiple of the intrinsic block size of the
 383                                   device.
 384   @param[in]      Buffer          A pointer to the source buffer for the data.
 385
 386   @retval EFI_SUCCESS             The write request was queued if Event is not
 387                                   NULL. The data was written correctly to the
 388                                   device if the Event is NULL.
 389   @retval EFI_WRITE_PROTECTED     The device cannot be written to.
 390   @retval EFI_NO_MEDIA            There is no media in the device.
 391   @retval EFI_MEDIA_CHANGED       The MediaId is not for the current media.
 392   @retval EFI_DEVICE_ERROR        The device reported an error while attempting
 393                                   to perform the write operation.
 394   @retval EFI_BAD_BUFFER_SIZE     The BufferSize parameter is not a multiple of
 395                                   the intrinsic block size of the device.
 396   @retval EFI_INVALID_PARAMETER   The write request contains LBAs that are not
 397                                   valid, or the buffer is not on proper
 398                                   alignment.
 399   @retval EFI_OUT_OF_RESOURCES    The request could not be completed due to a
 400                                   lack of resources.
 401
 402 **/
 403 EFI_STATUS
 404 EFIAPI
 405 RamDiskBlkIo2WriteBlocksEx (
 406   IN     EFI_BLOCK_IO2_PROTOCOL   *This,
 407   IN     UINT32                   MediaId,
 408   IN     EFI_LBA                  Lba,
 409   IN OUT EFI_BLOCK_IO2_TOKEN      *Token,
 410   IN     UINTN                    BufferSize,
 411   IN     VOID                     *Buffer
 412   )
 413 {
 414   RAM_DISK_PRIVATE_DATA           *PrivateData;
 415   EFI_STATUS                      Status;
 416
 417   PrivateData = RAM_DISK_PRIVATE_FROM_BLKIO2 (This);
 418
 419   Status = RamDiskBlkIoWriteBlocks (
 420               &PrivateData->BlockIo,
 421               MediaId,
 422               Lba,
 423               BufferSize,
 424               Buffer
 425               );
 426   if (EFI_ERROR (Status)) {
 427     return Status;
 428   }
 429
 430   //
 431   // If caller's event is given, signal it after the memory write completes.
 432   //
 433   if ((Token != NULL) && (Token->Event != NULL)) {
 434     Token->TransactionStatus = EFI_SUCCESS;
 435     gBS->SignalEvent (Token->Event);
 436   }
 437
 438   return EFI_SUCCESS;
 439 }
 440
 441
 442 /**
 443   Flushes all modified data to a physical block device.
 444
 445   @param[in]      This            Indicates a pointer to the calling context.
 446   @param[in, out] Token           A pointer to the token associated with the
 447                                   transaction.
 448
 449   @retval EFI_SUCCESS             The flush request was queued if Event is not
 450                                   NULL. All outstanding data was written
 451                                   correctly to the device if the Event is NULL.
 452   @retval EFI_DEVICE_ERROR        The device reported an error while attempting
 453                                   to write data.
 454   @retval EFI_WRITE_PROTECTED     The device cannot be written to.
 455   @retval EFI_NO_MEDIA            There is no media in the device.
 456   @retval EFI_MEDIA_CHANGED       The MediaId is not for the current media.
 457   @retval EFI_OUT_OF_RESOURCES    The request could not be completed due to a
 458                                   lack of resources.
 459
 460 **/
 461 EFI_STATUS
 462 EFIAPI
 463 RamDiskBlkIo2FlushBlocksEx (
 464   IN     EFI_BLOCK_IO2_PROTOCOL   *This,
 465   IN OUT EFI_BLOCK_IO2_TOKEN      *Token
 466   )
 467 {
 468   RAM_DISK_PRIVATE_DATA           *PrivateData;
 469
 470   PrivateData = RAM_DISK_PRIVATE_FROM_BLKIO2 (This);
 471
 472   if (TRUE == PrivateData->Media.ReadOnly) {
 473     return EFI_WRITE_PROTECTED;
 474   }
 475
 476   //
 477   // If caller's event is given, signal it directly.
 478   //
 479   if ((Token != NULL) && (Token->Event != NULL)) {
 480     Token->TransactionStatus = EFI_SUCCESS;
 481     gBS->SignalEvent (Token->Event);
 482   }
 483
 484   return EFI_SUCCESS;
 485 }