xref: /qemu/hw/xen/xen_pvdev.c (revision 6402cbbb) 
1 /*
2  * Xen para-virtualization device
3  *
4  *  (c) 2008 Gerd Hoffmann <kraxel@redhat.com>
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, see <http://www.gnu.org/licenses/>
18  */
19 
20 #include "qemu/osdep.h"
21 #include "qemu/log.h"
22 #include "hw/qdev-core.h"
23 #include "hw/xen/xen_backend.h"
24 #include "hw/xen/xen_pvdev.h"
25 
26 /* private */
27 static int debug;
28 
29 struct xs_dirs {
30     char *xs_dir;
31     QTAILQ_ENTRY(xs_dirs) list;
32 };
33 
34 static QTAILQ_HEAD(xs_dirs_head, xs_dirs) xs_cleanup =
35     QTAILQ_HEAD_INITIALIZER(xs_cleanup);
36 
37 static QTAILQ_HEAD(XenDeviceHead, XenDevice) xendevs =
38     QTAILQ_HEAD_INITIALIZER(xendevs);
39 
40 /* ------------------------------------------------------------- */
41 
42 static void xenstore_cleanup_dir(char *dir)
43 {
44     struct xs_dirs *d;
45 
46     d = g_malloc(sizeof(*d));
47     d->xs_dir = dir;
48     QTAILQ_INSERT_TAIL(&xs_cleanup, d, list);
49 }
50 
51 void xen_config_cleanup(void)
52 {
53     struct xs_dirs *d;
54 
55     QTAILQ_FOREACH(d, &xs_cleanup, list) {
56         xs_rm(xenstore, 0, d->xs_dir);
57     }
58 }
59 
60 int xenstore_mkdir(char *path, int p)
61 {
62     struct xs_permissions perms[2] = {
63         {
64             .id    = 0, /* set owner: dom0 */
65         }, {
66             .id    = xen_domid,
67             .perms = p,
68         }
69     };
70 
71     if (!xs_mkdir(xenstore, 0, path)) {
72         xen_pv_printf(NULL, 0, "xs_mkdir %s: failed\n", path);
73         return -1;
74     }
75     xenstore_cleanup_dir(g_strdup(path));
76 
77     if (!xs_set_permissions(xenstore, 0, path, perms, 2)) {
78         xen_pv_printf(NULL, 0, "xs_set_permissions %s: failed\n", path);
79         return -1;
80     }
81     return 0;
82 }
83 
84 int xenstore_write_str(const char *base, const char *node, const char *val)
85 {
86     char abspath[XEN_BUFSIZE];
87 
88     snprintf(abspath, sizeof(abspath), "%s/%s", base, node);
89     if (!xs_write(xenstore, 0, abspath, val, strlen(val))) {
90         return -1;
91     }
92     return 0;
93 }
94 
95 char *xenstore_read_str(const char *base, const char *node)
96 {
97     char abspath[XEN_BUFSIZE];
98     unsigned int len;
99     char *str, *ret = NULL;
100 
101     snprintf(abspath, sizeof(abspath), "%s/%s", base, node);
102     str = xs_read(xenstore, 0, abspath, &len);
103     if (str != NULL) {
104         /* move to qemu-allocated memory to make sure
105          * callers can savely g_free() stuff. */
106         ret = g_strdup(str);
107         free(str);
108     }
109     return ret;
110 }
111 
112 int xenstore_write_int(const char *base, const char *node, int ival)
113 {
114     char val[12];
115 
116     snprintf(val, sizeof(val), "%d", ival);
117     return xenstore_write_str(base, node, val);
118 }
119 
120 int xenstore_write_int64(const char *base, const char *node, int64_t ival)
121 {
122     char val[21];
123 
124     snprintf(val, sizeof(val), "%"PRId64, ival);
125     return xenstore_write_str(base, node, val);
126 }
127 
128 int xenstore_read_int(const char *base, const char *node, int *ival)
129 {
130     char *val;
131     int rc = -1;
132 
133     val = xenstore_read_str(base, node);
134     if (val && 1 == sscanf(val, "%d", ival)) {
135         rc = 0;
136     }
137     g_free(val);
138     return rc;
139 }
140 
141 int xenstore_read_uint64(const char *base, const char *node, uint64_t *uval)
142 {
143     char *val;
144     int rc = -1;
145 
146     val = xenstore_read_str(base, node);
147     if (val && 1 == sscanf(val, "%"SCNu64, uval)) {
148         rc = 0;
149     }
150     g_free(val);
151     return rc;
152 }
153 
154 void xenstore_update(void *unused)
155 {
156     char **vec = NULL;
157     intptr_t type, ops, ptr;
158     unsigned int dom, count;
159 
160     vec = xs_read_watch(xenstore, &count);
161     if (vec == NULL) {
162         goto cleanup;
163     }
164 
165     if (sscanf(vec[XS_WATCH_TOKEN], "be:%" PRIxPTR ":%d:%" PRIxPTR,
166                &type, &dom, &ops) == 3) {
167         xenstore_update_be(vec[XS_WATCH_PATH], (void *)type, dom, (void*)ops);
168     }
169     if (sscanf(vec[XS_WATCH_TOKEN], "fe:%" PRIxPTR, &ptr) == 1) {
170         xenstore_update_fe(vec[XS_WATCH_PATH], (void *)ptr);
171     }
172 
173 cleanup:
174     free(vec);
175 }
176 
177 const char *xenbus_strstate(enum xenbus_state state)
178 {
179     static const char *const name[] = {
180         [XenbusStateUnknown]       = "Unknown",
181         [XenbusStateInitialising]  = "Initialising",
182         [XenbusStateInitWait]      = "InitWait",
183         [XenbusStateInitialised]   = "Initialised",
184         [XenbusStateConnected]     = "Connected",
185         [XenbusStateClosing]       = "Closing",
186         [XenbusStateClosed]        = "Closed",
187     };
188     return (state < ARRAY_SIZE(name)) ? name[state] : "INVALID";
189 }
190 
191 /*
192  * msg_level:
193  *  0 == errors (stderr + logfile).
194  *  1 == informative debug messages (logfile only).
195  *  2 == noisy debug messages (logfile only).
196  *  3 == will flood your log (logfile only).
197  */
198 void xen_pv_printf(struct XenDevice *xendev, int msg_level,
199                    const char *fmt, ...)
200 {
201     va_list args;
202 
203     if (xendev) {
204         if (msg_level > xendev->debug) {
205             return;
206         }
207         qemu_log("xen be: %s: ", xendev->name);
208         if (msg_level == 0) {
209             fprintf(stderr, "xen be: %s: ", xendev->name);
210         }
211     } else {
212         if (msg_level > debug) {
213             return;
214         }
215         qemu_log("xen be core: ");
216         if (msg_level == 0) {
217             fprintf(stderr, "xen be core: ");
218         }
219     }
220     va_start(args, fmt);
221     qemu_log_vprintf(fmt, args);
222     va_end(args);
223     if (msg_level == 0) {
224         va_start(args, fmt);
225         vfprintf(stderr, fmt, args);
226         va_end(args);
227     }
228     qemu_log_flush();
229 }
230 
231 void xen_pv_evtchn_event(void *opaque)
232 {
233     struct XenDevice *xendev = opaque;
234     evtchn_port_t port;
235 
236     port = xenevtchn_pending(xendev->evtchndev);
237     if (port != xendev->local_port) {
238         xen_pv_printf(xendev, 0,
239                       "xenevtchn_pending returned %d (expected %d)\n",
240                       port, xendev->local_port);
241         return;
242     }
243     xenevtchn_unmask(xendev->evtchndev, port);
244 
245     if (xendev->ops->event) {
246         xendev->ops->event(xendev);
247     }
248 }
249 
250 void xen_pv_unbind_evtchn(struct XenDevice *xendev)
251 {
252     if (xendev->local_port == -1) {
253         return;
254     }
255     qemu_set_fd_handler(xenevtchn_fd(xendev->evtchndev), NULL, NULL, NULL);
256     xenevtchn_unbind(xendev->evtchndev, xendev->local_port);
257     xen_pv_printf(xendev, 2, "unbind evtchn port %d\n", xendev->local_port);
258     xendev->local_port = -1;
259 }
260 
261 int xen_pv_send_notify(struct XenDevice *xendev)
262 {
263     return xenevtchn_notify(xendev->evtchndev, xendev->local_port);
264 }
265 
266 /* ------------------------------------------------------------- */
267 
268 struct XenDevice *xen_pv_find_xendev(const char *type, int dom, int dev)
269 {
270     struct XenDevice *xendev;
271 
272     QTAILQ_FOREACH(xendev, &xendevs, next) {
273         if (xendev->dom != dom) {
274             continue;
275         }
276         if (xendev->dev != dev) {
277             continue;
278         }
279         if (strcmp(xendev->type, type) != 0) {
280             continue;
281         }
282         return xendev;
283     }
284     return NULL;
285 }
286 
287 /*
288  * release xen backend device.
289  */
290 void xen_pv_del_xendev(struct XenDevice *xendev)
291 {
292     if (xendev->ops->free) {
293         xendev->ops->free(xendev);
294     }
295 
296     if (xendev->fe) {
297         char token[XEN_BUFSIZE];
298         snprintf(token, sizeof(token), "fe:%p", xendev);
299         xs_unwatch(xenstore, xendev->fe, token);
300         g_free(xendev->fe);
301     }
302 
303     if (xendev->evtchndev != NULL) {
304         xenevtchn_close(xendev->evtchndev);
305     }
306     if (xendev->gnttabdev != NULL) {
307         xengnttab_close(xendev->gnttabdev);
308     }
309 
310     QTAILQ_REMOVE(&xendevs, xendev, next);
311 
312     qdev_unplug(&xendev->qdev, NULL);
313 }
314 
315 void xen_pv_insert_xendev(struct XenDevice *xendev)
316 {
317     QTAILQ_INSERT_TAIL(&xendevs, xendev, next);
318 }
319