OvmfPkg/VirtioBlkDxe/VirtioBlk.c

   1 /** @file
   2
   3   This driver produces Block I/O Protocol instances for virtio-blk devices.
   4
   5   The implementation is basic:
   6
   7   - No attach/detach (ie. removable media).
   8
   9   - Although the non-blocking interfaces of EFI_BLOCK_IO2_PROTOCOL could be a
  10     good match for multiple in-flight virtio-blk requests, we stick to
  11     synchronous requests and EFI_BLOCK_IO_PROTOCOL for now.
  12
  13   Copyright (C) 2012, Red Hat, Inc.
  14   Copyright (c) 2012, Intel Corporation. All rights reserved.<BR>
  15
  16   This program and the accompanying materials are licensed and made available
  17   under the terms and conditions of the BSD License which accompanies this
  18   distribution. The full text of the license may be found at
  19   http://opensource.org/licenses/bsd-license.php
  20
  21   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, WITHOUT
  22   WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  23
  24 **/
  25
  26 #include <IndustryStandard/VirtioBlk.h>
  27 #include <Library/BaseMemoryLib.h>
  28 #include <Library/DebugLib.h>
  29 #include <Library/MemoryAllocationLib.h>
  30 #include <Library/UefiBootServicesTableLib.h>
  31 #include <Library/UefiLib.h>
  32 #include <Library/VirtioLib.h>
  33
  34 #include "VirtioBlk.h"
  35
  36 /**
  37
  38   Convenience macros to read and write region 0 IO space elements of the
  39   virtio-blk device, for configuration purposes.
  40
  41   The following macros make it possible to specify only the "core parameters"
  42   for such accesses and to derive the rest. By the time VIRTIO_CFG_WRITE()
  43   returns, the transaction will have been completed.
  44
  45   @param[in] Dev       Pointer to the VBLK_DEV structure whose VirtIo space
  46                        we're accessing. Dev->VirtIo must be valid.
  47
  48   @param[in] Field     A field name from VBLK_HDR, identifying the virtio-blk
  49                        configuration item to access.
  50
  51   @param[in] Value     (VIRTIO_CFG_WRITE() only.) The value to write to the
  52                        selected configuration item.
  53
  54   @param[out] Pointer  (VIRTIO_CFG_READ() only.) The object to receive the
  55                        value read from the configuration item. Its type must be
  56                        one of UINT8, UINT16, UINT32, UINT64.
  57
  58
  59   @return  Status code returned by Virtio->WriteDevice() / Virtio->ReadDevice().
  60
  61 **/
  62
  63 #define VIRTIO_CFG_WRITE(Dev, Field, Value)  ((Dev)->VirtIo->WriteDevice ( \
  64                                                 (Dev)->VirtIo,             \
  65                                                 OFFSET_OF_VBLK (Field),    \
  66                                                 SIZE_OF_VBLK (Field),      \
  67                                                 (Value)                    \
  68                                                 ))
  69
  70 #define VIRTIO_CFG_READ(Dev, Field, Pointer) ((Dev)->VirtIo->ReadDevice (  \
  71                                                 (Dev)->VirtIo,             \
  72                                                 OFFSET_OF_VBLK (Field),    \
  73                                                 SIZE_OF_VBLK (Field),      \
  74                                                 sizeof *(Pointer),         \
  75                                                 (Pointer)                  \
  76                                                 ))
  77
  78
  79 //
  80 // UEFI Spec 2.3.1 + Errata C, 12.8 EFI Block I/O Protocol
  81 // Driver Writer's Guide for UEFI 2.3.1 v1.01,
  82 //   24.2 Block I/O Protocol Implementations
  83 //
  84 EFI_STATUS
  85 EFIAPI
  86 VirtioBlkReset (
  87   IN EFI_BLOCK_IO_PROTOCOL *This,
  88   IN BOOLEAN               ExtendedVerification
  89   )
  90 {
  91   //
  92   // If we managed to initialize and install the driver, then the device is
  93   // working correctly.
  94   //
  95   return EFI_SUCCESS;
  96 }
  97
  98 /**
  99
 100   Verify correctness of the read/write (not flush) request submitted to the
 101   EFI_BLOCK_IO_PROTOCOL instance.
 102
 103   This function provides most verification steps described in:
 104
 105     UEFI Spec 2.3.1 + Errata C, 12.8 EFI Block I/O Protocol, 12.8 EFI Block I/O
 106     Protocol,
 107     - EFI_BLOCK_IO_PROTOCOL.ReadBlocks()
 108     - EFI_BLOCK_IO_PROTOCOL.WriteBlocks()
 109
 110     Driver Writer's Guide for UEFI 2.3.1 v1.01,
 111     - 24.2.2. ReadBlocks() and ReadBlocksEx() Implementation
 112     - 24.2.3 WriteBlocks() and WriteBlockEx() Implementation
 113
 114   Request sizes are limited to 1 GB (checked). This is not a practical
 115   limitation, just conformance to virtio-0.9.5, 2.3.2 Descriptor Table: "no
 116   descriptor chain may be more than 2^32 bytes long in total".
 117
 118   Some Media characteristics are hardcoded in VirtioBlkInit() below (like
 119   non-removable media, no restriction on buffer alignment etc); we rely on
 120   those here without explicit mention.
 121
 122   @param[in] Media               The EFI_BLOCK_IO_MEDIA characteristics for
 123                                  this driver instance, extracted from the
 124                                  underlying virtio-blk device at initialization
 125                                  time. We validate the request against this set
 126                                  of attributes.
 127
 128
 129   @param[in] Lba                 Logical Block Address: number of logical
 130                                  blocks to skip from the beginning of the
 131                                  device.
 132
 133   @param[in] PositiveBufferSize  Size of buffer to transfer, in bytes. The
 134                                  caller is responsible to ensure this parameter
 135                                  is positive.
 136
 137   @param[in] RequestIsWrite      TRUE iff data transfer goes from guest to
 138                                  device.
 139
 140
 141   @@return                       Validation result to be forwarded outwards by
 142                                  ReadBlocks() and WriteBlocks, as required by
 143                                  the specs above.
 144
 145 **/
 146 STATIC
 147 EFI_STATUS
 148 EFIAPI
 149 VerifyReadWriteRequest (
 150   IN  EFI_BLOCK_IO_MEDIA *Media,
 151   IN  EFI_LBA            Lba,
 152   IN  UINTN              PositiveBufferSize,
 153   IN  BOOLEAN            RequestIsWrite
 154   )
 155 {
 156   UINTN BlockCount;
 157
 158   ASSERT (PositiveBufferSize > 0);
 159
 160   if (PositiveBufferSize > SIZE_1GB ||
 161       PositiveBufferSize % Media->BlockSize > 0) {
 162     return EFI_BAD_BUFFER_SIZE;
 163   }
 164   BlockCount = PositiveBufferSize / Media->BlockSize;
 165
 166   //
 167   // Avoid unsigned wraparound on either side in the second comparison.
 168   //
 169   if (Lba > Media->LastBlock || BlockCount - 1 > Media->LastBlock - Lba) {
 170     return EFI_INVALID_PARAMETER;
 171   }
 172
 173   if (RequestIsWrite && Media->ReadOnly) {
 174     return EFI_WRITE_PROTECTED;
 175   }
 176
 177   return EFI_SUCCESS;
 178 }
 179
 180
 181
 182
 183 /**
 184
 185   Format a read / write / flush request as three consecutive virtio
 186   descriptors, push them to the host, and poll for the response.
 187
 188   This is the main workhorse function. Two use cases are supported, read/write
 189   and flush. The function may only be called after the request parameters have
 190   been verified by
 191   - specific checks in ReadBlocks() / WriteBlocks() / FlushBlocks(), and
 192   - VerifyReadWriteRequest() (for read/write only).
 193
 194   Parameters handled commonly:
 195
 196     @param[in] Dev             The virtio-blk device the request is targeted
 197                                at.
 198
 199   Flush request:
 200
 201     @param[in] Lba             Must be zero.
 202
 203     @param[in] BufferSize      Must be zero.
 204
 205     @param[in out] Buffer      Ignored by the function.
 206
 207     @param[in] RequestIsWrite  Must be TRUE.
 208
 209   Read/Write request:
 210
 211     @param[in] Lba             Logical Block Address: number of logical blocks
 212                                to skip from the beginning of the device.
 213
 214     @param[in] BufferSize      Size of buffer to transfer, in bytes. The caller
 215                                is responsible to ensure this parameter is
 216                                positive.
 217
 218     @param[in out] Buffer      The guest side area to read data from the device
 219                                into, or write data to the device from.
 220
 221     @param[in] RequestIsWrite  TRUE iff data transfer goes from guest to
 222                                device.
 223
 224   Return values are common to both use cases, and are appropriate to be
 225   forwarded by the EFI_BLOCK_IO_PROTOCOL functions (ReadBlocks(),
 226   WriteBlocks(), FlushBlocks()).
 227
 228
 229   @retval EFI_SUCCESS          Transfer complete.
 230
 231   @retval EFI_DEVICE_ERROR     Failed to notify host side via VirtIo write, or
 232                                unable to parse host response, or host response
 233                                is not VIRTIO_BLK_S_OK.
 234
 235 **/
 236
 237 STATIC
 238 EFI_STATUS
 239 EFIAPI
 240 SynchronousRequest (
 241   IN              VBLK_DEV *Dev,
 242   IN              EFI_LBA  Lba,
 243   IN              UINTN    BufferSize,
 244   IN OUT volatile VOID     *Buffer,
 245   IN              BOOLEAN  RequestIsWrite
 246   )
 247 {
 248   UINT32                  BlockSize;
 249   volatile VIRTIO_BLK_REQ Request;
 250   volatile UINT8          HostStatus;
 251   DESC_INDICES            Indices;
 252
 253   BlockSize = Dev->BlockIoMedia.BlockSize;
 254
 255   //
 256   // ensured by VirtioBlkInit()
 257   //
 258   ASSERT (BlockSize > 0);
 259   ASSERT (BlockSize % 512 == 0);
 260
 261   //
 262   // ensured by contract above, plus VerifyReadWriteRequest()
 263   //
 264   ASSERT (BufferSize % BlockSize == 0);
 265
 266   //
 267   // Prepare virtio-blk request header, setting zero size for flush.
 268   // IO Priority is homogeneously 0.
 269   //
 270   Request.Type   = RequestIsWrite ?
 271                    (BufferSize == 0 ? VIRTIO_BLK_T_FLUSH : VIRTIO_BLK_T_OUT) :
 272                    VIRTIO_BLK_T_IN;
 273   Request.IoPrio = 0;
 274   Request.Sector = MultU64x32(Lba, BlockSize / 512);
 275
 276   VirtioPrepare (&Dev->Ring, &Indices);
 277
 278   //
 279   // preset a host status for ourselves that we do not accept as success
 280   //
 281   HostStatus = VIRTIO_BLK_S_IOERR;
 282
 283   //
 284   // ensured by VirtioBlkInit() -- this predicate, in combination with the
 285   // lock-step progress, ensures we don't have to track free descriptors.
 286   //
 287   ASSERT (Dev->Ring.QueueSize >= 3);
 288
 289   //
 290   // virtio-blk header in first desc
 291   //
 292   VirtioAppendDesc (&Dev->Ring, (UINTN) &Request, sizeof Request,
 293     VRING_DESC_F_NEXT, &Indices);
 294
 295   //
 296   // data buffer for read/write in second desc
 297   //
 298   if (BufferSize > 0) {
 299     //
 300     // From virtio-0.9.5, 2.3.2 Descriptor Table:
 301     // "no descriptor chain may be more than 2^32 bytes long in total".
 302     //
 303     // The predicate is ensured by the call contract above (for flush), or
 304     // VerifyReadWriteRequest() (for read/write). It also implies that
 305     // converting BufferSize to UINT32 will not truncate it.
 306     //
 307     ASSERT (BufferSize <= SIZE_1GB);
 308
 309     //
 310     // VRING_DESC_F_WRITE is interpreted from the host's point of view.
 311     //
 312     VirtioAppendDesc (&Dev->Ring, (UINTN) Buffer, (UINT32) BufferSize,
 313       VRING_DESC_F_NEXT | (RequestIsWrite ? 0 : VRING_DESC_F_WRITE),
 314       &Indices);
 315   }
 316
 317   //
 318   // host status in last (second or third) desc
 319   //
 320   VirtioAppendDesc (&Dev->Ring, (UINTN) &HostStatus, sizeof HostStatus,
 321     VRING_DESC_F_WRITE, &Indices);
 322
 323   //
 324   // virtio-blk's only virtqueue is #0, called "requestq" (see Appendix D).
 325   //
 326   if (VirtioFlush (Dev->VirtIo, 0, &Dev->Ring, &Indices) == EFI_SUCCESS &&
 327       HostStatus == VIRTIO_BLK_S_OK) {
 328     return EFI_SUCCESS;
 329   }
 330
 331   return EFI_DEVICE_ERROR;
 332 }
 333
 334
 335 /**
 336
 337   ReadBlocks() operation for virtio-blk.
 338
 339   See
 340   - UEFI Spec 2.3.1 + Errata C, 12.8 EFI Block I/O Protocol, 12.8 EFI Block I/O
 341     Protocol, EFI_BLOCK_IO_PROTOCOL.ReadBlocks().
 342   - Driver Writer's Guide for UEFI 2.3.1 v1.01, 24.2.2. ReadBlocks() and
 343     ReadBlocksEx() Implementation.
 344
 345   Parameter checks and conformant return values are implemented in
 346   VerifyReadWriteRequest() and SynchronousRequest().
 347
 348   A zero BufferSize doesn't seem to be prohibited, so do nothing in that case,
 349   successfully.
 350
 351 **/
 352
 353 EFI_STATUS
 354 EFIAPI
 355 VirtioBlkReadBlocks (
 356   IN  EFI_BLOCK_IO_PROTOCOL *This,
 357   IN  UINT32                MediaId,
 358   IN  EFI_LBA               Lba,
 359   IN  UINTN                 BufferSize,
 360   OUT VOID                  *Buffer
 361   )
 362 {
 363   VBLK_DEV   *Dev;
 364   EFI_STATUS Status;
 365
 366   if (BufferSize == 0) {
 367     return EFI_SUCCESS;
 368   }
 369
 370   Dev = VIRTIO_BLK_FROM_BLOCK_IO (This);
 371   Status = VerifyReadWriteRequest (
 372              &Dev->BlockIoMedia,
 373              Lba,
 374              BufferSize,
 375              FALSE               // RequestIsWrite
 376              );
 377   if (EFI_ERROR (Status)) {
 378     return Status;
 379   }
 380
 381   return SynchronousRequest (
 382            Dev,
 383            Lba,
 384            BufferSize,
 385            Buffer,
 386            FALSE       // RequestIsWrite
 387            );
 388 }
 389
 390 /**
 391
 392   WriteBlocks() operation for virtio-blk.
 393
 394   See
 395   - UEFI Spec 2.3.1 + Errata C, 12.8 EFI Block I/O Protocol, 12.8 EFI Block I/O
 396     Protocol, EFI_BLOCK_IO_PROTOCOL.WriteBlocks().
 397   - Driver Writer's Guide for UEFI 2.3.1 v1.01, 24.2.3 WriteBlocks() and
 398     WriteBlockEx() Implementation.
 399
 400   Parameter checks and conformant return values are implemented in
 401   VerifyReadWriteRequest() and SynchronousRequest().
 402
 403   A zero BufferSize doesn't seem to be prohibited, so do nothing in that case,
 404   successfully.
 405
 406 **/
 407
 408 EFI_STATUS
 409 EFIAPI
 410 VirtioBlkWriteBlocks (
 411   IN EFI_BLOCK_IO_PROTOCOL *This,
 412   IN UINT32                MediaId,
 413   IN EFI_LBA               Lba,
 414   IN UINTN                 BufferSize,
 415   IN VOID                  *Buffer
 416   )
 417 {
 418   VBLK_DEV   *Dev;
 419   EFI_STATUS Status;
 420
 421   if (BufferSize == 0) {
 422     return EFI_SUCCESS;
 423   }
 424
 425   Dev = VIRTIO_BLK_FROM_BLOCK_IO (This);
 426   Status = VerifyReadWriteRequest (
 427              &Dev->BlockIoMedia,
 428              Lba,
 429              BufferSize,
 430              TRUE                // RequestIsWrite
 431              );
 432   if (EFI_ERROR (Status)) {
 433     return Status;
 434   }
 435
 436   return SynchronousRequest (
 437            Dev,
 438            Lba,
 439            BufferSize,
 440            Buffer,
 441            TRUE        // RequestIsWrite
 442            );
 443 }
 444
 445
 446 /**
 447
 448   FlushBlocks() operation for virtio-blk.
 449
 450   See
 451   - UEFI Spec 2.3.1 + Errata C, 12.8 EFI Block I/O Protocol, 12.8 EFI Block I/O
 452     Protocol, EFI_BLOCK_IO_PROTOCOL.FlushBlocks().
 453   - Driver Writer's Guide for UEFI 2.3.1 v1.01, 24.2.4 FlushBlocks() and
 454     FlushBlocksEx() Implementation.
 455
 456   If the underlying virtio-blk device doesn't support flushing (ie.
 457   write-caching), then this function should not be called by higher layers,
 458   according to EFI_BLOCK_IO_MEDIA characteristics set in VirtioBlkInit().
 459   Should they do nonetheless, we do nothing, successfully.
 460
 461 **/
 462
 463 EFI_STATUS
 464 EFIAPI
 465 VirtioBlkFlushBlocks (
 466   IN EFI_BLOCK_IO_PROTOCOL *This
 467   )
 468 {
 469   VBLK_DEV *Dev;
 470
 471   Dev = VIRTIO_BLK_FROM_BLOCK_IO (This);
 472   return Dev->BlockIoMedia.WriteCaching ?
 473            SynchronousRequest (
 474              Dev,
 475              0,    // Lba
 476              0,    // BufferSize
 477              NULL, // Buffer
 478              TRUE  // RequestIsWrite
 479              ) :
 480            EFI_SUCCESS;
 481 }
 482
 483
 484 /**
 485
 486   Device probe function for this driver.
 487
 488   The DXE core calls this function for any given device in order to see if the
 489   driver can drive the device.
 490
 491   Specs relevant in the general sense:
 492
 493   - UEFI Spec 2.3.1 + Errata C:
 494     - 6.3 Protocol Handler Services -- for accessing the underlying device
 495     - 10.1 EFI Driver Binding Protocol -- for exporting ourselves
 496
 497   - Driver Writer's Guide for UEFI 2.3.1 v1.01:
 498     - 5.1.3.4 OpenProtocol() and CloseProtocol() -- for accessing the
 499       underlying device
 500     - 9 Driver Binding Protocol -- for exporting ourselves
 501
 502   @param[in]  This                The EFI_DRIVER_BINDING_PROTOCOL object
 503                                   incorporating this driver (independently of
 504                                   any device).
 505
 506   @param[in] DeviceHandle         The device to probe.
 507
 508   @param[in] RemainingDevicePath  Relevant only for bus drivers, ignored.
 509
 510
 511   @retval EFI_SUCCESS      The driver supports the device being probed.
 512
 513   @retval EFI_UNSUPPORTED  Based on virtio-blk discovery, we do not support
 514                            the device.
 515
 516   @return                  Error codes from the OpenProtocol() boot service or
 517                            the VirtIo protocol.
 518
 519 **/
 520
 521 EFI_STATUS
 522 EFIAPI
 523 VirtioBlkDriverBindingSupported (
 524   IN EFI_DRIVER_BINDING_PROTOCOL *This,
 525   IN EFI_HANDLE                  DeviceHandle,
 526   IN EFI_DEVICE_PATH_PROTOCOL    *RemainingDevicePath
 527   )
 528 {
 529   EFI_STATUS          Status;
 530   VIRTIO_DEVICE_PROTOCOL *VirtIo;
 531
 532   //
 533   // Attempt to open the device with the VirtIo set of interfaces. On success,
 534   // the protocol is "instantiated" for the VirtIo device. Covers duplicate open
 535   // attempts (EFI_ALREADY_STARTED).
 536   //
 537   Status = gBS->OpenProtocol (
 538                   DeviceHandle,               // candidate device
 539                   &gVirtioDeviceProtocolGuid, // for generic VirtIo access
 540                   (VOID **)&VirtIo,           // handle to instantiate
 541                   This->DriverBindingHandle,  // requestor driver identity
 542                   DeviceHandle,               // ControllerHandle, according to
 543                                               // the UEFI Driver Model
 544                   EFI_OPEN_PROTOCOL_BY_DRIVER // get exclusive VirtIo access to
 545                                               // the device; to be released
 546                   );
 547   if (EFI_ERROR (Status)) {
 548     return Status;
 549   }
 550
 551   if (VirtIo->SubSystemDeviceId != VIRTIO_SUBSYSTEM_BLOCK_DEVICE) {
 552     Status = EFI_UNSUPPORTED;
 553   }
 554
 555   //
 556   // We needed VirtIo access only transitorily, to see whether we support the
 557   // device or not.
 558   //
 559   gBS->CloseProtocol (DeviceHandle, &gVirtioDeviceProtocolGuid,
 560          This->DriverBindingHandle, DeviceHandle);
 561   return Status;
 562 }
 563
 564
 565 /**
 566
 567   Set up all BlockIo and virtio-blk aspects of this driver for the specified
 568   device.
 569
 570   @param[in out] Dev  The driver instance to configure. The caller is
 571                       responsible for Dev->VirtIo's validity (ie. working IO
 572                       access to the underlying virtio-blk device).
 573
 574   @retval EFI_SUCCESS      Setup complete.
 575
 576   @retval EFI_UNSUPPORTED  The driver is unable to work with the virtio ring or
 577                            virtio-blk attributes the host provides.
 578
 579   @return                  Error codes from VirtioRingInit() or
 580                            VIRTIO_CFG_READ() / VIRTIO_CFG_WRITE().
 581
 582 **/
 583
 584 STATIC
 585 EFI_STATUS
 586 EFIAPI
 587 VirtioBlkInit (
 588   IN OUT VBLK_DEV *Dev
 589   )
 590 {
 591   UINT8      NextDevStat;
 592   EFI_STATUS Status;
 593
 594   UINT32     Features;
 595   UINT64     NumSectors;
 596   UINT32     BlockSize;
 597   UINT16     QueueSize;
 598
 599   //
 600   // Execute virtio-0.9.5, 2.2.1 Device Initialization Sequence.
 601   //
 602   NextDevStat = 0;             // step 1 -- reset device
 603   Status = Dev->VirtIo->SetDeviceStatus (Dev->VirtIo, NextDevStat);
 604   if (EFI_ERROR (Status)) {
 605     goto Failed;
 606   }
 607
 608   NextDevStat |= VSTAT_ACK;    // step 2 -- acknowledge device presence
 609   Status = Dev->VirtIo->SetDeviceStatus (Dev->VirtIo, NextDevStat);
 610   if (EFI_ERROR (Status)) {
 611     goto Failed;
 612   }
 613
 614   NextDevStat |= VSTAT_DRIVER; // step 3 -- we know how to drive it
 615   Status = Dev->VirtIo->SetDeviceStatus (Dev->VirtIo, NextDevStat);
 616   if (EFI_ERROR (Status)) {
 617     goto Failed;
 618   }
 619
 620   //
 621   // Set Page Size - MMIO VirtIo Specific
 622   //
 623   Status = Dev->VirtIo->SetPageSize (Dev->VirtIo, EFI_PAGE_SIZE);
 624   if (EFI_ERROR (Status)) {
 625     goto Failed;
 626   }
 627
 628   //
 629   // step 4a -- retrieve and validate features
 630   //
 631   Status = Dev->VirtIo->GetDeviceFeatures (Dev->VirtIo, &Features);
 632   if (EFI_ERROR (Status)) {
 633     goto Failed;
 634   }
 635
 636   Status = VIRTIO_CFG_READ (Dev, Capacity, &NumSectors);
 637   if (EFI_ERROR (Status)) {
 638     goto Failed;
 639   }
 640   if (NumSectors == 0) {
 641     Status = EFI_UNSUPPORTED;
 642     goto Failed;
 643   }
 644
 645   if (Features & VIRTIO_BLK_F_BLK_SIZE) {
 646     Status = VIRTIO_CFG_READ (Dev, BlkSize, &BlockSize);
 647     if (EFI_ERROR (Status)) {
 648       goto Failed;
 649     }
 650     if (BlockSize == 0 || BlockSize % 512 != 0 ||
 651         ModU64x32 (NumSectors, BlockSize / 512) != 0) {
 652       //
 653       // We can only handle a logical block consisting of whole sectors,
 654       // and only a disk composed of whole logical blocks.
 655       //
 656       Status = EFI_UNSUPPORTED;
 657       goto Failed;
 658     }
 659   }
 660   else {
 661     BlockSize = 512;
 662   }
 663
 664   //
 665   // step 4b -- allocate virtqueue
 666   //
 667   Status = Dev->VirtIo->SetQueueSel (Dev->VirtIo, 0);
 668   if (EFI_ERROR (Status)) {
 669     goto Failed;
 670   }
 671   Status = Dev->VirtIo->GetQueueNumMax (Dev->VirtIo, &QueueSize);
 672   if (EFI_ERROR (Status)) {
 673     goto Failed;
 674   }
 675   if (QueueSize < 3) { // SynchronousRequest() uses at most three descriptors
 676     Status = EFI_UNSUPPORTED;
 677     goto Failed;
 678   }
 679
 680   Status = VirtioRingInit (QueueSize, &Dev->Ring);
 681   if (EFI_ERROR (Status)) {
 682     goto Failed;
 683   }
 684
 685   //
 686   // Additional steps for MMIO: align the queue appropriately, and set the
 687   // size. If anything fails from here on, we must release the ring resources.
 688   //
 689   Status = Dev->VirtIo->SetQueueNum (Dev->VirtIo, QueueSize);
 690   if (EFI_ERROR (Status)) {
 691     goto ReleaseQueue;
 692   }
 693
 694   Status = Dev->VirtIo->SetQueueAlign (Dev->VirtIo, EFI_PAGE_SIZE);
 695   if (EFI_ERROR (Status)) {
 696     goto ReleaseQueue;
 697   }
 698
 699   //
 700   // step 4c -- Report GPFN (guest-physical frame number) of queue.
 701   //
 702   Status = Dev->VirtIo->SetQueueAddress (Dev->VirtIo,
 703       (UINT32) ((UINTN) Dev->Ring.Base >> EFI_PAGE_SHIFT));
 704   if (EFI_ERROR (Status)) {
 705     goto ReleaseQueue;
 706   }
 707
 708
 709   //
 710   // step 5 -- Report understood features. There are no virtio-blk specific
 711   // features to negotiate in virtio-0.9.5, plus we do not want any of the
 712   // device-independent (known or unknown) VIRTIO_F_* capabilities (see
 713   // Appendix B).
 714   //
 715   Status = Dev->VirtIo->SetGuestFeatures (Dev->VirtIo, 0);
 716   if (EFI_ERROR (Status)) {
 717     goto ReleaseQueue;
 718   }
 719
 720   //
 721   // step 6 -- initialization complete
 722   //
 723   NextDevStat |= VSTAT_DRIVER_OK;
 724   Status = Dev->VirtIo->SetDeviceStatus (Dev->VirtIo, NextDevStat);
 725   if (EFI_ERROR (Status)) {
 726     goto ReleaseQueue;
 727   }
 728
 729   //
 730   // Populate the exported interface's attributes; see UEFI spec v2.3.1 +
 731   // Errata C, 12.8 EFI Block I/O Protocol. We stick to the lowest possible
 732   // EFI_BLOCK_IO_PROTOCOL revision for now.
 733   //
 734   Dev->BlockIo.Revision              = 0;
 735   Dev->BlockIo.Media                 = &Dev->BlockIoMedia;
 736   Dev->BlockIo.Reset                 = &VirtioBlkReset;
 737   Dev->BlockIo.ReadBlocks            = &VirtioBlkReadBlocks;
 738   Dev->BlockIo.WriteBlocks           = &VirtioBlkWriteBlocks;
 739   Dev->BlockIo.FlushBlocks           = &VirtioBlkFlushBlocks;
 740   Dev->BlockIoMedia.MediaId          = 0;
 741   Dev->BlockIoMedia.RemovableMedia   = FALSE;
 742   Dev->BlockIoMedia.MediaPresent     = TRUE;
 743   Dev->BlockIoMedia.LogicalPartition = FALSE;
 744   Dev->BlockIoMedia.ReadOnly         = !!(Features & VIRTIO_BLK_F_RO);
 745   Dev->BlockIoMedia.WriteCaching     = !!(Features & VIRTIO_BLK_F_FLUSH);
 746   Dev->BlockIoMedia.BlockSize        = BlockSize;
 747   Dev->BlockIoMedia.IoAlign          = 0;
 748   Dev->BlockIoMedia.LastBlock        = DivU64x32 (NumSectors,
 749                                          BlockSize / 512) - 1;
 750   return EFI_SUCCESS;
 751
 752 ReleaseQueue:
 753   VirtioRingUninit (&Dev->Ring);
 754
 755 Failed:
 756   //
 757   // Notify the host about our failure to setup: virtio-0.9.5, 2.2.2.1 Device
 758   // Status. VirtIo access failure here should not mask the original error.
 759   //
 760   NextDevStat |= VSTAT_FAILED;
 761   Dev->VirtIo->SetDeviceStatus (Dev->VirtIo, NextDevStat);
 762
 763   return Status; // reached only via Failed above
 764 }
 765
 766
 767 /**
 768
 769   Uninitialize the internals of a virtio-blk device that has been successfully
 770   set up with VirtioBlkInit().
 771
 772   @param[in out]  Dev  The device to clean up.
 773
 774 **/
 775
 776 STATIC
 777 VOID
 778 EFIAPI
 779 VirtioBlkUninit (
 780   IN OUT VBLK_DEV *Dev
 781   )
 782 {
 783   //
 784   // Reset the virtual device -- see virtio-0.9.5, 2.2.2.1 Device Status. When
 785   // VIRTIO_CFG_WRITE() returns, the host will have learned to stay away from
 786   // the old comms area.
 787   //
 788   Dev->VirtIo->SetDeviceStatus (Dev->VirtIo, 0);
 789
 790   VirtioRingUninit (&Dev->Ring);
 791
 792   SetMem (&Dev->BlockIo,      sizeof Dev->BlockIo,      0x00);
 793   SetMem (&Dev->BlockIoMedia, sizeof Dev->BlockIoMedia, 0x00);
 794 }
 795
 796
 797 /**
 798
 799   After we've pronounced support for a specific device in
 800   DriverBindingSupported(), we start managing said device (passed in by the
 801   Driver Exeuction Environment) with the following service.
 802
 803   See DriverBindingSupported() for specification references.
 804
 805   @param[in]  This                The EFI_DRIVER_BINDING_PROTOCOL object
 806                                   incorporating this driver (independently of
 807                                   any device).
 808
 809   @param[in] DeviceHandle         The supported device to drive.
 810
 811   @param[in] RemainingDevicePath  Relevant only for bus drivers, ignored.
 812
 813
 814   @retval EFI_SUCCESS           Driver instance has been created and
 815                                 initialized  for the virtio-blk device, it
 816                                 is now accessibla via EFI_BLOCK_IO_PROTOCOL.
 817
 818   @retval EFI_OUT_OF_RESOURCES  Memory allocation failed.
 819
 820   @return                       Error codes from the OpenProtocol() boot
 821                                 service, the VirtIo protocol, VirtioBlkInit(),
 822                                 or the InstallProtocolInterface() boot service.
 823
 824 **/
 825
 826 EFI_STATUS
 827 EFIAPI
 828 VirtioBlkDriverBindingStart (
 829   IN EFI_DRIVER_BINDING_PROTOCOL *This,
 830   IN EFI_HANDLE                  DeviceHandle,
 831   IN EFI_DEVICE_PATH_PROTOCOL    *RemainingDevicePath
 832   )
 833 {
 834   VBLK_DEV   *Dev;
 835   EFI_STATUS Status;
 836
 837   Dev = (VBLK_DEV *) AllocateZeroPool (sizeof *Dev);
 838   if (Dev == NULL) {
 839     return EFI_OUT_OF_RESOURCES;
 840   }
 841
 842   Status = gBS->OpenProtocol (DeviceHandle, &gVirtioDeviceProtocolGuid,
 843                   (VOID **)&Dev->VirtIo, This->DriverBindingHandle,
 844                   DeviceHandle, EFI_OPEN_PROTOCOL_BY_DRIVER);
 845   if (EFI_ERROR (Status)) {
 846     goto FreeVirtioBlk;
 847   }
 848
 849   //
 850   // VirtIo access granted, configure virtio-blk device.
 851   //
 852   Status = VirtioBlkInit (Dev);
 853   if (EFI_ERROR (Status)) {
 854     goto CloseVirtIo;
 855   }
 856
 857   //
 858   // Setup complete, attempt to export the driver instance's BlockIo interface.
 859   //
 860   Dev->Signature = VBLK_SIG;
 861   Status = gBS->InstallProtocolInterface (&DeviceHandle,
 862                   &gEfiBlockIoProtocolGuid, EFI_NATIVE_INTERFACE,
 863                   &Dev->BlockIo);
 864   if (EFI_ERROR (Status)) {
 865     goto UninitDev;
 866   }
 867
 868   return EFI_SUCCESS;
 869
 870 UninitDev:
 871   VirtioBlkUninit (Dev);
 872
 873 CloseVirtIo:
 874   gBS->CloseProtocol (DeviceHandle, &gVirtioDeviceProtocolGuid,
 875          This->DriverBindingHandle, DeviceHandle);
 876
 877 FreeVirtioBlk:
 878   FreePool (Dev);
 879
 880   return Status;
 881 }
 882
 883
 884 /**
 885
 886   Stop driving a virtio-blk device and remove its BlockIo interface.
 887
 888   This function replays the success path of DriverBindingStart() in reverse.
 889   The host side virtio-blk device is reset, so that the OS boot loader or the
 890   OS may reinitialize it.
 891
 892   @param[in] This               The EFI_DRIVER_BINDING_PROTOCOL object
 893                                 incorporating this driver (independently of any
 894                                 device).
 895
 896   @param[in] DeviceHandle       Stop driving this device.
 897
 898   @param[in] NumberOfChildren   Since this function belongs to a device driver
 899                                 only (as opposed to a bus driver), the caller
 900                                 environment sets NumberOfChildren to zero, and
 901                                 we ignore it.
 902
 903   @param[in] ChildHandleBuffer  Ignored (corresponding to NumberOfChildren).
 904
 905 **/
 906
 907 EFI_STATUS
 908 EFIAPI
 909 VirtioBlkDriverBindingStop (
 910   IN EFI_DRIVER_BINDING_PROTOCOL *This,
 911   IN EFI_HANDLE                  DeviceHandle,
 912   IN UINTN                       NumberOfChildren,
 913   IN EFI_HANDLE                  *ChildHandleBuffer
 914   )
 915 {
 916   EFI_STATUS            Status;
 917   EFI_BLOCK_IO_PROTOCOL *BlockIo;
 918   VBLK_DEV              *Dev;
 919
 920   Status = gBS->OpenProtocol (
 921                   DeviceHandle,                  // candidate device
 922                   &gEfiBlockIoProtocolGuid,      // retrieve the BlockIo iface
 923                   (VOID **)&BlockIo,             // target pointer
 924                   This->DriverBindingHandle,     // requestor driver identity
 925                   DeviceHandle,                  // requesting lookup for dev.
 926                   EFI_OPEN_PROTOCOL_GET_PROTOCOL // lookup only, no ref. added
 927                   );
 928   if (EFI_ERROR (Status)) {
 929     return Status;
 930   }
 931
 932   Dev = VIRTIO_BLK_FROM_BLOCK_IO (BlockIo);
 933
 934   //
 935   // Handle Stop() requests for in-use driver instances gracefully.
 936   //
 937   Status = gBS->UninstallProtocolInterface (DeviceHandle,
 938                   &gEfiBlockIoProtocolGuid, &Dev->BlockIo);
 939   if (EFI_ERROR (Status)) {
 940     return Status;
 941   }
 942
 943   VirtioBlkUninit (Dev);
 944
 945   gBS->CloseProtocol (DeviceHandle, &gVirtioDeviceProtocolGuid,
 946          This->DriverBindingHandle, DeviceHandle);
 947
 948   FreePool (Dev);
 949
 950   return EFI_SUCCESS;
 951 }
 952
 953
 954 //
 955 // The static object that groups the Supported() (ie. probe), Start() and
 956 // Stop() functions of the driver together. Refer to UEFI Spec 2.3.1 + Errata
 957 // C, 10.1 EFI Driver Binding Protocol.
 958 //
 959 STATIC EFI_DRIVER_BINDING_PROTOCOL gDriverBinding = {
 960   &VirtioBlkDriverBindingSupported,
 961   &VirtioBlkDriverBindingStart,
 962   &VirtioBlkDriverBindingStop,
 963   0x10, // Version, must be in [0x10 .. 0xFFFFFFEF] for IHV-developed drivers
 964   NULL, // ImageHandle, to be overwritten by
 965         // EfiLibInstallDriverBindingComponentName2() in VirtioBlkEntryPoint()
 966   NULL  // DriverBindingHandle, ditto
 967 };
 968
 969
 970 //
 971 // The purpose of the following scaffolding (EFI_COMPONENT_NAME_PROTOCOL and
 972 // EFI_COMPONENT_NAME2_PROTOCOL implementation) is to format the driver's name
 973 // in English, for display on standard console devices. This is recommended for
 974 // UEFI drivers that follow the UEFI Driver Model. Refer to the Driver Writer's
 975 // Guide for UEFI 2.3.1 v1.01, 11 UEFI Driver and Controller Names.
 976 //
 977 // Device type names ("Virtio Block Device") are not formatted because the
 978 // driver supports only that device type. Therefore the driver name suffices
 979 // for unambiguous identification.
 980 //
 981
 982 STATIC
 983 EFI_UNICODE_STRING_TABLE mDriverNameTable[] = {
 984   { "eng;en", L"Virtio Block Driver" },
 985   { NULL,     NULL                   }
 986 };
 987
 988 STATIC
 989 EFI_COMPONENT_NAME_PROTOCOL gComponentName;
 990
 991 EFI_STATUS
 992 EFIAPI
 993 VirtioBlkGetDriverName (
 994   IN  EFI_COMPONENT_NAME_PROTOCOL *This,
 995   IN  CHAR8                       *Language,
 996   OUT CHAR16                      **DriverName
 997   )
 998 {
 999   return LookupUnicodeString2 (
1000            Language,
1001            This->SupportedLanguages,
1002            mDriverNameTable,
1003            DriverName,
1004            (BOOLEAN)(This == &gComponentName) // Iso639Language
1005            );
1006 }
1007
1008 EFI_STATUS
1009 EFIAPI
1010 VirtioBlkGetDeviceName (
1011   IN  EFI_COMPONENT_NAME_PROTOCOL *This,
1012   IN  EFI_HANDLE                  DeviceHandle,
1013   IN  EFI_HANDLE                  ChildHandle,
1014   IN  CHAR8                       *Language,
1015   OUT CHAR16                      **ControllerName
1016   )
1017 {
1018   return EFI_UNSUPPORTED;
1019 }
1020
1021 STATIC
1022 EFI_COMPONENT_NAME_PROTOCOL gComponentName = {
1023   &VirtioBlkGetDriverName,
1024   &VirtioBlkGetDeviceName,
1025   "eng" // SupportedLanguages, ISO 639-2 language codes
1026 };
1027
1028 STATIC
1029 EFI_COMPONENT_NAME2_PROTOCOL gComponentName2 = {
1030   (EFI_COMPONENT_NAME2_GET_DRIVER_NAME)     &VirtioBlkGetDriverName,
1031   (EFI_COMPONENT_NAME2_GET_CONTROLLER_NAME) &VirtioBlkGetDeviceName,
1032   "en" // SupportedLanguages, RFC 4646 language codes
1033 };
1034
1035
1036 //
1037 // Entry point of this driver.
1038 //
1039 EFI_STATUS
1040 EFIAPI
1041 VirtioBlkEntryPoint (
1042   IN EFI_HANDLE       ImageHandle,
1043   IN EFI_SYSTEM_TABLE *SystemTable
1044   )
1045 {
1046   return EfiLibInstallDriverBindingComponentName2 (
1047            ImageHandle,
1048            SystemTable,
1049            &gDriverBinding,
1050            ImageHandle,
1051            &gComponentName,
1052            &gComponentName2
1053            );
1054 }
1055