OvmfPkg/XenBusDxe/XenStore.c

   1 /** @file
   2   Low-level kernel interface to the XenStore.
   3
   4   The XenStore interface is a simple storage system that is a means of
   5   communicating state and configuration data between the Xen Domain 0
   6   and the various guest domains.  All configuration data other than
   7   a small amount of essential information required during the early
   8   boot process of launching a Xen aware guest, is managed using the
   9   XenStore.
  10
  11   The XenStore is ASCII string based, and has a structure and semantics
  12   similar to a filesystem.  There are files and directories, the directories
  13   able to contain files or other directories.  The depth of the hierachy
  14   is only limited by the XenStore's maximum path length.
  15
  16   The communication channel between the XenStore service and other
  17   domains is via two, guest specific, ring buffers in a shared memory
  18   area.  One ring buffer is used for communicating in each direction.
  19   The grant table references for this shared memory are given to the
  20   guest either via the xen_start_info structure for a fully para-
  21   virtualized guest, or via HVM hypercalls for a hardware virtualized
  22   guest.
  23
  24   The XenStore communication relies on an event channel and thus
  25   interrupts.  But under OVMF this XenStore client will pull the
  26   state of the event channel.
  27
  28   Several Xen services depend on the XenStore, most notably the
  29   XenBus used to discover and manage Xen devices.
  30
  31   Copyright (C) 2005 Rusty Russell, IBM Corporation
  32   Copyright (C) 2009,2010 Spectra Logic Corporation
  33   Copyright (C) 2014, Citrix Ltd.
  34
  35   This file may be distributed separately from the Linux kernel, or
  36   incorporated into other software packages, subject to the following license:
  37
  38   Permission is hereby granted, free of charge, to any person obtaining a copy
  39   of this source file (the "Software"), to deal in the Software without
  40   restriction, including without limitation the rights to use, copy, modify,
  41   merge, publish, distribute, sublicense, and/or sell copies of the Software,
  42   and to permit persons to whom the Software is furnished to do so, subject to
  43   the following conditions:
  44
  45   The above copyright notice and this permission notice shall be included in
  46   all copies or substantial portions of the Software.
  47
  48   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  49   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  50   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  51   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  52   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  53   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  54   IN THE SOFTWARE.
  55 **/
  56
  57 #include "XenStore.h"
  58
  59 #include <Library/PrintLib.h>
  60
  61 #include <IndustryStandard/Xen/hvm/params.h>
  62
  63 #include "XenHypercall.h"
  64 #include "EventChannel.h"
  65
  66 //
  67 // Private Data Structures
  68 //
  69
  70 typedef struct {
  71   CONST VOID  *Data;
  72   UINTN       Len;
  73 } WRITE_REQUEST;
  74
  75 /* Register callback to watch subtree (node) in the XenStore. */
  76 #define XENSTORE_WATCH_SIGNATURE SIGNATURE_32 ('X','S','w','a')
  77 struct _XENSTORE_WATCH
  78 {
  79   UINT32      Signature;
  80   LIST_ENTRY  Link;
  81
  82   /* Path being watched. */
  83   CHAR8       *Node;
  84 };
  85
  86 #define XENSTORE_WATCH_FROM_LINK(l) \
  87   CR (l, XENSTORE_WATCH, Link, XENSTORE_WATCH_SIGNATURE)
  88
  89
  90 /**
  91  * Structure capturing messages received from the XenStore service.
  92  */
  93 #define XENSTORE_MESSAGE_SIGNATURE SIGNATURE_32 ('X', 'S', 's', 'm')
  94 typedef struct {
  95   UINT32 Signature;
  96   LIST_ENTRY Link;
  97
  98   struct xsd_sockmsg Header;
  99
 100   union {
 101     /* Queued replies. */
 102     struct {
 103       CHAR8 *Body;
 104     } Reply;
 105
 106     /* Queued watch events. */
 107     struct {
 108       XENSTORE_WATCH *Handle;
 109       CONST CHAR8 **Vector;
 110       UINT32 VectorSize;
 111     } Watch;
 112   } u;
 113 } XENSTORE_MESSAGE;
 114 #define XENSTORE_MESSAGE_FROM_LINK(r) \
 115   CR (r, XENSTORE_MESSAGE, Link, XENSTORE_MESSAGE_SIGNATURE)
 116
 117 /**
 118  * Container for all XenStore related state.
 119  */
 120 typedef struct {
 121   /**
 122    * Pointer to shared memory communication structures allowing us
 123    * to communicate with the XenStore service.
 124    */
 125   struct xenstore_domain_interface *XenStore;
 126
 127   XENBUS_DEVICE *Dev;
 128
 129   /**
 130    * A list of replies to our requests.
 131    *
 132    * The reply list is filled by xs_rcv_thread().  It
 133    * is consumed by the context that issued the request
 134    * to which a reply is made.  The requester blocks in
 135    * XenStoreReadReply ().
 136    *
 137    * /note Only one requesting context can be active at a time.
 138    */
 139   LIST_ENTRY ReplyList;
 140
 141   /** Lock protecting the reply list. */
 142   EFI_LOCK ReplyLock;
 143
 144   /**
 145    * List of registered watches.
 146    */
 147   LIST_ENTRY RegisteredWatches;
 148
 149   /** Lock protecting the registered watches list. */
 150   EFI_LOCK RegisteredWatchesLock;
 151
 152   /**
 153    * List of pending watch callback events.
 154    */
 155   LIST_ENTRY WatchEvents;
 156
 157   /** Lock protecting the watch calback list. */
 158   EFI_LOCK WatchEventsLock;
 159
 160   /**
 161    * The event channel for communicating with the
 162    * XenStore service.
 163    */
 164   evtchn_port_t EventChannel;
 165
 166   /** Handle for XenStore events. */
 167   EFI_EVENT EventChannelEvent;
 168 } XENSTORE_PRIVATE;
 169
 170 //
 171 // Global Data
 172 //
 173 static XENSTORE_PRIVATE xs;
 174
 175
 176 //
 177 // Private Utility Functions
 178 //
 179
 180 /**
 181   Count and optionally record pointers to a number of NUL terminated
 182   strings in a buffer.
 183
 184   @param Strings  A pointer to a contiguous buffer of NUL terminated strings.
 185   @param Len      The length of the buffer pointed to by strings.
 186   @param Dst      An array to store pointers to each string found in strings.
 187
 188   @return  A count of the number of strings found.
 189 **/
 190 STATIC
 191 UINT32
 192 ExtractStrings (
 193   IN  CONST CHAR8 *Strings,
 194   IN  UINTN       Len,
 195   OUT CONST CHAR8 **Dst OPTIONAL
 196   )
 197 {
 198   UINT32 Num = 0;
 199   CONST CHAR8 *Ptr;
 200
 201   for (Ptr = Strings; Ptr < Strings + Len; Ptr += AsciiStrSize (Ptr)) {
 202     if (Dst != NULL) {
 203       *Dst++ = Ptr;
 204     }
 205     Num++;
 206   }
 207
 208   return Num;
 209 }
 210
 211 /**
 212   Convert a contiguous buffer containing a series of NUL terminated
 213   strings into an array of pointers to strings.
 214
 215   The returned pointer references the array of string pointers which
 216   is followed by the storage for the string data.  It is the client's
 217   responsibility to free this storage.
 218
 219   The storage addressed by Strings is free'd prior to Split returning.
 220
 221   @param Strings  A pointer to a contiguous buffer of NUL terminated strings.
 222   @param Len      The length of the buffer pointed to by strings.
 223   @param NumPtr   The number of strings found and returned in the strings
 224                   array.
 225
 226   @return  An array of pointers to the strings found in the input buffer.
 227 **/
 228 STATIC
 229 CONST CHAR8 **
 230 Split (
 231   IN  CHAR8   *Strings,
 232   IN  UINTN   Len,
 233   OUT UINT32  *NumPtr
 234   )
 235 {
 236   CONST CHAR8 **Dst;
 237
 238   ASSERT(NumPtr != NULL);
 239   ASSERT(Strings != NULL);
 240
 241   /* Protect against unterminated buffers. */
 242   if (Len > 0) {
 243     Strings[Len - 1] = '\0';
 244   }
 245
 246   /* Count the Strings. */
 247   *NumPtr = ExtractStrings (Strings, Len, NULL);
 248
 249   /* Transfer to one big alloc for easy freeing by the caller. */
 250   Dst = AllocatePool (*NumPtr * sizeof (CHAR8 *) + Len);
 251   CopyMem (&Dst[*NumPtr], Strings, Len);
 252   FreePool (Strings);
 253
 254   /* Extract pointers to newly allocated array. */
 255   Strings = (CHAR8 *) &Dst[*NumPtr];
 256   ExtractStrings (Strings, Len, Dst);
 257
 258   return (Dst);
 259 }
 260
 261 /**
 262   Convert from watch token (unique identifier) to the associated
 263   internal tracking structure for this watch.
 264
 265   @param Tocken  The unique identifier for the watch to find.
 266
 267   @return  A pointer to the found watch structure or NULL.
 268 **/
 269 STATIC
 270 XENSTORE_WATCH *
 271 XenStoreFindWatch (
 272   IN CONST CHAR8 *Token
 273   )
 274 {
 275   XENSTORE_WATCH *Watch, *WantedWatch;
 276   LIST_ENTRY *Entry;
 277
 278   WantedWatch = (VOID *) AsciiStrHexToUintn (Token);
 279
 280   if (IsListEmpty (&xs.RegisteredWatches)) {
 281     return NULL;
 282   }
 283   for (Entry = GetFirstNode (&xs.RegisteredWatches);
 284        !IsNull (&xs.RegisteredWatches, Entry);
 285        Entry = GetNextNode (&xs.RegisteredWatches, Entry)) {
 286     Watch = XENSTORE_WATCH_FROM_LINK (Entry);
 287     if (Watch == WantedWatch)
 288       return Watch;
 289   }
 290
 291   return NULL;
 292 }
 293
 294 //
 295 // Public Utility Functions
 296 // API comments for these methods can be found in XenStore.h
 297 //
 298
 299 CHAR8 *
 300 XenStoreJoin (
 301   IN CONST CHAR8 *DirectoryPath,
 302   IN CONST CHAR8 *Node
 303   )
 304 {
 305   CHAR8 *Buf;
 306
 307   /* +1 for '/' and +1 for '\0' */
 308   Buf = AllocateZeroPool (
 309           AsciiStrLen (DirectoryPath) + AsciiStrLen (Node) + 2);
 310   AsciiStrCat (Buf, DirectoryPath);
 311   if (Node[0] != '\0') {
 312     AsciiStrCat (Buf, "/");
 313     AsciiStrCat (Buf, Node);
 314   }
 315
 316   return Buf;
 317 }
 318
 319 //
 320 // Low Level Communication Management
 321 //
 322
 323 /**
 324   Verify that the indexes for a ring are valid.
 325
 326   The difference between the producer and consumer cannot
 327   exceed the size of the ring.
 328
 329   @param Cons  The consumer index for the ring to test.
 330   @param Prod  The producer index for the ring to test.
 331
 332   @retval TRUE   If indexes are in range.
 333   @retval FALSE  If the indexes are out of range.
 334 **/
 335 STATIC
 336 BOOLEAN
 337 XenStoreCheckIndexes (
 338   XENSTORE_RING_IDX Cons,
 339   XENSTORE_RING_IDX Prod
 340   )
 341 {
 342   return ((Prod - Cons) <= XENSTORE_RING_SIZE);
 343 }
 344
 345 /**
 346   Return a pointer to, and the length of, the contiguous
 347   free region available for output in a ring buffer.
 348
 349   @param Cons    The consumer index for the ring.
 350   @param Prod    The producer index for the ring.
 351   @param Buffer  The base address of the ring's storage.
 352   @param LenPtr  The amount of contiguous storage available.
 353
 354   @return  A pointer to the start location of the free region.
 355 **/
 356 STATIC
 357 VOID *
 358 XenStoreGetOutputChunk (
 359   IN  XENSTORE_RING_IDX Cons,
 360   IN  XENSTORE_RING_IDX Prod,
 361   IN  CHAR8             *Buffer,
 362   OUT UINT32            *LenPtr
 363   )
 364 {
 365   UINT32 Len;
 366   Len = XENSTORE_RING_SIZE - MASK_XENSTORE_IDX (Prod);
 367   if ((XENSTORE_RING_SIZE - (Prod - Cons)) < Len) {
 368     Len = XENSTORE_RING_SIZE - (Prod - Cons);
 369   }
 370   *LenPtr = Len;
 371   return (Buffer + MASK_XENSTORE_IDX (Prod));
 372 }
 373
 374 /**
 375   Return a pointer to, and the length of, the contiguous
 376   data available to read from a ring buffer.
 377
 378   @param Cons    The consumer index for the ring.
 379   @param Prod    The producer index for the ring.
 380   @param Buffer  The base address of the ring's storage.
 381   @param LenPtr  The amount of contiguous data available to read.
 382
 383   @return  A pointer to the start location of the available data.
 384 **/
 385 STATIC
 386 CONST VOID *
 387 XenStoreGetInputChunk (
 388   IN  XENSTORE_RING_IDX Cons,
 389   IN  XENSTORE_RING_IDX Prod,
 390   IN  CONST CHAR8       *Buffer,
 391   OUT UINT32            *LenPtr
 392   )
 393 {
 394   UINT32 Len;
 395
 396   Len = XENSTORE_RING_SIZE - MASK_XENSTORE_IDX (Cons);
 397   if ((Prod - Cons) < Len) {
 398     Len = Prod - Cons;
 399   }
 400   *LenPtr = Len;
 401   return (Buffer + MASK_XENSTORE_IDX (Cons));
 402 }
 403
 404 /**
 405   Wait for an event or timeout.
 406
 407   @param Event    Event to wait for.
 408   @param Timeout  A timeout value in 100ns units.
 409
 410   @retval EFI_SUCCESS   Event have been triggered or the current TPL is not
 411                         TPL_APPLICATION.
 412   @retval EFI_TIMEOUT   Timeout have expired.
 413 **/
 414 STATIC
 415 EFI_STATUS
 416 XenStoreWaitForEvent (
 417   IN EFI_EVENT Event,
 418   IN UINT64    Timeout
 419   )
 420 {
 421   UINTN Index;
 422   EFI_STATUS Status;
 423   EFI_EVENT TimerEvent;
 424   EFI_EVENT WaitList[2];
 425
 426   gBS->CreateEvent (EVT_TIMER, 0, NULL, NULL, &TimerEvent);
 427   gBS->SetTimer (TimerEvent, TimerRelative, Timeout);
 428
 429   WaitList[0] = xs.EventChannelEvent;
 430   WaitList[1] = TimerEvent;
 431   Status = gBS->WaitForEvent (2, WaitList, &Index);
 432   ASSERT (Status != EFI_INVALID_PARAMETER);
 433   gBS->CloseEvent (TimerEvent);
 434   if (Status == EFI_UNSUPPORTED) {
 435     return EFI_SUCCESS;
 436   }
 437   if (Index == 1) {
 438     return EFI_TIMEOUT;
 439   } else {
 440     return EFI_SUCCESS;
 441   }
 442 }
 443
 444 /**
 445   Transmit data to the XenStore service.
 446
 447   The buffer pointed to by DataPtr is at least Len bytes in length.
 448
 449   @param DataPtr  A pointer to the contiguous data to send.
 450   @param Len      The amount of data to send.
 451
 452   @return  On success 0, otherwise an errno value indicating the
 453            cause of failure.
 454 **/
 455 STATIC
 456 XENSTORE_STATUS
 457 XenStoreWriteStore (
 458   IN CONST VOID *DataPtr,
 459   IN UINTN      Len
 460   )
 461 {
 462   XENSTORE_RING_IDX Cons, Prod;
 463   CONST CHAR8 *Data = (CONST CHAR8 *)DataPtr;
 464
 465   while (Len != 0) {
 466     void *Dest;
 467     UINT32 Available;
 468
 469     Cons = xs.XenStore->req_cons;
 470     Prod = xs.XenStore->req_prod;
 471     if ((Prod - Cons) == XENSTORE_RING_SIZE) {
 472       /*
 473        * Output ring is full. Wait for a ring event.
 474        *
 475        * Note that the events from both queues are combined, so being woken
 476        * does not guarantee that data exist in the read ring.
 477        */
 478       EFI_STATUS Status;
 479
 480       Status = XenStoreWaitForEvent (xs.EventChannelEvent,
 481                                      EFI_TIMER_PERIOD_SECONDS (1));
 482       if (Status == EFI_TIMEOUT) {
 483         DEBUG ((EFI_D_WARN, "XenStore Write, waiting for a ring event.\n"));
 484       }
 485       continue;
 486     }
 487
 488     /* Verify queue sanity. */
 489     if (!XenStoreCheckIndexes (Cons, Prod)) {
 490       xs.XenStore->req_cons = xs.XenStore->req_prod = 0;
 491       return XENSTORE_STATUS_EIO;
 492     }
 493
 494     Dest = XenStoreGetOutputChunk (Cons, Prod, xs.XenStore->req, &Available);
 495     if (Available > Len) {
 496       Available = Len;
 497     }
 498
 499     CopyMem (Dest, Data, Available);
 500     Data += Available;
 501     Len -= Available;
 502
 503     /*
 504      * The store to the producer index, which indicates
 505      * to the other side that new data has arrived, must
 506      * be visible only after our copy of the data into the
 507      * ring has completed.
 508      */
 509     MemoryFence ();
 510     xs.XenStore->req_prod += Available;
 511
 512     /*
 513      * The other side will see the change to req_prod at the time of the
 514      * interrupt.
 515      */
 516     MemoryFence ();
 517     XenEventChannelNotify (xs.Dev, xs.EventChannel);
 518   }
 519
 520   return XENSTORE_STATUS_SUCCESS;
 521 }
 522
 523 /**
 524   Receive data from the XenStore service.
 525
 526   The buffer pointed to by DataPtr is at least Len bytes in length.
 527
 528   @param DataPtr  A pointer to the contiguous buffer to receive the data.
 529   @param Len      The amount of data to receive.
 530
 531   @return  On success 0, otherwise an errno value indicating the
 532            cause of failure.
 533 **/
 534 STATIC
 535 XENSTORE_STATUS
 536 XenStoreReadStore (
 537   OUT VOID *DataPtr,
 538   IN  UINTN Len
 539   )
 540 {
 541   XENSTORE_RING_IDX Cons, Prod;
 542   CHAR8 *Data = (CHAR8 *) DataPtr;
 543
 544   while (Len != 0) {
 545     UINT32 Available;
 546     CONST CHAR8 *Src;
 547
 548     Cons = xs.XenStore->rsp_cons;
 549     Prod = xs.XenStore->rsp_prod;
 550     if (Cons == Prod) {
 551       /*
 552        * Nothing to read. Wait for a ring event.
 553        *
 554        * Note that the events from both queues are combined, so being woken
 555        * does not guarantee that data exist in the read ring.
 556        */
 557       EFI_STATUS Status;
 558
 559       Status = XenStoreWaitForEvent (xs.EventChannelEvent,
 560                                      EFI_TIMER_PERIOD_SECONDS (1));
 561       if (Status == EFI_TIMEOUT) {
 562         DEBUG ((EFI_D_WARN, "XenStore Read, waiting for a ring event.\n"));
 563       }
 564       continue;
 565     }
 566
 567     /* Verify queue sanity. */
 568     if (!XenStoreCheckIndexes (Cons, Prod)) {
 569       xs.XenStore->rsp_cons = xs.XenStore->rsp_prod = 0;
 570       return XENSTORE_STATUS_EIO;
 571     }
 572
 573     Src = XenStoreGetInputChunk (Cons, Prod, xs.XenStore->rsp, &Available);
 574     if (Available > Len) {
 575       Available = Len;
 576     }
 577
 578     /*
 579      * Insure the data we read is related to the indexes
 580      * we read above.
 581      */
 582     MemoryFence ();
 583
 584     CopyMem (Data, Src, Available);
 585     Data += Available;
 586     Len -= Available;
 587
 588     /*
 589      * Insure that the producer of this ring does not see
 590      * the ring space as free until after we have copied it
 591      * out.
 592      */
 593     MemoryFence ();
 594     xs.XenStore->rsp_cons += Available;
 595
 596     /*
 597      * The producer will see the updated consumer index when the event is
 598      * delivered.
 599      */
 600     MemoryFence ();
 601     XenEventChannelNotify (xs.Dev, xs.EventChannel);
 602   }
 603
 604   return XENSTORE_STATUS_SUCCESS;
 605 }
 606
 607 //
 608 // Received Message Processing
 609 //
 610
 611 /**
 612   Block reading the next message from the XenStore service and
 613   process the result.
 614
 615   @return  XENSTORE_STATUS_SUCCESS on success.  Otherwise an errno value
 616            indicating the type of failure encountered.
 617 **/
 618 STATIC
 619 XENSTORE_STATUS
 620 XenStoreProcessMessage (
 621   VOID
 622   )
 623 {
 624   XENSTORE_MESSAGE *Message;
 625   CHAR8 *Body;
 626   XENSTORE_STATUS Status;
 627
 628   Message = AllocateZeroPool (sizeof (XENSTORE_MESSAGE));
 629   Message->Signature = XENSTORE_MESSAGE_SIGNATURE;
 630   Status = XenStoreReadStore (&Message->Header, sizeof (Message->Header));
 631   if (Status != XENSTORE_STATUS_SUCCESS) {
 632     FreePool (Message);
 633     DEBUG ((EFI_D_ERROR, "XenStore: Error read store (%d)\n", Status));
 634     return Status;
 635   }
 636
 637   Body = AllocatePool (Message->Header.len + 1);
 638   Status = XenStoreReadStore (Body, Message->Header.len);
 639   if (Status != XENSTORE_STATUS_SUCCESS) {
 640     FreePool (Body);
 641     FreePool (Message);
 642     DEBUG ((EFI_D_ERROR, "XenStore: Error read store (%d)\n", Status));
 643     return Status;
 644   }
 645   Body[Message->Header.len] = '\0';
 646
 647   if (Message->Header.type == XS_WATCH_EVENT) {
 648     Message->u.Watch.Vector = Split(Body, Message->Header.len,
 649                                     &Message->u.Watch.VectorSize);
 650
 651     EfiAcquireLock (&xs.RegisteredWatchesLock);
 652     Message->u.Watch.Handle =
 653       XenStoreFindWatch (Message->u.Watch.Vector[XS_WATCH_TOKEN]);
 654     DEBUG ((EFI_D_INFO, "XenStore: Watch event %a\n",
 655             Message->u.Watch.Vector[XS_WATCH_TOKEN]));
 656     if (Message->u.Watch.Handle != NULL) {
 657       EfiAcquireLock (&xs.WatchEventsLock);
 658       InsertHeadList (&xs.WatchEvents, &Message->Link);
 659       EfiReleaseLock (&xs.WatchEventsLock);
 660     } else {
 661       DEBUG ((EFI_D_WARN, "XenStore: Watch handle %a not found\n",
 662               Message->u.Watch.Vector[XS_WATCH_TOKEN]));
 663       FreePool(Message->u.Watch.Vector);
 664       FreePool(Message);
 665     }
 666     EfiReleaseLock (&xs.RegisteredWatchesLock);
 667   } else {
 668     Message->u.Reply.Body = Body;
 669     EfiAcquireLock (&xs.ReplyLock);
 670     InsertTailList (&xs.ReplyList, &Message->Link);
 671     EfiReleaseLock (&xs.ReplyLock);
 672   }
 673
 674   return XENSTORE_STATUS_SUCCESS;
 675 }
 676
 677 //
 678 // XenStore Message Request/Reply Processing
 679 //
 680
 681 /**
 682   Convert a XenStore error string into an errno number.
 683
 684   Unknown error strings are converted to EINVAL.
 685
 686   @param errorstring  The error string to convert.
 687
 688   @return  The errno best matching the input string.
 689
 690 **/
 691 typedef struct {
 692   XENSTORE_STATUS Status;
 693   CONST CHAR8 *ErrorStr;
 694 } XenStoreErrors;
 695
 696 static XenStoreErrors gXenStoreErrors[] = {
 697   { XENSTORE_STATUS_EINVAL, "EINVAL" },
 698   { XENSTORE_STATUS_EACCES, "EACCES" },
 699   { XENSTORE_STATUS_EEXIST, "EEXIST" },
 700   { XENSTORE_STATUS_EISDIR, "EISDIR" },
 701   { XENSTORE_STATUS_ENOENT, "ENOENT" },
 702   { XENSTORE_STATUS_ENOMEM, "ENOMEM" },
 703   { XENSTORE_STATUS_ENOSPC, "ENOSPC" },
 704   { XENSTORE_STATUS_EIO, "EIO" },
 705   { XENSTORE_STATUS_ENOTEMPTY, "ENOTEMPTY" },
 706   { XENSTORE_STATUS_ENOSYS, "ENOSYS" },
 707   { XENSTORE_STATUS_EROFS, "EROFS" },
 708   { XENSTORE_STATUS_EBUSY, "EBUSY" },
 709   { XENSTORE_STATUS_EAGAIN, "EAGAIN" },
 710   { XENSTORE_STATUS_EISCONN, "EISCONN" },
 711   { XENSTORE_STATUS_E2BIG, "E2BIG" }
 712 };
 713 #define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
 714
 715 STATIC
 716 XENSTORE_STATUS
 717 XenStoreGetError (
 718   CONST CHAR8 *ErrorStr
 719   )
 720 {
 721   UINT32 Index;
 722
 723   for (Index = 0; Index < ARRAY_SIZE(gXenStoreErrors); Index++) {
 724     if (!AsciiStrCmp (ErrorStr, gXenStoreErrors[Index].ErrorStr)) {
 725       return gXenStoreErrors[Index].Status;
 726     }
 727   }
 728   DEBUG ((EFI_D_WARN, "XenStore gave unknown error %a\n", ErrorStr));
 729   return XENSTORE_STATUS_EINVAL;
 730 }
 731
 732 /**
 733   Block waiting for a reply to a message request.
 734
 735   @param TypePtr The returned type of the reply.
 736   @param LenPtr  The returned body length of the reply.
 737   @param Result  The returned body of the reply.
 738 **/
 739 STATIC
 740 XENSTORE_STATUS
 741 XenStoreReadReply (
 742   OUT enum xsd_sockmsg_type *TypePtr,
 743   OUT UINT32 *LenPtr OPTIONAL,
 744   OUT VOID **Result
 745   )
 746 {
 747   XENSTORE_MESSAGE *Message;
 748   LIST_ENTRY *Entry;
 749   CHAR8 *Body;
 750
 751   while (IsListEmpty (&xs.ReplyList)) {
 752     XENSTORE_STATUS Status;
 753     Status = XenStoreProcessMessage ();
 754     if (Status != XENSTORE_STATUS_SUCCESS && Status != XENSTORE_STATUS_EAGAIN) {
 755       DEBUG ((EFI_D_ERROR, "XenStore, error while reading the ring (%d).",
 756               Status));
 757       return Status;
 758     }
 759   }
 760   EfiAcquireLock (&xs.ReplyLock);
 761   Entry = GetFirstNode (&xs.ReplyList);
 762   Message = XENSTORE_MESSAGE_FROM_LINK (Entry);
 763   RemoveEntryList (Entry);
 764   EfiReleaseLock (&xs.ReplyLock);
 765
 766   *TypePtr = Message->Header.type;
 767   if (LenPtr != NULL) {
 768     *LenPtr = Message->Header.len;
 769   }
 770   Body = Message->u.Reply.Body;
 771
 772   FreePool (Message);
 773   *Result = Body;
 774   return XENSTORE_STATUS_SUCCESS;
 775 }
 776
 777 /**
 778   Send a message with an optionally muti-part body to the XenStore service.
 779
 780   @param Transaction    The transaction to use for this request.
 781   @param RequestType    The type of message to send.
 782   @param WriteRequest   Pointers to the body sections of the request.
 783   @param NumRequests    The number of body sections in the request.
 784   @param LenPtr         The returned length of the reply.
 785   @param ResultPtr      The returned body of the reply.
 786
 787   @return  XENSTORE_STATUS_SUCCESS on success.  Otherwise an errno indicating
 788            the cause of failure.
 789 **/
 790 STATIC
 791 XENSTORE_STATUS
 792 XenStoreTalkv (
 793   IN  XENSTORE_TRANSACTION    Transaction,
 794   IN  enum xsd_sockmsg_type   RequestType,
 795   IN  CONST WRITE_REQUEST     *WriteRequest,
 796   IN  UINT32                  NumRequests,
 797   OUT UINT32                  *LenPtr OPTIONAL,
 798   OUT VOID                    **ResultPtr OPTIONAL
 799   )
 800 {
 801   struct xsd_sockmsg Message;
 802   void *Return = NULL;
 803   UINT32 Index;
 804   XENSTORE_STATUS Status;
 805
 806   Message.tx_id = Transaction.Id;
 807   Message.req_id = 0;
 808   Message.type = RequestType;
 809   Message.len = 0;
 810   for (Index = 0; Index < NumRequests; Index++) {
 811     Message.len += WriteRequest[Index].Len;
 812   }
 813
 814   Status = XenStoreWriteStore (&Message, sizeof (Message));
 815   if (Status != XENSTORE_STATUS_SUCCESS) {
 816     DEBUG ((EFI_D_ERROR, "XenStoreTalkv failed %d\n", Status));
 817     goto Error;
 818   }
 819
 820   for (Index = 0; Index < NumRequests; Index++) {
 821     Status = XenStoreWriteStore (WriteRequest[Index].Data, WriteRequest[Index].Len);
 822     if (Status != XENSTORE_STATUS_SUCCESS) {
 823       DEBUG ((EFI_D_ERROR, "XenStoreTalkv failed %d\n", Status));
 824       goto Error;
 825     }
 826   }
 827
 828   Status = XenStoreReadReply (&Message.type, LenPtr, &Return);
 829
 830 Error:
 831   if (Status != XENSTORE_STATUS_SUCCESS) {
 832     return Status;
 833   }
 834
 835   if (Message.type == XS_ERROR) {
 836     Status = XenStoreGetError (Return);
 837     FreePool (Return);
 838     return Status;
 839   }
 840
 841   /* Reply is either error or an echo of our request message type. */
 842   ASSERT (Message.type == RequestType);
 843
 844   if (ResultPtr) {
 845     *ResultPtr = Return;
 846   } else {
 847     FreePool (Return);
 848   }
 849
 850   return XENSTORE_STATUS_SUCCESS;
 851 }
 852
 853 /**
 854   Wrapper for XenStoreTalkv allowing easy transmission of a message with
 855   a single, contiguous, message body.
 856
 857   The returned result is provided in malloced storage and thus must be free'd
 858   by the caller.
 859
 860   @param Transaction    The transaction to use for this request.
 861   @param RequestType    The type of message to send.
 862   @param Body           The body of the request.
 863   @param LenPtr         The returned length of the reply.
 864   @param Result         The returned body of the reply.
 865
 866   @return  0 on success.  Otherwise an errno indicating
 867            the cause of failure.
 868 **/
 869 STATIC
 870 XENSTORE_STATUS
 871 XenStoreSingle (
 872   IN  XENSTORE_TRANSACTION    Transaction,
 873   IN  enum xsd_sockmsg_type   RequestType,
 874   IN  CONST CHAR8             *Body,
 875   OUT UINT32                  *LenPtr OPTIONAL,
 876   OUT VOID                    **Result OPTIONAL
 877   )
 878 {
 879   WRITE_REQUEST WriteRequest;
 880
 881   WriteRequest.Data = (VOID *) Body;
 882   WriteRequest.Len = AsciiStrSize (Body);
 883
 884   return XenStoreTalkv (Transaction, RequestType, &WriteRequest, 1,
 885                         LenPtr, Result);
 886 }
 887
 888 //
 889 // XenStore Watch Support
 890 //
 891
 892 /**
 893   Transmit a watch request to the XenStore service.
 894
 895   @param Path    The path in the XenStore to watch.
 896   @param Tocken  A unique identifier for this watch.
 897
 898   @return  XENSTORE_STATUS_SUCCESS on success.  Otherwise an errno indicating the
 899            cause of failure.
 900 **/
 901 STATIC
 902 XENSTORE_STATUS
 903 XenStoreWatch (
 904   CONST CHAR8 *Path,
 905   CONST CHAR8 *Token
 906   )
 907 {
 908   WRITE_REQUEST WriteRequest[2];
 909
 910   WriteRequest[0].Data = (VOID *) Path;
 911   WriteRequest[0].Len = AsciiStrSize (Path);
 912   WriteRequest[1].Data = (VOID *) Token;
 913   WriteRequest[1].Len = AsciiStrSize (Token);
 914
 915   return XenStoreTalkv (XST_NIL, XS_WATCH, WriteRequest, 2, NULL, NULL);
 916 }
 917
 918 /**
 919   Transmit an uwatch request to the XenStore service.
 920
 921   @param Path    The path in the XenStore to watch.
 922   @param Tocken  A unique identifier for this watch.
 923
 924   @return  XENSTORE_STATUS_SUCCESS on success.  Otherwise an errno indicating
 925            the cause of failure.
 926 **/
 927 STATIC
 928 XENSTORE_STATUS
 929 XenStoreUnwatch (
 930   CONST CHAR8 *Path,
 931   CONST CHAR8 *Token
 932   )
 933 {
 934   WRITE_REQUEST WriteRequest[2];
 935
 936   WriteRequest[0].Data = (VOID *) Path;
 937   WriteRequest[0].Len = AsciiStrSize (Path);
 938   WriteRequest[1].Data = (VOID *) Token;
 939   WriteRequest[1].Len = AsciiStrSize (Token);
 940
 941   return XenStoreTalkv (XST_NIL, XS_UNWATCH, WriteRequest, 2, NULL, NULL);
 942 }
 943
 944 STATIC
 945 XENSTORE_STATUS
 946 XenStoreWaitWatch (
 947   VOID *Token
 948   )
 949 {
 950   XENSTORE_MESSAGE *Message;
 951   LIST_ENTRY *Entry = NULL;
 952   LIST_ENTRY *Last = NULL;
 953   XENSTORE_STATUS Status;
 954
 955   while (TRUE) {
 956     EfiAcquireLock (&xs.WatchEventsLock);
 957     if (IsListEmpty (&xs.WatchEvents) ||
 958         Last == GetFirstNode (&xs.WatchEvents)) {
 959       EfiReleaseLock (&xs.WatchEventsLock);
 960       Status = XenStoreProcessMessage ();
 961       if (Status != XENSTORE_STATUS_SUCCESS && Status != XENSTORE_STATUS_EAGAIN) {
 962         return Status;
 963       }
 964       continue;
 965     }
 966
 967     for (Entry = GetFirstNode (&xs.WatchEvents);
 968          Entry != Last && !IsNull (&xs.WatchEvents, Entry);
 969          Entry = GetNextNode (&xs.WatchEvents, Entry)) {
 970       Message = XENSTORE_MESSAGE_FROM_LINK (Entry);
 971       if (Message->u.Watch.Handle == Token) {
 972         RemoveEntryList (Entry);
 973         EfiReleaseLock (&xs.WatchEventsLock);
 974         FreePool(Message->u.Watch.Vector);
 975         FreePool(Message);
 976         return XENSTORE_STATUS_SUCCESS;
 977       }
 978     }
 979     Last = GetFirstNode (&xs.WatchEvents);
 980     EfiReleaseLock (&xs.WatchEventsLock);
 981   }
 982 }
 983
 984 VOID
 985 EFIAPI
 986 NotifyEventChannelCheckForEvent (
 987   IN EFI_EVENT Event,
 988   IN VOID *Context
 989   )
 990 {
 991   XENSTORE_PRIVATE *xs;
 992   xs = (XENSTORE_PRIVATE *)Context;
 993   if (TestAndClearBit (xs->EventChannel, xs->Dev->SharedInfo->evtchn_pending)) {
 994     gBS->SignalEvent (Event);
 995   }
 996 }
 997
 998 /**
 999   Setup communication channels with the XenStore service.
1000
1001   @retval EFI_SUCCESS if everything went well.
1002 **/
1003 STATIC
1004 EFI_STATUS
1005 XenStoreInitComms (
1006   XENSTORE_PRIVATE *xs
1007   )
1008 {
1009   EFI_STATUS Status;
1010   EFI_EVENT TimerEvent;
1011   struct xenstore_domain_interface *XenStore = xs->XenStore;
1012
1013   Status = gBS->CreateEvent (EVT_TIMER, 0, NULL, NULL, &TimerEvent);
1014   Status = gBS->SetTimer (TimerEvent, TimerRelative,
1015                           EFI_TIMER_PERIOD_SECONDS (5));
1016   while (XenStore->rsp_prod != XenStore->rsp_cons) {
1017     Status = gBS->CheckEvent (TimerEvent);
1018     if (!EFI_ERROR (Status)) {
1019       DEBUG ((EFI_D_WARN, "XENSTORE response ring is not quiescent "
1020               "(%08x:%08x): fixing up\n",
1021               XenStore->rsp_cons, XenStore->rsp_prod));
1022       XenStore->rsp_cons = XenStore->rsp_prod;
1023     }
1024   }
1025   gBS->CloseEvent (TimerEvent);
1026
1027   Status = gBS->CreateEvent (EVT_NOTIFY_WAIT, TPL_NOTIFY,
1028                              NotifyEventChannelCheckForEvent, xs,
1029                              &xs->EventChannelEvent);
1030   ASSERT_EFI_ERROR (Status);
1031
1032   return Status;
1033 }
1034
1035 /**
1036   Initialize XenStore.
1037
1038   @param Dev  A XENBUS_DEVICE instance.
1039
1040   @retval EFI_SUCCESS if everything went well.
1041 **/
1042 EFI_STATUS
1043 XenStoreInit (
1044   XENBUS_DEVICE *Dev
1045   )
1046 {
1047   EFI_STATUS Status;
1048   /**
1049    * The HVM guest pseudo-physical frame number.  This is Xen's mapping
1050    * of the true machine frame number into our "physical address space".
1051    */
1052   UINTN XenStoreGpfn;
1053
1054   xs.Dev = Dev;
1055
1056   xs.EventChannel = XenHypercallHvmGetParam (Dev, HVM_PARAM_STORE_EVTCHN);
1057   XenStoreGpfn = XenHypercallHvmGetParam (Dev, HVM_PARAM_STORE_PFN);
1058   xs.XenStore = (VOID *) (XenStoreGpfn << EFI_PAGE_SHIFT);
1059   DEBUG ((EFI_D_INFO, "XenBusInit: XenBus rings @%p, event channel %x\n",
1060           xs.XenStore, xs.EventChannel));
1061
1062   InitializeListHead (&xs.ReplyList);
1063   InitializeListHead (&xs.WatchEvents);
1064   InitializeListHead (&xs.RegisteredWatches);
1065
1066   EfiInitializeLock (&xs.ReplyLock, TPL_NOTIFY);
1067   EfiInitializeLock (&xs.RegisteredWatchesLock, TPL_NOTIFY);
1068   EfiInitializeLock (&xs.WatchEventsLock, TPL_NOTIFY);
1069
1070   /* Initialize the shared memory rings to talk to xenstored */
1071   Status = XenStoreInitComms (&xs);
1072   if (EFI_ERROR (Status)) {
1073     return Status;
1074   }
1075
1076   return Status;
1077 }
1078
1079 VOID
1080 XenStoreDeinit (
1081   IN XENBUS_DEVICE *Dev
1082   )
1083 {
1084   //
1085   // Emptying the list RegisteredWatches, but this list should already be
1086   // empty. Every driver that is using Watches should unregister them when
1087   // it is stopped.
1088   //
1089   if (!IsListEmpty (&xs.RegisteredWatches)) {
1090     XENSTORE_WATCH *Watch;
1091     LIST_ENTRY *Entry;
1092     DEBUG ((EFI_D_WARN, "XenStore: RegisteredWatches is not empty, cleaning up..."));
1093     Entry = GetFirstNode (&xs.RegisteredWatches);
1094     while (!IsNull (&xs.RegisteredWatches, Entry)) {
1095       Watch = XENSTORE_WATCH_FROM_LINK (Entry);
1096       Entry = GetNextNode (&xs.RegisteredWatches, Entry);
1097
1098       XenStoreUnregisterWatch (Watch);
1099     }
1100   }
1101
1102   //
1103   // Emptying the list WatchEvents, but this list should already be empty after
1104   // having cleanup the list RegisteredWatches.
1105   //
1106   if (!IsListEmpty (&xs.WatchEvents)) {
1107     LIST_ENTRY *Entry;
1108     DEBUG ((EFI_D_WARN, "XenStore: WatchEvents is not empty, cleaning up..."));
1109     Entry = GetFirstNode (&xs.WatchEvents);
1110     while (!IsNull (&xs.WatchEvents, Entry)) {
1111       XENSTORE_MESSAGE *Message = XENSTORE_MESSAGE_FROM_LINK (Entry);
1112       Entry = GetNextNode (&xs.WatchEvents, Entry);
1113       RemoveEntryList (&Message->Link);
1114       FreePool (Message->u.Watch.Vector);
1115       FreePool (Message);
1116     }
1117   }
1118
1119   if (!IsListEmpty (&xs.ReplyList)) {
1120     XENSTORE_MESSAGE *Message;
1121     LIST_ENTRY *Entry;
1122     Entry = GetFirstNode (&xs.ReplyList);
1123     while (!IsNull (&xs.ReplyList, Entry)) {
1124       Message = XENSTORE_MESSAGE_FROM_LINK (Entry);
1125       Entry = GetNextNode (&xs.ReplyList, Entry);
1126       RemoveEntryList (&Message->Link);
1127       FreePool (Message->u.Reply.Body);
1128       FreePool (Message);
1129     }
1130   }
1131
1132   gBS->CloseEvent (xs.EventChannelEvent);
1133
1134   if (xs.XenStore->server_features & XENSTORE_SERVER_FEATURE_RECONNECTION) {
1135     xs.XenStore->connection = XENSTORE_RECONNECT;
1136     XenEventChannelNotify (xs.Dev, xs.EventChannel);
1137     while (*(volatile UINT32*)&xs.XenStore->connection == XENSTORE_RECONNECT) {
1138       XenStoreWaitForEvent (xs.EventChannelEvent, EFI_TIMER_PERIOD_MILLISECONDS (100));
1139     }
1140   } else {
1141     /* If the backend reads the state while we're erasing it then the
1142      * ring state will become corrupted, preventing guest frontends from
1143      * connecting. This is rare. To help diagnose the failure, we fill
1144      * the ring with XS_INVALID packets. */
1145     SetMem (xs.XenStore->req, XENSTORE_RING_SIZE, 0xff);
1146     SetMem (xs.XenStore->rsp, XENSTORE_RING_SIZE, 0xff);
1147     xs.XenStore->req_cons = xs.XenStore->req_prod = 0;
1148     xs.XenStore->rsp_cons = xs.XenStore->rsp_prod = 0;
1149   }
1150   xs.XenStore = NULL;
1151 }
1152
1153 //
1154 // Public API
1155 // API comments for these methods can be found in XenStore.h
1156 //
1157
1158 XENSTORE_STATUS
1159 XenStoreListDirectory (
1160   IN  XENSTORE_TRANSACTION  Transaction,
1161   IN  CONST CHAR8           *DirectoryPath,
1162   IN  CONST CHAR8           *Node,
1163   OUT UINT32                *DirectoryCountPtr,
1164   OUT CONST CHAR8           ***DirectoryListPtr
1165   )
1166 {
1167   CHAR8 *Path;
1168   CHAR8 *TempStr;
1169   UINT32 Len = 0;
1170   XENSTORE_STATUS Status;
1171
1172   Path = XenStoreJoin (DirectoryPath, Node);
1173   Status = XenStoreSingle (Transaction, XS_DIRECTORY, Path, &Len,
1174                            (VOID **) &TempStr);
1175   FreePool (Path);
1176   if (Status != XENSTORE_STATUS_SUCCESS) {
1177     return Status;
1178   }
1179
1180   *DirectoryListPtr = Split (TempStr, Len, DirectoryCountPtr);
1181
1182   return XENSTORE_STATUS_SUCCESS;
1183 }
1184
1185 BOOLEAN
1186 XenStorePathExists (
1187   IN XENSTORE_TRANSACTION  Transaction,
1188   IN CONST CHAR8           *Directory,
1189   IN CONST CHAR8           *Node
1190   )
1191 {
1192   CONST CHAR8 **TempStr;
1193   XENSTORE_STATUS Status;
1194   UINT32 TempNum;
1195
1196   Status = XenStoreListDirectory (Transaction, Directory, Node,
1197                                   &TempNum, &TempStr);
1198   if (Status != XENSTORE_STATUS_SUCCESS) {
1199     return FALSE;
1200   }
1201   FreePool (TempStr);
1202   return TRUE;
1203 }
1204
1205 XENSTORE_STATUS
1206 XenStoreRead (
1207   IN  XENSTORE_TRANSACTION    Transaction,
1208   IN  CONST CHAR8             *DirectoryPath,
1209   IN  CONST CHAR8             *Node,
1210   OUT UINT32                  *LenPtr OPTIONAL,
1211   OUT VOID                    **Result
1212   )
1213 {
1214   CHAR8 *Path;
1215   VOID *Value;
1216   XENSTORE_STATUS Status;
1217
1218   Path = XenStoreJoin (DirectoryPath, Node);
1219   Status = XenStoreSingle (Transaction, XS_READ, Path, LenPtr, &Value);
1220   FreePool (Path);
1221   if (Status != XENSTORE_STATUS_SUCCESS) {
1222     return Status;
1223   }
1224
1225   *Result = Value;
1226   return XENSTORE_STATUS_SUCCESS;
1227 }
1228
1229 XENSTORE_STATUS
1230 XenStoreWrite (
1231   IN XENSTORE_TRANSACTION  Transaction,
1232   IN CONST CHAR8           *DirectoryPath,
1233   IN CONST CHAR8           *Node,
1234   IN CONST CHAR8           *Str
1235   )
1236 {
1237   CHAR8 *Path;
1238   WRITE_REQUEST WriteRequest[2];
1239   XENSTORE_STATUS Status;
1240
1241   Path = XenStoreJoin (DirectoryPath, Node);
1242
1243   WriteRequest[0].Data = (VOID *) Path;
1244   WriteRequest[0].Len = AsciiStrSize (Path);
1245   WriteRequest[1].Data = (VOID *) Str;
1246   WriteRequest[1].Len = AsciiStrLen (Str);
1247
1248   Status = XenStoreTalkv (Transaction, XS_WRITE, WriteRequest, 2, NULL, NULL);
1249   FreePool (Path);
1250
1251   return Status;
1252 }
1253
1254 XENSTORE_STATUS
1255 XenStoreRemove (
1256   IN XENSTORE_TRANSACTION   Transaction,
1257   IN CONST CHAR8            *DirectoryPath,
1258   IN CONST CHAR8            *Node
1259   )
1260 {
1261   CHAR8 *Path;
1262   XENSTORE_STATUS Status;
1263
1264   Path = XenStoreJoin (DirectoryPath, Node);
1265   Status = XenStoreSingle (Transaction, XS_RM, Path, NULL, NULL);
1266   FreePool (Path);
1267
1268   return Status;
1269 }
1270
1271 XENSTORE_STATUS
1272 XenStoreTransactionStart (
1273   OUT XENSTORE_TRANSACTION  *Transaction
1274   )
1275 {
1276   CHAR8 *IdStr;
1277   XENSTORE_STATUS Status;
1278
1279   Status = XenStoreSingle (XST_NIL, XS_TRANSACTION_START, "", NULL,
1280                            (VOID **) &IdStr);
1281   if (Status == XENSTORE_STATUS_SUCCESS) {
1282     Transaction->Id = AsciiStrDecimalToUintn (IdStr);
1283     FreePool (IdStr);
1284   }
1285
1286   return Status;
1287 }
1288
1289 XENSTORE_STATUS
1290 XenStoreTransactionEnd (
1291   IN XENSTORE_TRANSACTION   Transaction,
1292   IN BOOLEAN                Abort
1293   )
1294 {
1295   CHAR8 AbortStr[2];
1296
1297   if (Abort) {
1298     AsciiStrCpy (AbortStr, "F");
1299   } else {
1300     AsciiStrCpy (AbortStr, "T");
1301   }
1302
1303   return XenStoreSingle (Transaction, XS_TRANSACTION_END, AbortStr, NULL, NULL);
1304 }
1305
1306 XENSTORE_STATUS
1307 XenStoreVSPrint (
1308   IN XENSTORE_TRANSACTION  Transaction,
1309   IN CONST CHAR8           *DirectoryPath,
1310   IN CONST CHAR8           *Node,
1311   IN CONST CHAR8           *FormatString,
1312   IN VA_LIST               Marker
1313   )
1314 {
1315   CHAR8 *Buf;
1316   XENSTORE_STATUS Status;
1317   UINTN BufSize;
1318
1319   BufSize = SPrintLengthAsciiFormat (FormatString, Marker) + 1;
1320   Buf = AllocateZeroPool (BufSize);
1321   AsciiVSPrint (Buf, BufSize, FormatString, Marker);
1322   Status = XenStoreWrite (Transaction, DirectoryPath, Node, Buf);
1323   FreePool (Buf);
1324
1325   return Status;
1326 }
1327
1328 XENSTORE_STATUS
1329 EFIAPI
1330 XenStoreSPrint (
1331   IN XENSTORE_TRANSACTION   Transaction,
1332   IN CONST CHAR8            *DirectoryPath,
1333   IN CONST CHAR8            *Node,
1334   IN CONST CHAR8            *FormatString,
1335   ...
1336   )
1337 {
1338   VA_LIST Marker;
1339   XENSTORE_STATUS Status;
1340
1341   VA_START (Marker, FormatString);
1342   Status = XenStoreVSPrint (Transaction, DirectoryPath, Node, FormatString, Marker);
1343   VA_END (Marker);
1344
1345   return Status;
1346 }
1347
1348 XENSTORE_STATUS
1349 XenStoreRegisterWatch (
1350   IN CONST CHAR8      *DirectoryPath,
1351   IN CONST CHAR8      *Node,
1352   OUT XENSTORE_WATCH  **WatchPtr
1353   )
1354 {
1355   /* Pointer in ascii is the token. */
1356   CHAR8 Token[sizeof (XENSTORE_WATCH) * 2 + 1];
1357   XENSTORE_STATUS Status;
1358   XENSTORE_WATCH *Watch;
1359
1360   Watch = AllocateZeroPool (sizeof (XENSTORE_WATCH));
1361   Watch->Signature = XENSTORE_WATCH_SIGNATURE;
1362   Watch->Node = XenStoreJoin (DirectoryPath, Node);
1363
1364   EfiAcquireLock (&xs.RegisteredWatchesLock);
1365   InsertTailList (&xs.RegisteredWatches, &Watch->Link);
1366   EfiReleaseLock (&xs.RegisteredWatchesLock);
1367
1368   AsciiSPrint (Token, sizeof (Token), "%p", (VOID*) Watch);
1369   Status = XenStoreWatch (Watch->Node, Token);
1370
1371   /* Ignore errors due to multiple registration. */
1372   if (Status == XENSTORE_STATUS_EEXIST) {
1373     Status = XENSTORE_STATUS_SUCCESS;
1374   }
1375
1376   if (Status == XENSTORE_STATUS_SUCCESS) {
1377     *WatchPtr = Watch;
1378   } else {
1379     EfiAcquireLock (&xs.RegisteredWatchesLock);
1380     RemoveEntryList (&Watch->Link);
1381     EfiReleaseLock (&xs.RegisteredWatchesLock);
1382     FreePool (Watch->Node);
1383     FreePool (Watch);
1384   }
1385
1386   return Status;
1387 }
1388
1389 VOID
1390 XenStoreUnregisterWatch (
1391   IN XENSTORE_WATCH *Watch
1392   )
1393 {
1394   CHAR8 Token[sizeof (Watch) * 2 + 1];
1395   LIST_ENTRY *Entry;
1396
1397   ASSERT (Watch->Signature == XENSTORE_WATCH_SIGNATURE);
1398
1399   AsciiSPrint (Token, sizeof (Token), "%p", (VOID *) Watch);
1400   if (XenStoreFindWatch (Token) == NULL) {
1401     return;
1402   }
1403
1404   EfiAcquireLock (&xs.RegisteredWatchesLock);
1405   RemoveEntryList (&Watch->Link);
1406   EfiReleaseLock (&xs.RegisteredWatchesLock);
1407
1408   XenStoreUnwatch (Watch->Node, Token);
1409
1410   /* Cancel pending watch events. */
1411   EfiAcquireLock (&xs.WatchEventsLock);
1412   Entry = GetFirstNode (&xs.WatchEvents);
1413   while (!IsNull (&xs.WatchEvents, Entry)) {
1414     XENSTORE_MESSAGE *Message = XENSTORE_MESSAGE_FROM_LINK (Entry);
1415     Entry = GetNextNode (&xs.WatchEvents, Entry);
1416     if (Message->u.Watch.Handle == Watch) {
1417       RemoveEntryList (&Message->Link);
1418       FreePool (Message->u.Watch.Vector);
1419       FreePool (Message);
1420     }
1421   }
1422   EfiReleaseLock (&xs.WatchEventsLock);
1423
1424   FreePool (Watch->Node);
1425   FreePool (Watch);
1426 }
1427
1428
1429 //
1430 // XENBUS protocol
1431 //
1432
1433 XENSTORE_STATUS
1434 EFIAPI
1435 XenBusWaitForWatch (
1436   IN XENBUS_PROTOCOL *This,
1437   IN VOID *Token
1438   )
1439 {
1440   return XenStoreWaitWatch (Token);
1441 }
1442
1443 XENSTORE_STATUS
1444 EFIAPI
1445 XenBusXenStoreRead (
1446   IN  XENBUS_PROTOCOL       *This,
1447   IN  XENSTORE_TRANSACTION  Transaction,
1448   IN  CONST CHAR8           *Node,
1449   OUT VOID                  **Value
1450   )
1451 {
1452   return XenStoreRead (Transaction, This->Node, Node, NULL, Value);
1453 }
1454
1455 XENSTORE_STATUS
1456 EFIAPI
1457 XenBusXenStoreBackendRead (
1458   IN  XENBUS_PROTOCOL       *This,
1459   IN  XENSTORE_TRANSACTION  Transaction,
1460   IN  CONST CHAR8           *Node,
1461   OUT VOID                  **Value
1462   )
1463 {
1464   return XenStoreRead (Transaction, This->Backend, Node, NULL, Value);
1465 }
1466
1467 XENSTORE_STATUS
1468 EFIAPI
1469 XenBusXenStoreRemove (
1470   IN XENBUS_PROTOCOL        *This,
1471   IN XENSTORE_TRANSACTION   Transaction,
1472   IN const char             *Node
1473   )
1474 {
1475   return XenStoreRemove (Transaction, This->Node, Node);
1476 }
1477
1478 XENSTORE_STATUS
1479 EFIAPI
1480 XenBusXenStoreTransactionStart (
1481   IN  XENBUS_PROTOCOL       *This,
1482   OUT XENSTORE_TRANSACTION  *Transaction
1483   )
1484 {
1485   return XenStoreTransactionStart (Transaction);
1486 }
1487
1488 XENSTORE_STATUS
1489 EFIAPI
1490 XenBusXenStoreTransactionEnd (
1491   IN XENBUS_PROTOCOL        *This,
1492   IN XENSTORE_TRANSACTION   Transaction,
1493   IN BOOLEAN                Abort
1494   )
1495 {
1496   return XenStoreTransactionEnd (Transaction, Abort);
1497 }
1498
1499 XENSTORE_STATUS
1500 EFIAPI
1501 XenBusXenStoreSPrint (
1502   IN XENBUS_PROTOCOL        *This,
1503   IN XENSTORE_TRANSACTION   Transaction,
1504   IN CONST CHAR8            *DirectoryPath,
1505   IN CONST CHAR8            *Node,
1506   IN CONST CHAR8            *FormatString,
1507   ...
1508   )
1509 {
1510   VA_LIST Marker;
1511   XENSTORE_STATUS Status;
1512
1513   VA_START (Marker, FormatString);
1514   Status = XenStoreVSPrint (Transaction, DirectoryPath, Node, FormatString, Marker);
1515   VA_END (Marker);
1516
1517   return Status;
1518 }
1519
1520 XENSTORE_STATUS
1521 EFIAPI
1522 XenBusRegisterWatch (
1523   IN  XENBUS_PROTOCOL *This,
1524   IN  CONST CHAR8     *Node,
1525   OUT VOID            **Token
1526   )
1527 {
1528   return XenStoreRegisterWatch (This->Node, Node, (XENSTORE_WATCH **) Token);
1529 }
1530
1531 XENSTORE_STATUS
1532 EFIAPI
1533 XenBusRegisterWatchBackend (
1534   IN  XENBUS_PROTOCOL *This,
1535   IN  CONST CHAR8     *Node,
1536   OUT VOID            **Token
1537   )
1538 {
1539   return XenStoreRegisterWatch (This->Backend, Node, (XENSTORE_WATCH **) Token);
1540 }
1541
1542 VOID
1543 EFIAPI
1544 XenBusUnregisterWatch (
1545   IN XENBUS_PROTOCOL  *This,
1546   IN VOID             *Token
1547   )
1548 {
1549   XenStoreUnregisterWatch ((XENSTORE_WATCH *) Token);
1550 }