2 Low-level kernel interface to the XenStore.
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
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 hierarchy
14 is only limited by the XenStore's maximum path length.
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
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.
28 Several Xen services depend on the XenStore, most notably the
29 XenBus used to discover and manage Xen devices.
31 Copyright (C) 2005 Rusty Russell, IBM Corporation
32 Copyright (C) 2009,2010 Spectra Logic Corporation
33 Copyright (C) 2014, Citrix Ltd.
35 This file may be distributed separately from the Linux kernel, or
36 incorporated into other software packages, subject to the following license:
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:
45 The above copyright notice and this permission notice shall be included in
46 all copies or substantial portions of the Software.
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
59 #include <Library/PrintLib.h>
61 #include <IndustryStandard/Xen/hvm/params.h>
63 #include "EventChannel.h"
64 #include <Library/XenHypercallLib.h>
67 // Private Data Structures
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
82 /* Path being watched. */
86 #define XENSTORE_WATCH_FROM_LINK(l) \
87 CR (l, XENSTORE_WATCH, Link, XENSTORE_WATCH_SIGNATURE)
91 * Structure capturing messages received from the XenStore service.
93 #define XENSTORE_MESSAGE_SIGNATURE SIGNATURE_32 ('X', 'S', 's', 'm')
98 struct xsd_sockmsg Header
;
101 /* Queued replies. */
106 /* Queued watch events. */
108 XENSTORE_WATCH
*Handle
;
109 CONST CHAR8
**Vector
;
114 #define XENSTORE_MESSAGE_FROM_LINK(r) \
115 CR (r, XENSTORE_MESSAGE, Link, XENSTORE_MESSAGE_SIGNATURE)
118 * Container for all XenStore related state.
122 * Pointer to shared memory communication structures allowing us
123 * to communicate with the XenStore service.
125 struct xenstore_domain_interface
*XenStore
;
130 * A list of replies to our requests.
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 ().
137 * /note Only one requesting context can be active at a time.
139 LIST_ENTRY ReplyList
;
141 /** Lock protecting the reply list. */
145 * List of registered watches.
147 LIST_ENTRY RegisteredWatches
;
149 /** Lock protecting the registered watches list. */
150 EFI_LOCK RegisteredWatchesLock
;
153 * List of pending watch callback events.
155 LIST_ENTRY WatchEvents
;
157 /** Lock protecting the watch calback list. */
158 EFI_LOCK WatchEventsLock
;
161 * The event channel for communicating with the
164 evtchn_port_t EventChannel
;
166 /** Handle for XenStore events. */
167 EFI_EVENT EventChannelEvent
;
173 static XENSTORE_PRIVATE xs
;
177 // Private Utility Functions
181 Count and optionally record pointers to a number of NUL terminated
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.
188 @return A count of the number of strings found.
193 IN CONST CHAR8
*Strings
,
195 OUT CONST CHAR8
**Dst OPTIONAL
201 for (Ptr
= Strings
; Ptr
< Strings
+ Len
; Ptr
+= AsciiStrSize (Ptr
)) {
212 Convert a contiguous buffer containing a series of NUL terminated
213 strings into an array of pointers to strings.
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.
219 The storage addressed by Strings is free'd prior to Split returning.
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
226 @return An array of pointers to the strings found in the input buffer.
238 ASSERT(NumPtr
!= NULL
);
239 ASSERT(Strings
!= NULL
);
241 /* Protect against unterminated buffers. */
243 Strings
[Len
- 1] = '\0';
246 /* Count the Strings. */
247 *NumPtr
= ExtractStrings (Strings
, Len
, NULL
);
249 /* Transfer to one big alloc for easy freeing by the caller. */
250 Dst
= AllocatePool (*NumPtr
* sizeof (CHAR8
*) + Len
);
251 CopyMem ((VOID
*)&Dst
[*NumPtr
], Strings
, Len
);
254 /* Extract pointers to newly allocated array. */
255 Strings
= (CHAR8
*) &Dst
[*NumPtr
];
256 ExtractStrings (Strings
, Len
, Dst
);
262 Convert from watch token (unique identifier) to the associated
263 internal tracking structure for this watch.
265 @param Tocken The unique identifier for the watch to find.
267 @return A pointer to the found watch structure or NULL.
272 IN CONST CHAR8
*Token
275 XENSTORE_WATCH
*Watch
, *WantedWatch
;
278 WantedWatch
= (VOID
*) AsciiStrHexToUintn (Token
);
280 if (IsListEmpty (&xs
.RegisteredWatches
)) {
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
)
295 // Public Utility Functions
296 // API comments for these methods can be found in XenStore.h
301 IN CONST CHAR8
*DirectoryPath
,
308 /* +1 for '/' and +1 for '\0' */
309 BufSize
= AsciiStrLen (DirectoryPath
) + AsciiStrLen (Node
) + 2;
310 Buf
= AllocatePool (BufSize
);
311 ASSERT (Buf
!= NULL
);
313 if (Node
[0] == '\0') {
314 AsciiSPrint (Buf
, BufSize
, "%a", DirectoryPath
);
316 AsciiSPrint (Buf
, BufSize
, "%a/%a", DirectoryPath
, Node
);
323 // Low Level Communication Management
327 Verify that the indexes for a ring are valid.
329 The difference between the producer and consumer cannot
330 exceed the size of the ring.
332 @param Cons The consumer index for the ring to test.
333 @param Prod The producer index for the ring to test.
335 @retval TRUE If indexes are in range.
336 @retval FALSE If the indexes are out of range.
340 XenStoreCheckIndexes (
341 XENSTORE_RING_IDX Cons
,
342 XENSTORE_RING_IDX Prod
345 return ((Prod
- Cons
) <= XENSTORE_RING_SIZE
);
349 Return a pointer to, and the length of, the contiguous
350 free region available for output in a ring buffer.
352 @param Cons The consumer index for the ring.
353 @param Prod The producer index for the ring.
354 @param Buffer The base address of the ring's storage.
355 @param LenPtr The amount of contiguous storage available.
357 @return A pointer to the start location of the free region.
361 XenStoreGetOutputChunk (
362 IN XENSTORE_RING_IDX Cons
,
363 IN XENSTORE_RING_IDX Prod
,
369 Len
= XENSTORE_RING_SIZE
- MASK_XENSTORE_IDX (Prod
);
370 if ((XENSTORE_RING_SIZE
- (Prod
- Cons
)) < Len
) {
371 Len
= XENSTORE_RING_SIZE
- (Prod
- Cons
);
374 return (Buffer
+ MASK_XENSTORE_IDX (Prod
));
378 Return a pointer to, and the length of, the contiguous
379 data available to read from a ring buffer.
381 @param Cons The consumer index for the ring.
382 @param Prod The producer index for the ring.
383 @param Buffer The base address of the ring's storage.
384 @param LenPtr The amount of contiguous data available to read.
386 @return A pointer to the start location of the available data.
390 XenStoreGetInputChunk (
391 IN XENSTORE_RING_IDX Cons
,
392 IN XENSTORE_RING_IDX Prod
,
393 IN CONST CHAR8
*Buffer
,
399 Len
= XENSTORE_RING_SIZE
- MASK_XENSTORE_IDX (Cons
);
400 if ((Prod
- Cons
) < Len
) {
404 return (Buffer
+ MASK_XENSTORE_IDX (Cons
));
408 Wait for an event or timeout.
410 @param Event Event to wait for.
411 @param Timeout A timeout value in 100ns units.
413 @retval EFI_SUCCESS Event have been triggered or the current TPL is not
415 @retval EFI_TIMEOUT Timeout have expired.
419 XenStoreWaitForEvent (
426 EFI_EVENT TimerEvent
;
427 EFI_EVENT WaitList
[2];
429 gBS
->CreateEvent (EVT_TIMER
, 0, NULL
, NULL
, &TimerEvent
);
430 gBS
->SetTimer (TimerEvent
, TimerRelative
, Timeout
);
432 WaitList
[0] = xs
.EventChannelEvent
;
433 WaitList
[1] = TimerEvent
;
434 Status
= gBS
->WaitForEvent (2, WaitList
, &Index
);
435 ASSERT (Status
!= EFI_INVALID_PARAMETER
);
436 gBS
->CloseEvent (TimerEvent
);
437 if (Status
== EFI_UNSUPPORTED
) {
448 Transmit data to the XenStore service.
450 The buffer pointed to by DataPtr is at least Len bytes in length.
452 @param DataPtr A pointer to the contiguous data to send.
453 @param Len The amount of data to send.
455 @return On success 0, otherwise an errno value indicating the
461 IN CONST VOID
*DataPtr
,
465 XENSTORE_RING_IDX Cons
, Prod
;
466 CONST CHAR8
*Data
= (CONST CHAR8
*)DataPtr
;
472 Cons
= xs
.XenStore
->req_cons
;
473 Prod
= xs
.XenStore
->req_prod
;
474 if ((Prod
- Cons
) == XENSTORE_RING_SIZE
) {
476 * Output ring is full. Wait for a ring event.
478 * Note that the events from both queues are combined, so being woken
479 * does not guarantee that data exist in the read ring.
483 Status
= XenStoreWaitForEvent (xs
.EventChannelEvent
,
484 EFI_TIMER_PERIOD_SECONDS (1));
485 if (Status
== EFI_TIMEOUT
) {
486 DEBUG ((EFI_D_WARN
, "XenStore Write, waiting for a ring event.\n"));
491 /* Verify queue sanity. */
492 if (!XenStoreCheckIndexes (Cons
, Prod
)) {
493 xs
.XenStore
->req_cons
= xs
.XenStore
->req_prod
= 0;
494 return XENSTORE_STATUS_EIO
;
497 Dest
= XenStoreGetOutputChunk (Cons
, Prod
, xs
.XenStore
->req
, &Available
);
498 if (Available
> Len
) {
502 CopyMem (Dest
, Data
, Available
);
507 * The store to the producer index, which indicates
508 * to the other side that new data has arrived, must
509 * be visible only after our copy of the data into the
510 * ring has completed.
513 xs
.XenStore
->req_prod
+= Available
;
516 * The other side will see the change to req_prod at the time of the
520 XenEventChannelNotify (xs
.Dev
, xs
.EventChannel
);
523 return XENSTORE_STATUS_SUCCESS
;
527 Receive data from the XenStore service.
529 The buffer pointed to by DataPtr is at least Len bytes in length.
531 @param DataPtr A pointer to the contiguous buffer to receive the data.
532 @param Len The amount of data to receive.
534 @return On success 0, otherwise an errno value indicating the
544 XENSTORE_RING_IDX Cons
, Prod
;
545 CHAR8
*Data
= (CHAR8
*) DataPtr
;
551 Cons
= xs
.XenStore
->rsp_cons
;
552 Prod
= xs
.XenStore
->rsp_prod
;
555 * Nothing to read. Wait for a ring event.
557 * Note that the events from both queues are combined, so being woken
558 * does not guarantee that data exist in the read ring.
562 Status
= XenStoreWaitForEvent (xs
.EventChannelEvent
,
563 EFI_TIMER_PERIOD_SECONDS (1));
564 if (Status
== EFI_TIMEOUT
) {
565 DEBUG ((EFI_D_WARN
, "XenStore Read, waiting for a ring event.\n"));
570 /* Verify queue sanity. */
571 if (!XenStoreCheckIndexes (Cons
, Prod
)) {
572 xs
.XenStore
->rsp_cons
= xs
.XenStore
->rsp_prod
= 0;
573 return XENSTORE_STATUS_EIO
;
576 Src
= XenStoreGetInputChunk (Cons
, Prod
, xs
.XenStore
->rsp
, &Available
);
577 if (Available
> Len
) {
582 * Insure the data we read is related to the indexes
587 CopyMem (Data
, Src
, Available
);
592 * Insure that the producer of this ring does not see
593 * the ring space as free until after we have copied it
597 xs
.XenStore
->rsp_cons
+= Available
;
600 * The producer will see the updated consumer index when the event is
604 XenEventChannelNotify (xs
.Dev
, xs
.EventChannel
);
607 return XENSTORE_STATUS_SUCCESS
;
611 // Received Message Processing
615 Block reading the next message from the XenStore service and
618 @return XENSTORE_STATUS_SUCCESS on success. Otherwise an errno value
619 indicating the type of failure encountered.
623 XenStoreProcessMessage (
627 XENSTORE_MESSAGE
*Message
;
629 XENSTORE_STATUS Status
;
631 Message
= AllocateZeroPool (sizeof (XENSTORE_MESSAGE
));
632 Message
->Signature
= XENSTORE_MESSAGE_SIGNATURE
;
633 Status
= XenStoreReadStore (&Message
->Header
, sizeof (Message
->Header
));
634 if (Status
!= XENSTORE_STATUS_SUCCESS
) {
636 DEBUG ((EFI_D_ERROR
, "XenStore: Error read store (%d)\n", Status
));
640 Body
= AllocatePool (Message
->Header
.len
+ 1);
641 Status
= XenStoreReadStore (Body
, Message
->Header
.len
);
642 if (Status
!= XENSTORE_STATUS_SUCCESS
) {
645 DEBUG ((EFI_D_ERROR
, "XenStore: Error read store (%d)\n", Status
));
648 Body
[Message
->Header
.len
] = '\0';
650 if (Message
->Header
.type
== XS_WATCH_EVENT
) {
651 Message
->u
.Watch
.Vector
= Split(Body
, Message
->Header
.len
,
652 &Message
->u
.Watch
.VectorSize
);
654 EfiAcquireLock (&xs
.RegisteredWatchesLock
);
655 Message
->u
.Watch
.Handle
=
656 XenStoreFindWatch (Message
->u
.Watch
.Vector
[XS_WATCH_TOKEN
]);
657 DEBUG ((EFI_D_INFO
, "XenStore: Watch event %a\n",
658 Message
->u
.Watch
.Vector
[XS_WATCH_TOKEN
]));
659 if (Message
->u
.Watch
.Handle
!= NULL
) {
660 EfiAcquireLock (&xs
.WatchEventsLock
);
661 InsertHeadList (&xs
.WatchEvents
, &Message
->Link
);
662 EfiReleaseLock (&xs
.WatchEventsLock
);
664 DEBUG ((EFI_D_WARN
, "XenStore: Watch handle %a not found\n",
665 Message
->u
.Watch
.Vector
[XS_WATCH_TOKEN
]));
666 FreePool((VOID
*)Message
->u
.Watch
.Vector
);
669 EfiReleaseLock (&xs
.RegisteredWatchesLock
);
671 Message
->u
.Reply
.Body
= Body
;
672 EfiAcquireLock (&xs
.ReplyLock
);
673 InsertTailList (&xs
.ReplyList
, &Message
->Link
);
674 EfiReleaseLock (&xs
.ReplyLock
);
677 return XENSTORE_STATUS_SUCCESS
;
681 // XenStore Message Request/Reply Processing
685 Convert a XenStore error string into an errno number.
687 Unknown error strings are converted to EINVAL.
689 @param errorstring The error string to convert.
691 @return The errno best matching the input string.
695 XENSTORE_STATUS Status
;
696 CONST CHAR8
*ErrorStr
;
699 static XenStoreErrors gXenStoreErrors
[] = {
700 { XENSTORE_STATUS_EINVAL
, "EINVAL" },
701 { XENSTORE_STATUS_EACCES
, "EACCES" },
702 { XENSTORE_STATUS_EEXIST
, "EEXIST" },
703 { XENSTORE_STATUS_EISDIR
, "EISDIR" },
704 { XENSTORE_STATUS_ENOENT
, "ENOENT" },
705 { XENSTORE_STATUS_ENOMEM
, "ENOMEM" },
706 { XENSTORE_STATUS_ENOSPC
, "ENOSPC" },
707 { XENSTORE_STATUS_EIO
, "EIO" },
708 { XENSTORE_STATUS_ENOTEMPTY
, "ENOTEMPTY" },
709 { XENSTORE_STATUS_ENOSYS
, "ENOSYS" },
710 { XENSTORE_STATUS_EROFS
, "EROFS" },
711 { XENSTORE_STATUS_EBUSY
, "EBUSY" },
712 { XENSTORE_STATUS_EAGAIN
, "EAGAIN" },
713 { XENSTORE_STATUS_EISCONN
, "EISCONN" },
714 { XENSTORE_STATUS_E2BIG
, "E2BIG" }
717 #define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
723 CONST CHAR8
*ErrorStr
728 for (Index
= 0; Index
< ARRAY_SIZE(gXenStoreErrors
); Index
++) {
729 if (!AsciiStrCmp (ErrorStr
, gXenStoreErrors
[Index
].ErrorStr
)) {
730 return gXenStoreErrors
[Index
].Status
;
733 DEBUG ((EFI_D_WARN
, "XenStore gave unknown error %a\n", ErrorStr
));
734 return XENSTORE_STATUS_EINVAL
;
738 Block waiting for a reply to a message request.
740 @param TypePtr The returned type of the reply.
741 @param LenPtr The returned body length of the reply.
742 @param Result The returned body of the reply.
747 OUT
enum xsd_sockmsg_type
*TypePtr
,
748 OUT UINT32
*LenPtr OPTIONAL
,
752 XENSTORE_MESSAGE
*Message
;
756 while (IsListEmpty (&xs
.ReplyList
)) {
757 XENSTORE_STATUS Status
;
758 Status
= XenStoreProcessMessage ();
759 if (Status
!= XENSTORE_STATUS_SUCCESS
&& Status
!= XENSTORE_STATUS_EAGAIN
) {
760 DEBUG ((EFI_D_ERROR
, "XenStore, error while reading the ring (%d).",
765 EfiAcquireLock (&xs
.ReplyLock
);
766 Entry
= GetFirstNode (&xs
.ReplyList
);
767 Message
= XENSTORE_MESSAGE_FROM_LINK (Entry
);
768 RemoveEntryList (Entry
);
769 EfiReleaseLock (&xs
.ReplyLock
);
771 *TypePtr
= Message
->Header
.type
;
772 if (LenPtr
!= NULL
) {
773 *LenPtr
= Message
->Header
.len
;
775 Body
= Message
->u
.Reply
.Body
;
779 return XENSTORE_STATUS_SUCCESS
;
783 Send a message with an optionally muti-part body to the XenStore service.
785 @param Transaction The transaction to use for this request.
786 @param RequestType The type of message to send.
787 @param WriteRequest Pointers to the body sections of the request.
788 @param NumRequests The number of body sections in the request.
789 @param LenPtr The returned length of the reply.
790 @param ResultPtr The returned body of the reply.
792 @return XENSTORE_STATUS_SUCCESS on success. Otherwise an errno indicating
793 the cause of failure.
798 IN CONST XENSTORE_TRANSACTION
*Transaction
,
799 IN
enum xsd_sockmsg_type RequestType
,
800 IN CONST WRITE_REQUEST
*WriteRequest
,
801 IN UINT32 NumRequests
,
802 OUT UINT32
*LenPtr OPTIONAL
,
803 OUT VOID
**ResultPtr OPTIONAL
806 struct xsd_sockmsg Message
;
809 XENSTORE_STATUS Status
;
811 if (Transaction
== XST_NIL
) {
814 Message
.tx_id
= Transaction
->Id
;
817 Message
.type
= RequestType
;
819 for (Index
= 0; Index
< NumRequests
; Index
++) {
820 Message
.len
+= WriteRequest
[Index
].Len
;
823 Status
= XenStoreWriteStore (&Message
, sizeof (Message
));
824 if (Status
!= XENSTORE_STATUS_SUCCESS
) {
825 DEBUG ((EFI_D_ERROR
, "XenStoreTalkv failed %d\n", Status
));
829 for (Index
= 0; Index
< NumRequests
; Index
++) {
830 Status
= XenStoreWriteStore (WriteRequest
[Index
].Data
, WriteRequest
[Index
].Len
);
831 if (Status
!= XENSTORE_STATUS_SUCCESS
) {
832 DEBUG ((EFI_D_ERROR
, "XenStoreTalkv failed %d\n", Status
));
837 Status
= XenStoreReadReply ((enum xsd_sockmsg_type
*)&Message
.type
, LenPtr
, &Return
);
840 if (Status
!= XENSTORE_STATUS_SUCCESS
) {
844 if (Message
.type
== XS_ERROR
) {
845 Status
= XenStoreGetError (Return
);
850 /* Reply is either error or an echo of our request message type. */
851 ASSERT ((enum xsd_sockmsg_type
)Message
.type
== RequestType
);
859 return XENSTORE_STATUS_SUCCESS
;
863 Wrapper for XenStoreTalkv allowing easy transmission of a message with
864 a single, contiguous, message body.
866 The returned result is provided in malloced storage and thus must be free'd
869 @param Transaction The transaction to use for this request.
870 @param RequestType The type of message to send.
871 @param Body The body of the request.
872 @param LenPtr The returned length of the reply.
873 @param Result The returned body of the reply.
875 @return 0 on success. Otherwise an errno indicating
876 the cause of failure.
881 IN CONST XENSTORE_TRANSACTION
*Transaction
,
882 IN
enum xsd_sockmsg_type RequestType
,
883 IN CONST CHAR8
*Body
,
884 OUT UINT32
*LenPtr OPTIONAL
,
885 OUT VOID
**Result OPTIONAL
888 WRITE_REQUEST WriteRequest
;
890 WriteRequest
.Data
= (VOID
*) Body
;
891 WriteRequest
.Len
= (UINT32
)AsciiStrSize (Body
);
893 return XenStoreTalkv (Transaction
, RequestType
, &WriteRequest
, 1,
898 // XenStore Watch Support
902 Transmit a watch request to the XenStore service.
904 @param Path The path in the XenStore to watch.
905 @param Tocken A unique identifier for this watch.
907 @return XENSTORE_STATUS_SUCCESS on success. Otherwise an errno indicating the
917 WRITE_REQUEST WriteRequest
[2];
919 WriteRequest
[0].Data
= (VOID
*) Path
;
920 WriteRequest
[0].Len
= (UINT32
)AsciiStrSize (Path
);
921 WriteRequest
[1].Data
= (VOID
*) Token
;
922 WriteRequest
[1].Len
= (UINT32
)AsciiStrSize (Token
);
924 return XenStoreTalkv (XST_NIL
, XS_WATCH
, WriteRequest
, 2, NULL
, NULL
);
928 Transmit an uwatch request to the XenStore service.
930 @param Path The path in the XenStore to watch.
931 @param Tocken A unique identifier for this watch.
933 @return XENSTORE_STATUS_SUCCESS on success. Otherwise an errno indicating
934 the cause of failure.
943 WRITE_REQUEST WriteRequest
[2];
945 WriteRequest
[0].Data
= (VOID
*) Path
;
946 WriteRequest
[0].Len
= (UINT32
)AsciiStrSize (Path
);
947 WriteRequest
[1].Data
= (VOID
*) Token
;
948 WriteRequest
[1].Len
= (UINT32
)AsciiStrSize (Token
);
950 return XenStoreTalkv (XST_NIL
, XS_UNWATCH
, WriteRequest
, 2, NULL
, NULL
);
959 XENSTORE_MESSAGE
*Message
;
960 LIST_ENTRY
*Entry
= NULL
;
961 LIST_ENTRY
*Last
= NULL
;
962 XENSTORE_STATUS Status
;
965 EfiAcquireLock (&xs
.WatchEventsLock
);
966 if (IsListEmpty (&xs
.WatchEvents
) ||
967 Last
== GetFirstNode (&xs
.WatchEvents
)) {
968 EfiReleaseLock (&xs
.WatchEventsLock
);
969 Status
= XenStoreProcessMessage ();
970 if (Status
!= XENSTORE_STATUS_SUCCESS
&& Status
!= XENSTORE_STATUS_EAGAIN
) {
976 for (Entry
= GetFirstNode (&xs
.WatchEvents
);
977 Entry
!= Last
&& !IsNull (&xs
.WatchEvents
, Entry
);
978 Entry
= GetNextNode (&xs
.WatchEvents
, Entry
)) {
979 Message
= XENSTORE_MESSAGE_FROM_LINK (Entry
);
980 if (Message
->u
.Watch
.Handle
== Token
) {
981 RemoveEntryList (Entry
);
982 EfiReleaseLock (&xs
.WatchEventsLock
);
983 FreePool((VOID
*)Message
->u
.Watch
.Vector
);
985 return XENSTORE_STATUS_SUCCESS
;
988 Last
= GetFirstNode (&xs
.WatchEvents
);
989 EfiReleaseLock (&xs
.WatchEventsLock
);
995 NotifyEventChannelCheckForEvent (
1000 XENSTORE_PRIVATE
*xsp
;
1001 xsp
= (XENSTORE_PRIVATE
*)Context
;
1002 if (TestAndClearBit (xsp
->EventChannel
, xsp
->Dev
->SharedInfo
->evtchn_pending
)) {
1003 gBS
->SignalEvent (Event
);
1008 Setup communication channels with the XenStore service.
1010 @retval EFI_SUCCESS if everything went well.
1015 XENSTORE_PRIVATE
*xsp
1019 EFI_EVENT TimerEvent
;
1020 struct xenstore_domain_interface
*XenStore
= xsp
->XenStore
;
1022 Status
= gBS
->CreateEvent (EVT_TIMER
, 0, NULL
, NULL
, &TimerEvent
);
1023 Status
= gBS
->SetTimer (TimerEvent
, TimerRelative
,
1024 EFI_TIMER_PERIOD_SECONDS (5));
1025 while (XenStore
->rsp_prod
!= XenStore
->rsp_cons
) {
1026 Status
= gBS
->CheckEvent (TimerEvent
);
1027 if (!EFI_ERROR (Status
)) {
1028 DEBUG ((EFI_D_WARN
, "XENSTORE response ring is not quiescent "
1029 "(%08x:%08x): fixing up\n",
1030 XenStore
->rsp_cons
, XenStore
->rsp_prod
));
1031 XenStore
->rsp_cons
= XenStore
->rsp_prod
;
1034 gBS
->CloseEvent (TimerEvent
);
1036 Status
= gBS
->CreateEvent (EVT_NOTIFY_WAIT
, TPL_NOTIFY
,
1037 NotifyEventChannelCheckForEvent
, xsp
,
1038 &xsp
->EventChannelEvent
);
1039 ASSERT_EFI_ERROR (Status
);
1045 Initialize XenStore.
1047 @param Dev A XENBUS_DEVICE instance.
1049 @retval EFI_SUCCESS if everything went well.
1058 * The HVM guest pseudo-physical frame number. This is Xen's mapping
1059 * of the true machine frame number into our "physical address space".
1065 xs
.EventChannel
= (evtchn_port_t
)XenHypercallHvmGetParam (HVM_PARAM_STORE_EVTCHN
);
1066 XenStoreGpfn
= (UINTN
)XenHypercallHvmGetParam (HVM_PARAM_STORE_PFN
);
1067 xs
.XenStore
= (VOID
*) (XenStoreGpfn
<< EFI_PAGE_SHIFT
);
1068 DEBUG ((EFI_D_INFO
, "XenBusInit: XenBus rings @%p, event channel %x\n",
1069 xs
.XenStore
, xs
.EventChannel
));
1071 InitializeListHead (&xs
.ReplyList
);
1072 InitializeListHead (&xs
.WatchEvents
);
1073 InitializeListHead (&xs
.RegisteredWatches
);
1075 EfiInitializeLock (&xs
.ReplyLock
, TPL_NOTIFY
);
1076 EfiInitializeLock (&xs
.RegisteredWatchesLock
, TPL_NOTIFY
);
1077 EfiInitializeLock (&xs
.WatchEventsLock
, TPL_NOTIFY
);
1079 /* Initialize the shared memory rings to talk to xenstored */
1080 Status
= XenStoreInitComms (&xs
);
1081 if (EFI_ERROR (Status
)) {
1090 IN XENBUS_DEVICE
*Dev
1094 // Emptying the list RegisteredWatches, but this list should already be
1095 // empty. Every driver that is using Watches should unregister them when
1098 if (!IsListEmpty (&xs
.RegisteredWatches
)) {
1099 XENSTORE_WATCH
*Watch
;
1101 DEBUG ((EFI_D_WARN
, "XenStore: RegisteredWatches is not empty, cleaning up..."));
1102 Entry
= GetFirstNode (&xs
.RegisteredWatches
);
1103 while (!IsNull (&xs
.RegisteredWatches
, Entry
)) {
1104 Watch
= XENSTORE_WATCH_FROM_LINK (Entry
);
1105 Entry
= GetNextNode (&xs
.RegisteredWatches
, Entry
);
1107 XenStoreUnregisterWatch (Watch
);
1112 // Emptying the list WatchEvents, but this list should already be empty after
1113 // having cleanup the list RegisteredWatches.
1115 if (!IsListEmpty (&xs
.WatchEvents
)) {
1117 DEBUG ((EFI_D_WARN
, "XenStore: WatchEvents is not empty, cleaning up..."));
1118 Entry
= GetFirstNode (&xs
.WatchEvents
);
1119 while (!IsNull (&xs
.WatchEvents
, Entry
)) {
1120 XENSTORE_MESSAGE
*Message
= XENSTORE_MESSAGE_FROM_LINK (Entry
);
1121 Entry
= GetNextNode (&xs
.WatchEvents
, Entry
);
1122 RemoveEntryList (&Message
->Link
);
1123 FreePool ((VOID
*)Message
->u
.Watch
.Vector
);
1128 if (!IsListEmpty (&xs
.ReplyList
)) {
1129 XENSTORE_MESSAGE
*Message
;
1131 Entry
= GetFirstNode (&xs
.ReplyList
);
1132 while (!IsNull (&xs
.ReplyList
, Entry
)) {
1133 Message
= XENSTORE_MESSAGE_FROM_LINK (Entry
);
1134 Entry
= GetNextNode (&xs
.ReplyList
, Entry
);
1135 RemoveEntryList (&Message
->Link
);
1136 FreePool (Message
->u
.Reply
.Body
);
1141 gBS
->CloseEvent (xs
.EventChannelEvent
);
1143 if (xs
.XenStore
->server_features
& XENSTORE_SERVER_FEATURE_RECONNECTION
) {
1144 xs
.XenStore
->connection
= XENSTORE_RECONNECT
;
1145 XenEventChannelNotify (xs
.Dev
, xs
.EventChannel
);
1146 while (*(volatile UINT32
*)&xs
.XenStore
->connection
== XENSTORE_RECONNECT
) {
1147 XenStoreWaitForEvent (xs
.EventChannelEvent
, EFI_TIMER_PERIOD_MILLISECONDS (100));
1150 /* If the backend reads the state while we're erasing it then the
1151 * ring state will become corrupted, preventing guest frontends from
1152 * connecting. This is rare. To help diagnose the failure, we fill
1153 * the ring with XS_INVALID packets. */
1154 SetMem (xs
.XenStore
->req
, XENSTORE_RING_SIZE
, 0xff);
1155 SetMem (xs
.XenStore
->rsp
, XENSTORE_RING_SIZE
, 0xff);
1156 xs
.XenStore
->req_cons
= xs
.XenStore
->req_prod
= 0;
1157 xs
.XenStore
->rsp_cons
= xs
.XenStore
->rsp_prod
= 0;
1164 // API comments for these methods can be found in XenStore.h
1168 XenStoreListDirectory (
1169 IN CONST XENSTORE_TRANSACTION
*Transaction
,
1170 IN CONST CHAR8
*DirectoryPath
,
1171 IN CONST CHAR8
*Node
,
1172 OUT UINT32
*DirectoryCountPtr
,
1173 OUT CONST CHAR8
***DirectoryListPtr
1179 XENSTORE_STATUS Status
;
1181 Path
= XenStoreJoin (DirectoryPath
, Node
);
1182 Status
= XenStoreSingle (Transaction
, XS_DIRECTORY
, Path
, &Len
,
1183 (VOID
**) &TempStr
);
1185 if (Status
!= XENSTORE_STATUS_SUCCESS
) {
1189 *DirectoryListPtr
= Split (TempStr
, Len
, DirectoryCountPtr
);
1191 return XENSTORE_STATUS_SUCCESS
;
1195 XenStorePathExists (
1196 IN CONST XENSTORE_TRANSACTION
*Transaction
,
1197 IN CONST CHAR8
*Directory
,
1198 IN CONST CHAR8
*Node
1201 CONST CHAR8
**TempStr
;
1202 XENSTORE_STATUS Status
;
1205 Status
= XenStoreListDirectory (Transaction
, Directory
, Node
,
1206 &TempNum
, &TempStr
);
1207 if (Status
!= XENSTORE_STATUS_SUCCESS
) {
1210 FreePool ((VOID
*)TempStr
);
1216 IN CONST XENSTORE_TRANSACTION
*Transaction
,
1217 IN CONST CHAR8
*DirectoryPath
,
1218 IN CONST CHAR8
*Node
,
1219 OUT UINT32
*LenPtr OPTIONAL
,
1225 XENSTORE_STATUS Status
;
1227 Path
= XenStoreJoin (DirectoryPath
, Node
);
1228 Status
= XenStoreSingle (Transaction
, XS_READ
, Path
, LenPtr
, &Value
);
1230 if (Status
!= XENSTORE_STATUS_SUCCESS
) {
1235 return XENSTORE_STATUS_SUCCESS
;
1240 IN CONST XENSTORE_TRANSACTION
*Transaction
,
1241 IN CONST CHAR8
*DirectoryPath
,
1242 IN CONST CHAR8
*Node
,
1247 WRITE_REQUEST WriteRequest
[2];
1248 XENSTORE_STATUS Status
;
1250 Path
= XenStoreJoin (DirectoryPath
, Node
);
1252 WriteRequest
[0].Data
= (VOID
*) Path
;
1253 WriteRequest
[0].Len
= (UINT32
)AsciiStrSize (Path
);
1254 WriteRequest
[1].Data
= (VOID
*) Str
;
1255 WriteRequest
[1].Len
= (UINT32
)AsciiStrLen (Str
);
1257 Status
= XenStoreTalkv (Transaction
, XS_WRITE
, WriteRequest
, 2, NULL
, NULL
);
1265 IN CONST XENSTORE_TRANSACTION
*Transaction
,
1266 IN CONST CHAR8
*DirectoryPath
,
1267 IN CONST CHAR8
*Node
1271 XENSTORE_STATUS Status
;
1273 Path
= XenStoreJoin (DirectoryPath
, Node
);
1274 Status
= XenStoreSingle (Transaction
, XS_RM
, Path
, NULL
, NULL
);
1281 XenStoreTransactionStart (
1282 OUT XENSTORE_TRANSACTION
*Transaction
1286 XENSTORE_STATUS Status
;
1288 Status
= XenStoreSingle (XST_NIL
, XS_TRANSACTION_START
, "", NULL
,
1290 if (Status
== XENSTORE_STATUS_SUCCESS
) {
1291 Transaction
->Id
= (UINT32
)AsciiStrDecimalToUintn (IdStr
);
1299 XenStoreTransactionEnd (
1300 IN CONST XENSTORE_TRANSACTION
*Transaction
,
1306 AbortStr
[0] = Abort
? 'F' : 'T';
1309 return XenStoreSingle (Transaction
, XS_TRANSACTION_END
, AbortStr
, NULL
, NULL
);
1314 IN CONST XENSTORE_TRANSACTION
*Transaction
,
1315 IN CONST CHAR8
*DirectoryPath
,
1316 IN CONST CHAR8
*Node
,
1317 IN CONST CHAR8
*FormatString
,
1322 XENSTORE_STATUS Status
;
1326 VA_COPY (Marker2
, Marker
);
1327 BufSize
= SPrintLengthAsciiFormat (FormatString
, Marker2
) + 1;
1329 Buf
= AllocateZeroPool (BufSize
);
1330 AsciiVSPrint (Buf
, BufSize
, FormatString
, Marker
);
1331 Status
= XenStoreWrite (Transaction
, DirectoryPath
, Node
, Buf
);
1340 IN CONST XENSTORE_TRANSACTION
*Transaction
,
1341 IN CONST CHAR8
*DirectoryPath
,
1342 IN CONST CHAR8
*Node
,
1343 IN CONST CHAR8
*FormatString
,
1348 XENSTORE_STATUS Status
;
1350 VA_START (Marker
, FormatString
);
1351 Status
= XenStoreVSPrint (Transaction
, DirectoryPath
, Node
, FormatString
, Marker
);
1358 XenStoreRegisterWatch (
1359 IN CONST CHAR8
*DirectoryPath
,
1360 IN CONST CHAR8
*Node
,
1361 OUT XENSTORE_WATCH
**WatchPtr
1364 /* Pointer in ascii is the token. */
1365 CHAR8 Token
[sizeof (XENSTORE_WATCH
) * 2 + 1];
1366 XENSTORE_STATUS Status
;
1367 XENSTORE_WATCH
*Watch
;
1369 Watch
= AllocateZeroPool (sizeof (XENSTORE_WATCH
));
1370 Watch
->Signature
= XENSTORE_WATCH_SIGNATURE
;
1371 Watch
->Node
= XenStoreJoin (DirectoryPath
, Node
);
1373 EfiAcquireLock (&xs
.RegisteredWatchesLock
);
1374 InsertTailList (&xs
.RegisteredWatches
, &Watch
->Link
);
1375 EfiReleaseLock (&xs
.RegisteredWatchesLock
);
1377 AsciiSPrint (Token
, sizeof (Token
), "%p", (VOID
*) Watch
);
1378 Status
= XenStoreWatch (Watch
->Node
, Token
);
1380 /* Ignore errors due to multiple registration. */
1381 if (Status
== XENSTORE_STATUS_EEXIST
) {
1382 Status
= XENSTORE_STATUS_SUCCESS
;
1385 if (Status
== XENSTORE_STATUS_SUCCESS
) {
1388 EfiAcquireLock (&xs
.RegisteredWatchesLock
);
1389 RemoveEntryList (&Watch
->Link
);
1390 EfiReleaseLock (&xs
.RegisteredWatchesLock
);
1391 FreePool (Watch
->Node
);
1399 XenStoreUnregisterWatch (
1400 IN XENSTORE_WATCH
*Watch
1403 CHAR8 Token
[sizeof (Watch
) * 2 + 1];
1406 ASSERT (Watch
->Signature
== XENSTORE_WATCH_SIGNATURE
);
1408 AsciiSPrint (Token
, sizeof (Token
), "%p", (VOID
*) Watch
);
1409 if (XenStoreFindWatch (Token
) == NULL
) {
1413 EfiAcquireLock (&xs
.RegisteredWatchesLock
);
1414 RemoveEntryList (&Watch
->Link
);
1415 EfiReleaseLock (&xs
.RegisteredWatchesLock
);
1417 XenStoreUnwatch (Watch
->Node
, Token
);
1419 /* Cancel pending watch events. */
1420 EfiAcquireLock (&xs
.WatchEventsLock
);
1421 Entry
= GetFirstNode (&xs
.WatchEvents
);
1422 while (!IsNull (&xs
.WatchEvents
, Entry
)) {
1423 XENSTORE_MESSAGE
*Message
= XENSTORE_MESSAGE_FROM_LINK (Entry
);
1424 Entry
= GetNextNode (&xs
.WatchEvents
, Entry
);
1425 if (Message
->u
.Watch
.Handle
== Watch
) {
1426 RemoveEntryList (&Message
->Link
);
1427 FreePool ((VOID
*)Message
->u
.Watch
.Vector
);
1431 EfiReleaseLock (&xs
.WatchEventsLock
);
1433 FreePool (Watch
->Node
);
1444 XenBusWaitForWatch (
1445 IN XENBUS_PROTOCOL
*This
,
1449 return XenStoreWaitWatch (Token
);
1454 XenBusXenStoreRead (
1455 IN XENBUS_PROTOCOL
*This
,
1456 IN CONST XENSTORE_TRANSACTION
*Transaction
,
1457 IN CONST CHAR8
*Node
,
1461 return XenStoreRead (Transaction
, This
->Node
, Node
, NULL
, Value
);
1466 XenBusXenStoreBackendRead (
1467 IN XENBUS_PROTOCOL
*This
,
1468 IN CONST XENSTORE_TRANSACTION
*Transaction
,
1469 IN CONST CHAR8
*Node
,
1473 return XenStoreRead (Transaction
, This
->Backend
, Node
, NULL
, Value
);
1478 XenBusXenStoreRemove (
1479 IN XENBUS_PROTOCOL
*This
,
1480 IN CONST XENSTORE_TRANSACTION
*Transaction
,
1484 return XenStoreRemove (Transaction
, This
->Node
, Node
);
1489 XenBusXenStoreTransactionStart (
1490 IN XENBUS_PROTOCOL
*This
,
1491 OUT XENSTORE_TRANSACTION
*Transaction
1494 return XenStoreTransactionStart (Transaction
);
1499 XenBusXenStoreTransactionEnd (
1500 IN XENBUS_PROTOCOL
*This
,
1501 IN CONST XENSTORE_TRANSACTION
*Transaction
,
1505 return XenStoreTransactionEnd (Transaction
, Abort
);
1510 XenBusXenStoreSPrint (
1511 IN XENBUS_PROTOCOL
*This
,
1512 IN CONST XENSTORE_TRANSACTION
*Transaction
,
1513 IN CONST CHAR8
*DirectoryPath
,
1514 IN CONST CHAR8
*Node
,
1515 IN CONST CHAR8
*FormatString
,
1520 XENSTORE_STATUS Status
;
1522 VA_START (Marker
, FormatString
);
1523 Status
= XenStoreVSPrint (Transaction
, DirectoryPath
, Node
, FormatString
, Marker
);
1531 XenBusRegisterWatch (
1532 IN XENBUS_PROTOCOL
*This
,
1533 IN CONST CHAR8
*Node
,
1537 return XenStoreRegisterWatch (This
->Node
, Node
, (XENSTORE_WATCH
**) Token
);
1542 XenBusRegisterWatchBackend (
1543 IN XENBUS_PROTOCOL
*This
,
1544 IN CONST CHAR8
*Node
,
1548 return XenStoreRegisterWatch (This
->Backend
, Node
, (XENSTORE_WATCH
**) Token
);
1553 XenBusUnregisterWatch (
1554 IN XENBUS_PROTOCOL
*This
,
1558 XenStoreUnregisterWatch ((XENSTORE_WATCH
*) Token
);