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