xref: /openbmc/qemu/hw/xen/xen-bus-helper.c (revision ba2a92db)
1 /*
2  * Copyright (c) 2018  Citrix Systems Inc.
3  *
4  * This work is licensed under the terms of the GNU GPL, version 2 or later.
5  * See the COPYING file in the top-level directory.
6  */
7 
8 #include "qemu/osdep.h"
9 #include "hw/xen/xen.h"
10 #include "hw/xen/xen-bus.h"
11 #include "hw/xen/xen-bus-helper.h"
12 #include "qapi/error.h"
13 #include "trace.h"
14 
15 #include <glib/gprintf.h>
16 
17 struct xs_state {
18     enum xenbus_state statenum;
19     const char *statestr;
20 };
21 #define XS_STATE(state) { state, #state }
22 
23 static struct xs_state xs_state[] = {
24     XS_STATE(XenbusStateUnknown),
25     XS_STATE(XenbusStateInitialising),
26     XS_STATE(XenbusStateInitWait),
27     XS_STATE(XenbusStateInitialised),
28     XS_STATE(XenbusStateConnected),
29     XS_STATE(XenbusStateClosing),
30     XS_STATE(XenbusStateClosed),
31     XS_STATE(XenbusStateReconfiguring),
32     XS_STATE(XenbusStateReconfigured),
33 };
34 
35 #undef XS_STATE
36 
xs_strstate(enum xenbus_state state)37 const char *xs_strstate(enum xenbus_state state)
38 {
39     unsigned int i;
40 
41    for (i = 0; i < ARRAY_SIZE(xs_state); i++) {
42         if (xs_state[i].statenum == state) {
43             return xs_state[i].statestr;
44         }
45     }
46 
47     return "INVALID";
48 }
49 
xs_node_create(struct qemu_xs_handle * h,xs_transaction_t tid,const char * node,unsigned int owner,unsigned int domid,unsigned int perms,Error ** errp)50 void xs_node_create(struct qemu_xs_handle *h, xs_transaction_t tid,
51                     const char *node, unsigned int owner, unsigned int domid,
52                     unsigned int perms, Error **errp)
53 {
54     trace_xs_node_create(node);
55 
56     if (!qemu_xen_xs_create(h, tid, owner, domid, perms, node)) {
57         error_setg_errno(errp, errno, "failed to create node '%s'", node);
58     }
59 }
60 
xs_node_destroy(struct qemu_xs_handle * h,xs_transaction_t tid,const char * node,Error ** errp)61 void xs_node_destroy(struct qemu_xs_handle *h, xs_transaction_t tid,
62                      const char *node, Error **errp)
63 {
64     trace_xs_node_destroy(node);
65 
66     if (!qemu_xen_xs_destroy(h, tid, node)) {
67         error_setg_errno(errp, errno, "failed to destroy node '%s'", node);
68     }
69 }
70 
xs_node_vprintf(struct qemu_xs_handle * h,xs_transaction_t tid,const char * node,const char * key,Error ** errp,const char * fmt,va_list ap)71 void xs_node_vprintf(struct qemu_xs_handle *h, xs_transaction_t tid,
72                      const char *node, const char *key, Error **errp,
73                      const char *fmt, va_list ap)
74 {
75     char *path, *value;
76     int len;
77 
78     path = (strlen(node) != 0) ? g_strdup_printf("%s/%s", node, key) :
79         g_strdup(key);
80     len = g_vasprintf(&value, fmt, ap);
81 
82     trace_xs_node_vprintf(path, value);
83 
84     if (!qemu_xen_xs_write(h, tid, path, value, len)) {
85         error_setg_errno(errp, errno, "failed to write '%s' to '%s'",
86                          value, path);
87     }
88 
89     g_free(value);
90     g_free(path);
91 }
92 
xs_node_printf(struct qemu_xs_handle * h,xs_transaction_t tid,const char * node,const char * key,Error ** errp,const char * fmt,...)93 void xs_node_printf(struct qemu_xs_handle *h,  xs_transaction_t tid,
94                     const char *node, const char *key, Error **errp,
95                     const char *fmt, ...)
96 {
97     va_list ap;
98 
99     va_start(ap, fmt);
100     xs_node_vprintf(h, tid, node, key, errp, fmt, ap);
101     va_end(ap);
102 }
103 
xs_node_vscanf(struct qemu_xs_handle * h,xs_transaction_t tid,const char * node,const char * key,Error ** errp,const char * fmt,va_list ap)104 int xs_node_vscanf(struct qemu_xs_handle *h,  xs_transaction_t tid,
105                    const char *node, const char *key, Error **errp,
106                    const char *fmt, va_list ap)
107 {
108     char *path, *value;
109     int rc;
110 
111     path = (strlen(node) != 0) ? g_strdup_printf("%s/%s", node, key) :
112         g_strdup(key);
113     value = qemu_xen_xs_read(h, tid, path, NULL);
114 
115     trace_xs_node_vscanf(path, value);
116 
117     if (value) {
118         rc = vsscanf(value, fmt, ap);
119     } else {
120         error_setg_errno(errp, errno, "failed to read from '%s'",
121                          path);
122         rc = EOF;
123     }
124 
125     free(value);
126     g_free(path);
127 
128     return rc;
129 }
130 
xs_node_scanf(struct qemu_xs_handle * h,xs_transaction_t tid,const char * node,const char * key,Error ** errp,const char * fmt,...)131 int xs_node_scanf(struct qemu_xs_handle *h,  xs_transaction_t tid,
132                   const char *node, const char *key, Error **errp,
133                   const char *fmt, ...)
134 {
135     va_list ap;
136     int rc;
137 
138     va_start(ap, fmt);
139     rc = xs_node_vscanf(h, tid, node, key, errp, fmt, ap);
140     va_end(ap);
141 
142     return rc;
143 }
144 
xs_node_watch(struct qemu_xs_handle * h,const char * node,const char * key,xs_watch_fn fn,void * opaque,Error ** errp)145 struct qemu_xs_watch *xs_node_watch(struct qemu_xs_handle *h, const char *node,
146                                     const char *key, xs_watch_fn fn,
147                                     void *opaque, Error **errp)
148 {
149     char *path;
150     struct qemu_xs_watch *w;
151 
152     path = (strlen(node) != 0) ? g_strdup_printf("%s/%s", node, key) :
153         g_strdup(key);
154 
155     trace_xs_node_watch(path);
156 
157     w = qemu_xen_xs_watch(h, path, fn, opaque);
158     if (!w) {
159         error_setg_errno(errp, errno, "failed to watch node '%s'", path);
160     }
161 
162     g_free(path);
163 
164     return w;
165 }
166 
xs_node_unwatch(struct qemu_xs_handle * h,struct qemu_xs_watch * w)167 void xs_node_unwatch(struct qemu_xs_handle *h, struct qemu_xs_watch *w)
168 {
169     qemu_xen_xs_unwatch(h, w);
170 }
171