|
@@ -0,0 +1,557 @@
|
|
|
+// SPDX-License-Identifier: GPL-2.0
|
|
|
+/*
|
|
|
+ * (C) 2006 - Cambridge University
|
|
|
+ * (C) 2020 - EPAM Systems Inc.
|
|
|
+ *
|
|
|
+ * File: xenbus.c [1]
|
|
|
+ * Author: Steven Smith (sos22@cam.ac.uk)
|
|
|
+ * Changes: Grzegorz Milos (gm281@cam.ac.uk)
|
|
|
+ * Changes: John D. Ramsdell
|
|
|
+ *
|
|
|
+ * Date: Jun 2006, changes Aug 2006
|
|
|
+ *
|
|
|
+ * Description: Minimal implementation of xenbus
|
|
|
+ *
|
|
|
+ * [1] - http://xenbits.xen.org/gitweb/?p=mini-os.git;a=summary
|
|
|
+ */
|
|
|
+
|
|
|
+#include <common.h>
|
|
|
+#include <log.h>
|
|
|
+
|
|
|
+#include <asm/armv8/mmu.h>
|
|
|
+#include <asm/io.h>
|
|
|
+#include <asm/xen/system.h>
|
|
|
+
|
|
|
+#include <linux/bug.h>
|
|
|
+#include <linux/compat.h>
|
|
|
+
|
|
|
+#include <xen/events.h>
|
|
|
+#include <xen/hvm.h>
|
|
|
+#include <xen/xenbus.h>
|
|
|
+
|
|
|
+#include <xen/interface/io/xs_wire.h>
|
|
|
+
|
|
|
+#define map_frame_virt(v) (v << PAGE_SHIFT)
|
|
|
+
|
|
|
+#define SCNd16 "d"
|
|
|
+
|
|
|
+/* Wait for reply time out, ms */
|
|
|
+#define WAIT_XENBUS_TO_MS 5000
|
|
|
+/* Polling time out, ms */
|
|
|
+#define WAIT_XENBUS_POLL_TO_MS 1
|
|
|
+
|
|
|
+static struct xenstore_domain_interface *xenstore_buf;
|
|
|
+
|
|
|
+static char *errmsg(struct xsd_sockmsg *rep);
|
|
|
+
|
|
|
+u32 xenbus_evtchn;
|
|
|
+
|
|
|
+struct write_req {
|
|
|
+ const void *data;
|
|
|
+ unsigned int len;
|
|
|
+};
|
|
|
+
|
|
|
+static void memcpy_from_ring(const void *r, void *d, int off, int len)
|
|
|
+{
|
|
|
+ int c1, c2;
|
|
|
+ const char *ring = r;
|
|
|
+ char *dest = d;
|
|
|
+
|
|
|
+ c1 = min(len, XENSTORE_RING_SIZE - off);
|
|
|
+ c2 = len - c1;
|
|
|
+ memcpy(dest, ring + off, c1);
|
|
|
+ memcpy(dest + c1, ring, c2);
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * xenbus_get_reply() - Receive reply from xenbus
|
|
|
+ * @req_reply: reply message structure
|
|
|
+ *
|
|
|
+ * Wait for reply message event from the ring and copy received message
|
|
|
+ * to input xsd_sockmsg structure. Repeat until full reply is
|
|
|
+ * proceeded.
|
|
|
+ *
|
|
|
+ * Return: false - timeout
|
|
|
+ * true - reply is received
|
|
|
+ */
|
|
|
+static bool xenbus_get_reply(struct xsd_sockmsg **req_reply)
|
|
|
+{
|
|
|
+ struct xsd_sockmsg msg;
|
|
|
+ unsigned int prod = xenstore_buf->rsp_prod;
|
|
|
+
|
|
|
+again:
|
|
|
+ if (!wait_event_timeout(NULL, prod != xenstore_buf->rsp_prod,
|
|
|
+ WAIT_XENBUS_TO_MS)) {
|
|
|
+ printk("%s: wait_event timeout\n", __func__);
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ prod = xenstore_buf->rsp_prod;
|
|
|
+ if (xenstore_buf->rsp_prod - xenstore_buf->rsp_cons < sizeof(msg))
|
|
|
+ goto again;
|
|
|
+
|
|
|
+ rmb();
|
|
|
+ memcpy_from_ring(xenstore_buf->rsp, &msg,
|
|
|
+ MASK_XENSTORE_IDX(xenstore_buf->rsp_cons),
|
|
|
+ sizeof(msg));
|
|
|
+
|
|
|
+ if (xenstore_buf->rsp_prod - xenstore_buf->rsp_cons < sizeof(msg) + msg.len)
|
|
|
+ goto again;
|
|
|
+
|
|
|
+ /* We do not support and expect any Xen bus wathes. */
|
|
|
+ BUG_ON(msg.type == XS_WATCH_EVENT);
|
|
|
+
|
|
|
+ *req_reply = malloc(sizeof(msg) + msg.len);
|
|
|
+ memcpy_from_ring(xenstore_buf->rsp, *req_reply,
|
|
|
+ MASK_XENSTORE_IDX(xenstore_buf->rsp_cons),
|
|
|
+ msg.len + sizeof(msg));
|
|
|
+ mb();
|
|
|
+ xenstore_buf->rsp_cons += msg.len + sizeof(msg);
|
|
|
+
|
|
|
+ wmb();
|
|
|
+ notify_remote_via_evtchn(xenbus_evtchn);
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+char *xenbus_switch_state(xenbus_transaction_t xbt, const char *path,
|
|
|
+ XenbusState state)
|
|
|
+{
|
|
|
+ char *current_state;
|
|
|
+ char *msg = NULL;
|
|
|
+ char *msg2 = NULL;
|
|
|
+ char value[2];
|
|
|
+ XenbusState rs;
|
|
|
+ int xbt_flag = 0;
|
|
|
+ int retry = 0;
|
|
|
+
|
|
|
+ do {
|
|
|
+ if (xbt == XBT_NIL) {
|
|
|
+ msg = xenbus_transaction_start(&xbt);
|
|
|
+ if (msg)
|
|
|
+ goto exit;
|
|
|
+ xbt_flag = 1;
|
|
|
+ }
|
|
|
+
|
|
|
+ msg = xenbus_read(xbt, path, ¤t_state);
|
|
|
+ if (msg)
|
|
|
+ goto exit;
|
|
|
+
|
|
|
+ rs = (XenbusState)(current_state[0] - '0');
|
|
|
+ free(current_state);
|
|
|
+ if (rs == state) {
|
|
|
+ msg = NULL;
|
|
|
+ goto exit;
|
|
|
+ }
|
|
|
+
|
|
|
+ snprintf(value, 2, "%d", state);
|
|
|
+ msg = xenbus_write(xbt, path, value);
|
|
|
+
|
|
|
+exit:
|
|
|
+ if (xbt_flag) {
|
|
|
+ msg2 = xenbus_transaction_end(xbt, 0, &retry);
|
|
|
+ xbt = XBT_NIL;
|
|
|
+ }
|
|
|
+ if (msg == NULL && msg2 != NULL)
|
|
|
+ msg = msg2;
|
|
|
+ else
|
|
|
+ free(msg2);
|
|
|
+ } while (retry);
|
|
|
+
|
|
|
+ return msg;
|
|
|
+}
|
|
|
+
|
|
|
+char *xenbus_wait_for_state_change(const char *path, XenbusState *state)
|
|
|
+{
|
|
|
+ for (;;) {
|
|
|
+ char *res, *msg;
|
|
|
+ XenbusState rs;
|
|
|
+
|
|
|
+ msg = xenbus_read(XBT_NIL, path, &res);
|
|
|
+ if (msg)
|
|
|
+ return msg;
|
|
|
+
|
|
|
+ rs = (XenbusState)(res[0] - 48);
|
|
|
+ free(res);
|
|
|
+
|
|
|
+ if (rs == *state) {
|
|
|
+ wait_event_timeout(NULL, false, WAIT_XENBUS_POLL_TO_MS);
|
|
|
+ } else {
|
|
|
+ *state = rs;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return NULL;
|
|
|
+}
|
|
|
+
|
|
|
+/* Send data to xenbus. This can block. All of the requests are seen
|
|
|
+ * by xenbus as if sent atomically. The header is added
|
|
|
+ * automatically, using type %type, req_id %req_id, and trans_id
|
|
|
+ * %trans_id.
|
|
|
+ */
|
|
|
+static void xb_write(int type, int req_id, xenbus_transaction_t trans_id,
|
|
|
+ const struct write_req *req, int nr_reqs)
|
|
|
+{
|
|
|
+ XENSTORE_RING_IDX prod;
|
|
|
+ int r;
|
|
|
+ int len = 0;
|
|
|
+ const struct write_req *cur_req;
|
|
|
+ int req_off;
|
|
|
+ int total_off;
|
|
|
+ int this_chunk;
|
|
|
+ struct xsd_sockmsg m = {
|
|
|
+ .type = type,
|
|
|
+ .req_id = req_id,
|
|
|
+ .tx_id = trans_id
|
|
|
+ };
|
|
|
+ struct write_req header_req = {
|
|
|
+ &m,
|
|
|
+ sizeof(m)
|
|
|
+ };
|
|
|
+
|
|
|
+ for (r = 0; r < nr_reqs; r++)
|
|
|
+ len += req[r].len;
|
|
|
+ m.len = len;
|
|
|
+ len += sizeof(m);
|
|
|
+
|
|
|
+ cur_req = &header_req;
|
|
|
+
|
|
|
+ BUG_ON(len > XENSTORE_RING_SIZE);
|
|
|
+ prod = xenstore_buf->req_prod;
|
|
|
+ /* We are running synchronously, so it is a bug if we do not
|
|
|
+ * have enough room to send a message: please note that a message
|
|
|
+ * can occupy multiple slots in the ring buffer.
|
|
|
+ */
|
|
|
+ BUG_ON(prod + len - xenstore_buf->req_cons > XENSTORE_RING_SIZE);
|
|
|
+
|
|
|
+ total_off = 0;
|
|
|
+ req_off = 0;
|
|
|
+ while (total_off < len) {
|
|
|
+ this_chunk = min(cur_req->len - req_off,
|
|
|
+ XENSTORE_RING_SIZE - MASK_XENSTORE_IDX(prod));
|
|
|
+ memcpy((char *)xenstore_buf->req + MASK_XENSTORE_IDX(prod),
|
|
|
+ (char *)cur_req->data + req_off, this_chunk);
|
|
|
+ prod += this_chunk;
|
|
|
+ req_off += this_chunk;
|
|
|
+ total_off += this_chunk;
|
|
|
+ if (req_off == cur_req->len) {
|
|
|
+ req_off = 0;
|
|
|
+ if (cur_req == &header_req)
|
|
|
+ cur_req = req;
|
|
|
+ else
|
|
|
+ cur_req++;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ BUG_ON(req_off != 0);
|
|
|
+ BUG_ON(total_off != len);
|
|
|
+ BUG_ON(prod > xenstore_buf->req_cons + XENSTORE_RING_SIZE);
|
|
|
+
|
|
|
+ /* Remote must see entire message before updating indexes */
|
|
|
+ wmb();
|
|
|
+
|
|
|
+ xenstore_buf->req_prod += len;
|
|
|
+
|
|
|
+ /* Send evtchn to notify remote */
|
|
|
+ notify_remote_via_evtchn(xenbus_evtchn);
|
|
|
+}
|
|
|
+
|
|
|
+/* Send a message to xenbus, in the same fashion as xb_write, and
|
|
|
+ * block waiting for a reply. The reply is malloced and should be
|
|
|
+ * freed by the caller.
|
|
|
+ */
|
|
|
+struct xsd_sockmsg *xenbus_msg_reply(int type,
|
|
|
+ xenbus_transaction_t trans,
|
|
|
+ struct write_req *io,
|
|
|
+ int nr_reqs)
|
|
|
+{
|
|
|
+ struct xsd_sockmsg *rep;
|
|
|
+
|
|
|
+ /* We do not use request identifier which is echoed in daemon's response. */
|
|
|
+ xb_write(type, 0, trans, io, nr_reqs);
|
|
|
+ /* Now wait for the message to arrive. */
|
|
|
+ if (!xenbus_get_reply(&rep))
|
|
|
+ return NULL;
|
|
|
+ return rep;
|
|
|
+}
|
|
|
+
|
|
|
+static char *errmsg(struct xsd_sockmsg *rep)
|
|
|
+{
|
|
|
+ char *res;
|
|
|
+
|
|
|
+ if (!rep) {
|
|
|
+ char msg[] = "No reply";
|
|
|
+ size_t len = strlen(msg) + 1;
|
|
|
+
|
|
|
+ return memcpy(malloc(len), msg, len);
|
|
|
+ }
|
|
|
+ if (rep->type != XS_ERROR)
|
|
|
+ return NULL;
|
|
|
+ res = malloc(rep->len + 1);
|
|
|
+ memcpy(res, rep + 1, rep->len);
|
|
|
+ res[rep->len] = 0;
|
|
|
+ free(rep);
|
|
|
+ return res;
|
|
|
+}
|
|
|
+
|
|
|
+/* List the contents of a directory. Returns a malloc()ed array of
|
|
|
+ * pointers to malloc()ed strings. The array is NULL terminated. May
|
|
|
+ * block.
|
|
|
+ */
|
|
|
+char *xenbus_ls(xenbus_transaction_t xbt, const char *pre, char ***contents)
|
|
|
+{
|
|
|
+ struct xsd_sockmsg *reply, *repmsg;
|
|
|
+ struct write_req req[] = { { pre, strlen(pre) + 1 } };
|
|
|
+ int nr_elems, x, i;
|
|
|
+ char **res, *msg;
|
|
|
+
|
|
|
+ repmsg = xenbus_msg_reply(XS_DIRECTORY, xbt, req, ARRAY_SIZE(req));
|
|
|
+ msg = errmsg(repmsg);
|
|
|
+ if (msg) {
|
|
|
+ *contents = NULL;
|
|
|
+ return msg;
|
|
|
+ }
|
|
|
+ reply = repmsg + 1;
|
|
|
+ for (x = nr_elems = 0; x < repmsg->len; x++)
|
|
|
+ nr_elems += (((char *)reply)[x] == 0);
|
|
|
+ res = malloc(sizeof(res[0]) * (nr_elems + 1));
|
|
|
+ for (x = i = 0; i < nr_elems; i++) {
|
|
|
+ int l = strlen((char *)reply + x);
|
|
|
+
|
|
|
+ res[i] = malloc(l + 1);
|
|
|
+ memcpy(res[i], (char *)reply + x, l + 1);
|
|
|
+ x += l + 1;
|
|
|
+ }
|
|
|
+ res[i] = NULL;
|
|
|
+ free(repmsg);
|
|
|
+ *contents = res;
|
|
|
+ return NULL;
|
|
|
+}
|
|
|
+
|
|
|
+char *xenbus_read(xenbus_transaction_t xbt, const char *path, char **value)
|
|
|
+{
|
|
|
+ struct write_req req[] = { {path, strlen(path) + 1} };
|
|
|
+ struct xsd_sockmsg *rep;
|
|
|
+ char *res, *msg;
|
|
|
+
|
|
|
+ rep = xenbus_msg_reply(XS_READ, xbt, req, ARRAY_SIZE(req));
|
|
|
+ msg = errmsg(rep);
|
|
|
+ if (msg) {
|
|
|
+ *value = NULL;
|
|
|
+ return msg;
|
|
|
+ }
|
|
|
+ res = malloc(rep->len + 1);
|
|
|
+ memcpy(res, rep + 1, rep->len);
|
|
|
+ res[rep->len] = 0;
|
|
|
+ free(rep);
|
|
|
+ *value = res;
|
|
|
+ return NULL;
|
|
|
+}
|
|
|
+
|
|
|
+char *xenbus_write(xenbus_transaction_t xbt, const char *path,
|
|
|
+ const char *value)
|
|
|
+{
|
|
|
+ struct write_req req[] = {
|
|
|
+ {path, strlen(path) + 1},
|
|
|
+ {value, strlen(value)},
|
|
|
+ };
|
|
|
+ struct xsd_sockmsg *rep;
|
|
|
+ char *msg;
|
|
|
+
|
|
|
+ rep = xenbus_msg_reply(XS_WRITE, xbt, req, ARRAY_SIZE(req));
|
|
|
+ msg = errmsg(rep);
|
|
|
+ if (msg)
|
|
|
+ return msg;
|
|
|
+ free(rep);
|
|
|
+ return NULL;
|
|
|
+}
|
|
|
+
|
|
|
+char *xenbus_rm(xenbus_transaction_t xbt, const char *path)
|
|
|
+{
|
|
|
+ struct write_req req[] = { {path, strlen(path) + 1} };
|
|
|
+ struct xsd_sockmsg *rep;
|
|
|
+ char *msg;
|
|
|
+
|
|
|
+ rep = xenbus_msg_reply(XS_RM, xbt, req, ARRAY_SIZE(req));
|
|
|
+ msg = errmsg(rep);
|
|
|
+ if (msg)
|
|
|
+ return msg;
|
|
|
+ free(rep);
|
|
|
+ return NULL;
|
|
|
+}
|
|
|
+
|
|
|
+char *xenbus_get_perms(xenbus_transaction_t xbt, const char *path, char **value)
|
|
|
+{
|
|
|
+ struct write_req req[] = { {path, strlen(path) + 1} };
|
|
|
+ struct xsd_sockmsg *rep;
|
|
|
+ char *res, *msg;
|
|
|
+
|
|
|
+ rep = xenbus_msg_reply(XS_GET_PERMS, xbt, req, ARRAY_SIZE(req));
|
|
|
+ msg = errmsg(rep);
|
|
|
+ if (msg) {
|
|
|
+ *value = NULL;
|
|
|
+ return msg;
|
|
|
+ }
|
|
|
+ res = malloc(rep->len + 1);
|
|
|
+ memcpy(res, rep + 1, rep->len);
|
|
|
+ res[rep->len] = 0;
|
|
|
+ free(rep);
|
|
|
+ *value = res;
|
|
|
+ return NULL;
|
|
|
+}
|
|
|
+
|
|
|
+#define PERM_MAX_SIZE 32
|
|
|
+char *xenbus_set_perms(xenbus_transaction_t xbt, const char *path,
|
|
|
+ domid_t dom, char perm)
|
|
|
+{
|
|
|
+ char value[PERM_MAX_SIZE];
|
|
|
+ struct write_req req[] = {
|
|
|
+ {path, strlen(path) + 1},
|
|
|
+ {value, 0},
|
|
|
+ };
|
|
|
+ struct xsd_sockmsg *rep;
|
|
|
+ char *msg;
|
|
|
+
|
|
|
+ snprintf(value, PERM_MAX_SIZE, "%c%hu", perm, dom);
|
|
|
+ req[1].len = strlen(value) + 1;
|
|
|
+ rep = xenbus_msg_reply(XS_SET_PERMS, xbt, req, ARRAY_SIZE(req));
|
|
|
+ msg = errmsg(rep);
|
|
|
+ if (msg)
|
|
|
+ return msg;
|
|
|
+ free(rep);
|
|
|
+ return NULL;
|
|
|
+}
|
|
|
+
|
|
|
+char *xenbus_transaction_start(xenbus_transaction_t *xbt)
|
|
|
+{
|
|
|
+ /* Xenstored becomes angry if you send a length 0 message, so just
|
|
|
+ * shove a nul terminator on the end
|
|
|
+ */
|
|
|
+ struct write_req req = { "", 1};
|
|
|
+ struct xsd_sockmsg *rep;
|
|
|
+ char *err;
|
|
|
+
|
|
|
+ rep = xenbus_msg_reply(XS_TRANSACTION_START, 0, &req, 1);
|
|
|
+ err = errmsg(rep);
|
|
|
+ if (err)
|
|
|
+ return err;
|
|
|
+ sscanf((char *)(rep + 1), "%lu", xbt);
|
|
|
+ free(rep);
|
|
|
+ return NULL;
|
|
|
+}
|
|
|
+
|
|
|
+char *xenbus_transaction_end(xenbus_transaction_t t, int abort, int *retry)
|
|
|
+{
|
|
|
+ struct xsd_sockmsg *rep;
|
|
|
+ struct write_req req;
|
|
|
+ char *err;
|
|
|
+
|
|
|
+ *retry = 0;
|
|
|
+
|
|
|
+ req.data = abort ? "F" : "T";
|
|
|
+ req.len = 2;
|
|
|
+ rep = xenbus_msg_reply(XS_TRANSACTION_END, t, &req, 1);
|
|
|
+ err = errmsg(rep);
|
|
|
+ if (err) {
|
|
|
+ if (!strcmp(err, "EAGAIN")) {
|
|
|
+ *retry = 1;
|
|
|
+ free(err);
|
|
|
+ return NULL;
|
|
|
+ } else {
|
|
|
+ return err;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ free(rep);
|
|
|
+ return NULL;
|
|
|
+}
|
|
|
+
|
|
|
+int xenbus_read_integer(const char *path)
|
|
|
+{
|
|
|
+ char *res, *buf;
|
|
|
+ int t;
|
|
|
+
|
|
|
+ res = xenbus_read(XBT_NIL, path, &buf);
|
|
|
+ if (res) {
|
|
|
+ printk("Failed to read %s.\n", path);
|
|
|
+ free(res);
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+ sscanf(buf, "%d", &t);
|
|
|
+ free(buf);
|
|
|
+ return t;
|
|
|
+}
|
|
|
+
|
|
|
+int xenbus_read_uuid(const char *path, unsigned char uuid[16])
|
|
|
+{
|
|
|
+ char *res, *buf;
|
|
|
+
|
|
|
+ res = xenbus_read(XBT_NIL, path, &buf);
|
|
|
+ if (res) {
|
|
|
+ printk("Failed to read %s.\n", path);
|
|
|
+ free(res);
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ if (strlen(buf) != ((2 * 16) + 4) /* 16 hex bytes and 4 hyphens */
|
|
|
+ || sscanf(buf,
|
|
|
+ "%2hhx%2hhx%2hhx%2hhx-"
|
|
|
+ "%2hhx%2hhx-"
|
|
|
+ "%2hhx%2hhx-"
|
|
|
+ "%2hhx%2hhx-"
|
|
|
+ "%2hhx%2hhx%2hhx%2hhx%2hhx%2hhx",
|
|
|
+ uuid, uuid + 1, uuid + 2, uuid + 3,
|
|
|
+ uuid + 4, uuid + 5, uuid + 6, uuid + 7,
|
|
|
+ uuid + 8, uuid + 9, uuid + 10, uuid + 11,
|
|
|
+ uuid + 12, uuid + 13, uuid + 14, uuid + 15) != 16) {
|
|
|
+ printk("Xenbus path %s value %s is not a uuid!\n", path, buf);
|
|
|
+ free(buf);
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ free(buf);
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+char *xenbus_printf(xenbus_transaction_t xbt,
|
|
|
+ const char *node, const char *path,
|
|
|
+ const char *fmt, ...)
|
|
|
+{
|
|
|
+#define BUFFER_SIZE 256
|
|
|
+ char fullpath[BUFFER_SIZE];
|
|
|
+ char val[BUFFER_SIZE];
|
|
|
+ va_list args;
|
|
|
+
|
|
|
+ BUG_ON(strlen(node) + strlen(path) + 1 >= BUFFER_SIZE);
|
|
|
+ sprintf(fullpath, "%s/%s", node, path);
|
|
|
+ va_start(args, fmt);
|
|
|
+ vsprintf(val, fmt, args);
|
|
|
+ va_end(args);
|
|
|
+ return xenbus_write(xbt, fullpath, val);
|
|
|
+}
|
|
|
+
|
|
|
+domid_t xenbus_get_self_id(void)
|
|
|
+{
|
|
|
+ char *dom_id;
|
|
|
+ domid_t ret;
|
|
|
+
|
|
|
+ BUG_ON(xenbus_read(XBT_NIL, "domid", &dom_id));
|
|
|
+ sscanf(dom_id, "%"SCNd16, &ret);
|
|
|
+
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+void init_xenbus(void)
|
|
|
+{
|
|
|
+ u64 v;
|
|
|
+
|
|
|
+ debug("%s\n", __func__);
|
|
|
+ if (hvm_get_parameter(HVM_PARAM_STORE_EVTCHN, &v))
|
|
|
+ BUG();
|
|
|
+ xenbus_evtchn = v;
|
|
|
+
|
|
|
+ if (hvm_get_parameter(HVM_PARAM_STORE_PFN, &v))
|
|
|
+ BUG();
|
|
|
+ xenstore_buf = (struct xenstore_domain_interface *)map_frame_virt(v);
|
|
|
+}
|
|
|
+
|
|
|
+void fini_xenbus(void)
|
|
|
+{
|
|
|
+ debug("%s\n", __func__);
|
|
|
+}
|