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 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 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 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 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 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 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 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 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 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