OvmfPkg/XenPvBlkDxe/BlockFront.c

   1 /** @file
   2   Minimal block driver for Mini-OS.
   3
   4   Copyright (c) 2007-2008 Samuel Thibault.
   5   Copyright (C) 2014, Citrix Ltd.
   6   Copyright (c) 2014, Intel Corporation. All rights reserved.<BR>
   7
   8   Redistribution and use in source and binary forms, with or without
   9   modification, are permitted provided that the following conditions
  10   are met:
  11   1. Redistributions of source code must retain the above copyright
  12      notice, this list of conditions and the following disclaimer.
  13   2. Redistributions in binary form must reproduce the above copyright
  14      notice, this list of conditions and the following disclaimer in the
  15      documentation and/or other materials provided with the distribution.
  16
  17   THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  18   ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20   ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
  21   FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22   DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23   OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24   HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25   LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26   OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27   SUCH DAMAGE.
  28 **/
  29
  30 #include <Library/PrintLib.h>
  31 #include <Library/DebugLib.h>
  32
  33 #include "BlockFront.h"
  34
  35 #include <IndustryStandard/Xen/io/protocols.h>
  36 #include <IndustryStandard/Xen/io/xenbus.h>
  37
  38 /**
  39   Helper to read an integer from XenStore.
  40
  41   If the number overflows according to the range defined by UINT64,
  42   then ASSERT().
  43
  44   @param This         A pointer to a XENBUS_PROTOCOL instance.
  45   @param Node         The XenStore node to read from.
  46   @param FromBackend  Read frontend or backend value.
  47   @param ValuePtr     Where to put the value.
  48
  49   @retval XENSTORE_STATUS_SUCCESS  If succefull, will update ValuePtr.
  50   @return                          Any other return value indicate the error,
  51                                    ValuePtr is not updated in this case.
  52 **/
  53 STATIC
  54 XENSTORE_STATUS
  55 XenBusReadUint64 (
  56   IN  XENBUS_PROTOCOL *This,
  57   IN  CONST CHAR8     *Node,
  58   IN  BOOLEAN         FromBackend,
  59   OUT UINT64          *ValuePtr
  60   )
  61 {
  62   XENSTORE_STATUS Status;
  63   CHAR8 *Ptr;
  64
  65   if (!FromBackend) {
  66     Status = This->XsRead (This, XST_NIL, Node, (VOID**)&Ptr);
  67   } else {
  68     Status = This->XsBackendRead (This, XST_NIL, Node, (VOID**)&Ptr);
  69   }
  70   if (Status != XENSTORE_STATUS_SUCCESS) {
  71     return Status;
  72   }
  73   // AsciiStrDecimalToUint64 will ASSERT if Ptr overflow UINT64.
  74   *ValuePtr = AsciiStrDecimalToUint64 (Ptr);
  75   FreePool (Ptr);
  76   return Status;
  77 }
  78
  79 /**
  80   Free an instance of XEN_BLOCK_FRONT_DEVICE.
  81
  82   @param Dev  The instance to free.
  83 **/
  84 STATIC
  85 VOID
  86 XenPvBlockFree (
  87   IN XEN_BLOCK_FRONT_DEVICE *Dev
  88   )
  89 {
  90   XENBUS_PROTOCOL *XenBusIo = Dev->XenBusIo;
  91
  92   if (Dev->RingRef != 0) {
  93     XenBusIo->GrantEndAccess (XenBusIo, Dev->RingRef);
  94   }
  95   if (Dev->Ring.sring != NULL) {
  96     FreePages (Dev->Ring.sring, 1);
  97   }
  98   if (Dev->EventChannel != 0) {
  99     XenBusIo->EventChannelClose (XenBusIo, Dev->EventChannel);
 100   }
 101   FreePool (Dev);
 102 }
 103
 104 /**
 105   Wait until until the backend has reached the ExpectedState.
 106
 107   @param Dev            A XEN_BLOCK_FRONT_DEVICE instance.
 108   @param ExpectedState  The backend state expected.
 109   @param LastStatePtr   An optional pointer where to right the final state.
 110
 111   @return Return XENSTORE_STATUS_SUCCESS if the new backend state is ExpectedState
 112           or return an error otherwise.
 113 **/
 114 STATIC
 115 XENSTORE_STATUS
 116 XenPvBlkWaitForBackendState (
 117   IN  XEN_BLOCK_FRONT_DEVICE *Dev,
 118   IN  XenbusState            ExpectedState,
 119   OUT XenbusState            *LastStatePtr OPTIONAL
 120   )
 121 {
 122   XENBUS_PROTOCOL *XenBusIo = Dev->XenBusIo;
 123   XenbusState State;
 124   UINT64 Value;
 125   XENSTORE_STATUS Status = XENSTORE_STATUS_SUCCESS;
 126
 127   while (TRUE) {
 128     Status = XenBusReadUint64 (XenBusIo, "state", TRUE, &Value);
 129     if (Status != XENSTORE_STATUS_SUCCESS) {
 130       return Status;
 131     }
 132     if (Value > XenbusStateReconfigured) {
 133       //
 134       // Value is not a State value.
 135       //
 136       return XENSTORE_STATUS_EIO;
 137     }
 138     State = Value;
 139     if (State == ExpectedState) {
 140       break;
 141     } else if (State > ExpectedState) {
 142       Status = XENSTORE_STATUS_FAIL;
 143       break;
 144     }
 145     DEBUG ((EFI_D_INFO,
 146             "XenPvBlk: waiting backend state %d, current: %d\n",
 147             ExpectedState, State));
 148     XenBusIo->WaitForWatch (XenBusIo, Dev->StateWatchToken);
 149   }
 150
 151   if (LastStatePtr != NULL) {
 152     *LastStatePtr = State;
 153   }
 154
 155   return Status;
 156 }
 157
 158 EFI_STATUS
 159 XenPvBlockFrontInitialization (
 160   IN  XENBUS_PROTOCOL         *XenBusIo,
 161   IN  CONST CHAR8             *NodeName,
 162   OUT XEN_BLOCK_FRONT_DEVICE  **DevPtr
 163   )
 164 {
 165   XENSTORE_TRANSACTION Transaction;
 166   CHAR8 *DeviceType;
 167   blkif_sring_t *SharedRing;
 168   XENSTORE_STATUS Status;
 169   XEN_BLOCK_FRONT_DEVICE *Dev;
 170   XenbusState State;
 171   UINT64 Value;
 172
 173   ASSERT (NodeName != NULL);
 174
 175   Dev = AllocateZeroPool (sizeof (XEN_BLOCK_FRONT_DEVICE));
 176   Dev->Signature = XEN_BLOCK_FRONT_SIGNATURE;
 177   Dev->NodeName = NodeName;
 178   Dev->XenBusIo = XenBusIo;
 179   Dev->DeviceId = XenBusIo->DeviceId;
 180
 181   XenBusIo->XsRead (XenBusIo, XST_NIL, "device-type", (VOID**)&DeviceType);
 182   if (AsciiStrCmp (DeviceType, "cdrom") == 0) {
 183     Dev->MediaInfo.CdRom = TRUE;
 184   } else {
 185     Dev->MediaInfo.CdRom = FALSE;
 186   }
 187   FreePool (DeviceType);
 188
 189   Status = XenBusReadUint64 (XenBusIo, "backend-id", FALSE, &Value);
 190   if (Status != XENSTORE_STATUS_SUCCESS || Value > MAX_UINT16) {
 191     DEBUG ((EFI_D_ERROR, "XenPvBlk: Failed to get backend-id (%d)\n",
 192             Status));
 193     goto Error;
 194   }
 195   Dev->DomainId = Value;
 196   XenBusIo->EventChannelAllocate (XenBusIo, Dev->DomainId, &Dev->EventChannel);
 197
 198   SharedRing = (blkif_sring_t*) AllocatePages (1);
 199   SHARED_RING_INIT (SharedRing);
 200   FRONT_RING_INIT (&Dev->Ring, SharedRing, EFI_PAGE_SIZE);
 201   XenBusIo->GrantAccess (XenBusIo,
 202                          Dev->DomainId,
 203                          (INTN) SharedRing >> EFI_PAGE_SHIFT,
 204                          FALSE,
 205                          &Dev->RingRef);
 206
 207 Again:
 208   Status = XenBusIo->XsTransactionStart (XenBusIo, &Transaction);
 209   if (Status != XENSTORE_STATUS_SUCCESS) {
 210     DEBUG ((EFI_D_WARN, "XenPvBlk: Failed to start transaction, %d\n", Status));
 211     goto Error;
 212   }
 213
 214   Status = XenBusIo->XsPrintf (XenBusIo, &Transaction, NodeName, "ring-ref", "%d",
 215                                Dev->RingRef);
 216   if (Status != XENSTORE_STATUS_SUCCESS) {
 217     DEBUG ((EFI_D_ERROR, "XenPvBlk: Failed to write ring-ref.\n"));
 218     goto AbortTransaction;
 219   }
 220   Status = XenBusIo->XsPrintf (XenBusIo, &Transaction, NodeName,
 221                                "event-channel", "%d", Dev->EventChannel);
 222   if (Status != XENSTORE_STATUS_SUCCESS) {
 223     DEBUG ((EFI_D_ERROR, "XenPvBlk: Failed to write event-channel.\n"));
 224     goto AbortTransaction;
 225   }
 226   Status = XenBusIo->XsPrintf (XenBusIo, &Transaction, NodeName,
 227                                "protocol", "%a", XEN_IO_PROTO_ABI_NATIVE);
 228   if (Status != XENSTORE_STATUS_SUCCESS) {
 229     DEBUG ((EFI_D_ERROR, "XenPvBlk: Failed to write protocol.\n"));
 230     goto AbortTransaction;
 231   }
 232
 233   Status = XenBusIo->SetState (XenBusIo, &Transaction, XenbusStateConnected);
 234   if (Status != XENSTORE_STATUS_SUCCESS) {
 235     DEBUG ((EFI_D_ERROR, "XenPvBlk: Failed to switch state.\n"));
 236     goto AbortTransaction;
 237   }
 238
 239   Status = XenBusIo->XsTransactionEnd (XenBusIo, &Transaction, FALSE);
 240   if (Status == XENSTORE_STATUS_EAGAIN) {
 241     goto Again;
 242   }
 243
 244   XenBusIo->RegisterWatchBackend (XenBusIo, "state", &Dev->StateWatchToken);
 245
 246   //
 247   // Waiting for backend
 248   //
 249   Status = XenPvBlkWaitForBackendState (Dev, XenbusStateConnected, &State);
 250   if (Status != XENSTORE_STATUS_SUCCESS) {
 251     DEBUG ((EFI_D_ERROR,
 252             "XenPvBlk: backend for %a/%d not available, rc=%d state=%d\n",
 253             XenBusIo->Type, XenBusIo->DeviceId, Status, State));
 254     goto Error2;
 255   }
 256
 257   Status = XenBusReadUint64 (XenBusIo, "info", TRUE, &Value);
 258   if (Status != XENSTORE_STATUS_SUCCESS || Value > MAX_UINT32) {
 259     goto Error2;
 260   }
 261   Dev->MediaInfo.VDiskInfo = Value;
 262   if (Dev->MediaInfo.VDiskInfo & VDISK_READONLY) {
 263     Dev->MediaInfo.ReadWrite = FALSE;
 264   } else {
 265     Dev->MediaInfo.ReadWrite = TRUE;
 266   }
 267
 268   Status = XenBusReadUint64 (XenBusIo, "sectors", TRUE, &Dev->MediaInfo.Sectors);
 269   if (Status != XENSTORE_STATUS_SUCCESS) {
 270     goto Error2;
 271   }
 272
 273   Status = XenBusReadUint64 (XenBusIo, "sector-size", TRUE, &Value);
 274   if (Status != XENSTORE_STATUS_SUCCESS || Value > MAX_UINT32) {
 275     goto Error2;
 276   }
 277   if (Value % 512 != 0) {
 278     //
 279     // This is not supported by the driver.
 280     //
 281     DEBUG ((EFI_D_ERROR, "XenPvBlk: Unsupported sector-size value %d, "
 282             "it must be a multiple of 512\n", Value));
 283     goto Error2;
 284   }
 285   Dev->MediaInfo.SectorSize = Value;
 286
 287   // Default value
 288   Value = 0;
 289   XenBusReadUint64 (XenBusIo, "feature-barrier", TRUE, &Value);
 290   if (Value == 1) {
 291     Dev->MediaInfo.FeatureBarrier = TRUE;
 292   } else {
 293     Dev->MediaInfo.FeatureBarrier = FALSE;
 294   }
 295
 296   // Default value
 297   Value = 0;
 298   XenBusReadUint64 (XenBusIo, "feature-flush-cache", TRUE, &Value);
 299   if (Value == 1) {
 300     Dev->MediaInfo.FeatureFlushCache = TRUE;
 301   } else {
 302     Dev->MediaInfo.FeatureFlushCache = FALSE;
 303   }
 304
 305   DEBUG ((EFI_D_INFO, "XenPvBlk: New disk with %ld sectors of %d bytes\n",
 306           Dev->MediaInfo.Sectors, Dev->MediaInfo.SectorSize));
 307
 308   *DevPtr = Dev;
 309   return EFI_SUCCESS;
 310
 311 Error2:
 312   XenBusIo->UnregisterWatch (XenBusIo, Dev->StateWatchToken);
 313   XenBusIo->XsRemove (XenBusIo, XST_NIL, "ring-ref");
 314   XenBusIo->XsRemove (XenBusIo, XST_NIL, "event-channel");
 315   XenBusIo->XsRemove (XenBusIo, XST_NIL, "protocol");
 316   goto Error;
 317 AbortTransaction:
 318   XenBusIo->XsTransactionEnd (XenBusIo, &Transaction, TRUE);
 319 Error:
 320   XenPvBlockFree (Dev);
 321   return EFI_DEVICE_ERROR;
 322 }
 323
 324 VOID
 325 XenPvBlockFrontShutdown (
 326   IN XEN_BLOCK_FRONT_DEVICE *Dev
 327   )
 328 {
 329   XENBUS_PROTOCOL *XenBusIo = Dev->XenBusIo;
 330   XENSTORE_STATUS Status;
 331   UINT64 Value;
 332
 333   XenPvBlockSync (Dev);
 334
 335   Status = XenBusIo->SetState (XenBusIo, XST_NIL, XenbusStateClosing);
 336   if (Status != XENSTORE_STATUS_SUCCESS) {
 337     DEBUG ((EFI_D_ERROR,
 338             "XenPvBlk: error while changing state to Closing: %d\n",
 339             Status));
 340     goto Close;
 341   }
 342
 343   Status = XenPvBlkWaitForBackendState (Dev, XenbusStateClosing, NULL);
 344   if (Status != XENSTORE_STATUS_SUCCESS) {
 345     DEBUG ((EFI_D_ERROR,
 346             "XenPvBlk: error while waiting for closing backend state: %d\n",
 347             Status));
 348     goto Close;
 349   }
 350
 351   Status = XenBusIo->SetState (XenBusIo, XST_NIL, XenbusStateClosed);
 352   if (Status != XENSTORE_STATUS_SUCCESS) {
 353     DEBUG ((EFI_D_ERROR,
 354             "XenPvBlk: error while changing state to Closed: %d\n",
 355             Status));
 356     goto Close;
 357   }
 358
 359   Status = XenPvBlkWaitForBackendState (Dev, XenbusStateClosed, NULL);
 360   if (Status != XENSTORE_STATUS_SUCCESS) {
 361     DEBUG ((EFI_D_ERROR,
 362             "XenPvBlk: error while waiting for closed backend state: %d\n",
 363             Status));
 364     goto Close;
 365   }
 366
 367   Status = XenBusIo->SetState (XenBusIo, XST_NIL, XenbusStateInitialising);
 368   if (Status != XENSTORE_STATUS_SUCCESS) {
 369     DEBUG ((EFI_D_ERROR,
 370             "XenPvBlk: error while changing state to initialising: %d\n",
 371             Status));
 372     goto Close;
 373   }
 374
 375   while (TRUE) {
 376     Status = XenBusReadUint64 (XenBusIo, "state", TRUE, &Value);
 377     if (Status != XENSTORE_STATUS_SUCCESS) {
 378       DEBUG ((EFI_D_ERROR,
 379               "XenPvBlk: error while waiting for new backend state: %d\n",
 380               Status));
 381       goto Close;
 382     }
 383     if (Value <= XenbusStateInitWait || Value >= XenbusStateClosed) {
 384       break;
 385     }
 386     DEBUG ((EFI_D_INFO,
 387             "XenPvBlk: waiting backend state %d, current: %d\n",
 388             XenbusStateInitWait, Value));
 389     XenBusIo->WaitForWatch (XenBusIo, Dev->StateWatchToken);
 390   }
 391
 392 Close:
 393   XenBusIo->UnregisterWatch (XenBusIo, Dev->StateWatchToken);
 394   XenBusIo->XsRemove (XenBusIo, XST_NIL, "ring-ref");
 395   XenBusIo->XsRemove (XenBusIo, XST_NIL, "event-channel");
 396   XenBusIo->XsRemove (XenBusIo, XST_NIL, "protocol");
 397
 398   XenPvBlockFree (Dev);
 399 }
 400
 401 STATIC
 402 VOID
 403 XenPvBlockWaitSlot (
 404   IN XEN_BLOCK_FRONT_DEVICE *Dev
 405   )
 406 {
 407   /* Wait for a slot */
 408   if (RING_FULL (&Dev->Ring)) {
 409     while (TRUE) {
 410       XenPvBlockAsyncIoPoll (Dev);
 411       if (!RING_FULL (&Dev->Ring)) {
 412         break;
 413       }
 414       /* Really no slot, could wait for an event on Dev->EventChannel. */
 415     }
 416   }
 417 }
 418
 419 VOID
 420 XenPvBlockAsyncIo (
 421   IN OUT XEN_BLOCK_FRONT_IO *IoData,
 422   IN     BOOLEAN            IsWrite
 423   )
 424 {
 425   XEN_BLOCK_FRONT_DEVICE *Dev = IoData->Dev;
 426   XENBUS_PROTOCOL *XenBusIo = Dev->XenBusIo;
 427   blkif_request_t *Request;
 428   RING_IDX RingIndex;
 429   BOOLEAN Notify;
 430   INT32 NumSegments, Index;
 431   UINTN Start, End;
 432
 433   // Can't io at non-sector-aligned location
 434   ASSERT(!(IoData->Sector & ((Dev->MediaInfo.SectorSize / 512) - 1)));
 435   // Can't io non-sector-sized amounts
 436   ASSERT(!(IoData->Size & (Dev->MediaInfo.SectorSize - 1)));
 437   // Can't io non-sector-aligned buffer
 438   ASSERT(!((UINTN) IoData->Buffer & (Dev->MediaInfo.SectorSize - 1)));
 439
 440   Start = (UINTN) IoData->Buffer & ~EFI_PAGE_MASK;
 441   End = ((UINTN) IoData->Buffer + IoData->Size + EFI_PAGE_SIZE - 1) & ~EFI_PAGE_MASK;
 442   IoData->NumRef = NumSegments = (End - Start) / EFI_PAGE_SIZE;
 443
 444   ASSERT (NumSegments <= BLKIF_MAX_SEGMENTS_PER_REQUEST);
 445
 446   XenPvBlockWaitSlot (Dev);
 447   RingIndex = Dev->Ring.req_prod_pvt;
 448   Request = RING_GET_REQUEST (&Dev->Ring, RingIndex);
 449
 450   Request->operation = IsWrite ? BLKIF_OP_WRITE : BLKIF_OP_READ;
 451   Request->nr_segments = NumSegments;
 452   Request->handle = Dev->DeviceId;
 453   Request->id = (UINTN) IoData;
 454   Request->sector_number = IoData->Sector;
 455
 456   for (Index = 0; Index < NumSegments; Index++) {
 457     Request->seg[Index].first_sect = 0;
 458     Request->seg[Index].last_sect = EFI_PAGE_SIZE / 512 - 1;
 459   }
 460   Request->seg[0].first_sect = ((UINTN) IoData->Buffer & EFI_PAGE_MASK) / 512;
 461   Request->seg[NumSegments - 1].last_sect =
 462       (((UINTN) IoData->Buffer + IoData->Size - 1) & EFI_PAGE_MASK) / 512;
 463   for (Index = 0; Index < NumSegments; Index++) {
 464     UINTN Data = Start + Index * EFI_PAGE_SIZE;
 465     XenBusIo->GrantAccess (XenBusIo, Dev->DomainId,
 466                            Data >> EFI_PAGE_SHIFT, IsWrite,
 467                            &Request->seg[Index].gref);
 468     IoData->GrantRef[Index] = Request->seg[Index].gref;
 469   }
 470
 471   Dev->Ring.req_prod_pvt = RingIndex + 1;
 472
 473   MemoryFence ();
 474   RING_PUSH_REQUESTS_AND_CHECK_NOTIFY (&Dev->Ring, Notify);
 475
 476   if (Notify) {
 477     UINT32 ReturnCode;
 478     ReturnCode = XenBusIo->EventChannelNotify (XenBusIo, Dev->EventChannel);
 479     if (ReturnCode != 0) {
 480       DEBUG ((EFI_D_ERROR,
 481               "XenPvBlk: Unexpected return value from EventChannelNotify: %d\n",
 482               ReturnCode));
 483     }
 484   }
 485 }
 486
 487 EFI_STATUS
 488 XenPvBlockIo (
 489   IN OUT XEN_BLOCK_FRONT_IO *IoData,
 490   IN     BOOLEAN            IsWrite
 491   )
 492 {
 493   //
 494   // Status value that correspond to an IO in progress.
 495   //
 496   IoData->Status = EFI_ALREADY_STARTED;
 497   XenPvBlockAsyncIo (IoData, IsWrite);
 498
 499   while (IoData->Status == EFI_ALREADY_STARTED) {
 500     XenPvBlockAsyncIoPoll (IoData->Dev);
 501   }
 502
 503   return IoData->Status;
 504 }
 505
 506 STATIC
 507 VOID
 508 XenPvBlockPushOperation (
 509   IN XEN_BLOCK_FRONT_DEVICE *Dev,
 510   IN UINT8                  Operation,
 511   IN UINT64                 Id
 512   )
 513 {
 514   INT32 Index;
 515   blkif_request_t *Request;
 516   BOOLEAN Notify;
 517
 518   XenPvBlockWaitSlot (Dev);
 519   Index = Dev->Ring.req_prod_pvt;
 520   Request = RING_GET_REQUEST(&Dev->Ring, Index);
 521   Request->operation = Operation;
 522   Request->nr_segments = 0;
 523   Request->handle = Dev->DeviceId;
 524   Request->id = Id;
 525   /* Not needed anyway, but the backend will check it */
 526   Request->sector_number = 0;
 527   Dev->Ring.req_prod_pvt = Index + 1;
 528   MemoryFence ();
 529   RING_PUSH_REQUESTS_AND_CHECK_NOTIFY (&Dev->Ring, Notify);
 530   if (Notify) {
 531     XENBUS_PROTOCOL *XenBusIo = Dev->XenBusIo;
 532     UINT32 ReturnCode;
 533     ReturnCode = XenBusIo->EventChannelNotify (XenBusIo, Dev->EventChannel);
 534     if (ReturnCode != 0) {
 535       DEBUG ((EFI_D_ERROR,
 536               "XenPvBlk: Unexpected return value from EventChannelNotify: %d\n",
 537               ReturnCode));
 538     }
 539   }
 540 }
 541
 542 VOID
 543 XenPvBlockSync (
 544   IN XEN_BLOCK_FRONT_DEVICE *Dev
 545   )
 546 {
 547   if (Dev->MediaInfo.ReadWrite) {
 548     if (Dev->MediaInfo.FeatureBarrier) {
 549       XenPvBlockPushOperation (Dev, BLKIF_OP_WRITE_BARRIER, 0);
 550     }
 551
 552     if (Dev->MediaInfo.FeatureFlushCache) {
 553       XenPvBlockPushOperation (Dev, BLKIF_OP_FLUSH_DISKCACHE, 0);
 554     }
 555   }
 556
 557   /* Note: This won't finish if another thread enqueues requests.  */
 558   while (TRUE) {
 559     XenPvBlockAsyncIoPoll (Dev);
 560     if (RING_FREE_REQUESTS (&Dev->Ring) == RING_SIZE (&Dev->Ring)) {
 561       break;
 562     }
 563   }
 564 }
 565
 566 VOID
 567 XenPvBlockAsyncIoPoll (
 568   IN XEN_BLOCK_FRONT_DEVICE *Dev
 569   )
 570 {
 571   RING_IDX ProducerIndex, ConsumerIndex;
 572   blkif_response_t *Response;
 573   INT32 More;
 574
 575   do {
 576     ProducerIndex = Dev->Ring.sring->rsp_prod;
 577     /* Ensure we see queued responses up to 'ProducerIndex'. */
 578     MemoryFence ();
 579     ConsumerIndex = Dev->Ring.rsp_cons;
 580
 581     while (ConsumerIndex != ProducerIndex) {
 582       XEN_BLOCK_FRONT_IO *IoData = NULL;
 583       INT16 Status;
 584
 585       Response = RING_GET_RESPONSE (&Dev->Ring, ConsumerIndex);
 586
 587       IoData = (VOID *) (UINTN) Response->id;
 588       Status = Response->status;
 589
 590       switch (Response->operation) {
 591       case BLKIF_OP_READ:
 592       case BLKIF_OP_WRITE:
 593         {
 594           INT32 Index;
 595
 596           if (Status != BLKIF_RSP_OKAY) {
 597             DEBUG ((EFI_D_ERROR,
 598                     "XenPvBlk: "
 599                     "%a error %d on %a at sector %p, num bytes %p\n",
 600                     Response->operation == BLKIF_OP_READ ? "read" : "write",
 601                     Status, IoData->Dev->NodeName,
 602                     IoData->Sector,
 603                     IoData->Size));
 604           }
 605
 606           for (Index = 0; Index < IoData->NumRef; Index++) {
 607             Dev->XenBusIo->GrantEndAccess (Dev->XenBusIo, IoData->GrantRef[Index]);
 608           }
 609
 610           break;
 611         }
 612
 613       case BLKIF_OP_WRITE_BARRIER:
 614         if (Status != BLKIF_RSP_OKAY) {
 615           DEBUG ((EFI_D_ERROR, "XenPvBlk: write barrier error %d\n", Status));
 616         }
 617         break;
 618       case BLKIF_OP_FLUSH_DISKCACHE:
 619         if (Status != BLKIF_RSP_OKAY) {
 620           DEBUG ((EFI_D_ERROR, "XenPvBlk: flush error %d\n", Status));
 621         }
 622         break;
 623
 624       default:
 625         DEBUG ((EFI_D_ERROR,
 626                 "XenPvBlk: unrecognized block operation %d response (status %d)\n",
 627                 Response->operation, Status));
 628         break;
 629       }
 630
 631       Dev->Ring.rsp_cons = ++ConsumerIndex;
 632       if (IoData != NULL) {
 633         IoData->Status = Status ? EFI_DEVICE_ERROR : EFI_SUCCESS;
 634       }
 635       if (Dev->Ring.rsp_cons != ConsumerIndex) {
 636         /* We reentered, we must not continue here */
 637         break;
 638       }
 639     }
 640
 641     RING_FINAL_CHECK_FOR_RESPONSES (&Dev->Ring, More);
 642   } while (More != 0);
 643 }