2 * xen backend driver infrastructure
3 * (c) 2008 Gerd Hoffmann <kraxel@redhat.com>
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; under version 2 of the License.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License along
15 * with this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
20 * TODO: add some xenbus / xenstore concepts overview here.
30 #include <sys/types.h>
33 #include <sys/signal.h>
37 #include <xen/grant_table.h>
40 #include "qemu-char.h"
41 #include "xen_backend.h"
43 /* ------------------------------------------------------------- */
47 struct xs_handle
*xenstore
= NULL
;
50 static TAILQ_HEAD(XenDeviceHead
, XenDevice
) xendevs
= TAILQ_HEAD_INITIALIZER(xendevs
);
53 /* ------------------------------------------------------------- */
55 int xenstore_write_str(const char *base
, const char *node
, const char *val
)
57 char abspath
[XEN_BUFSIZE
];
59 snprintf(abspath
, sizeof(abspath
), "%s/%s", base
, node
);
60 if (!xs_write(xenstore
, 0, abspath
, val
, strlen(val
)))
65 char *xenstore_read_str(const char *base
, const char *node
)
67 char abspath
[XEN_BUFSIZE
];
69 char *str
, *ret
= NULL
;
71 snprintf(abspath
, sizeof(abspath
), "%s/%s", base
, node
);
72 str
= xs_read(xenstore
, 0, abspath
, &len
);
74 /* move to qemu-allocated memory to make sure
75 * callers can savely qemu_free() stuff. */
76 ret
= qemu_strdup(str
);
82 int xenstore_write_int(const char *base
, const char *node
, int ival
)
86 snprintf(val
, sizeof(val
), "%d", ival
);
87 return xenstore_write_str(base
, node
, val
);
90 int xenstore_read_int(const char *base
, const char *node
, int *ival
)
95 val
= xenstore_read_str(base
, node
);
96 if (val
&& 1 == sscanf(val
, "%d", ival
))
102 int xenstore_write_be_str(struct XenDevice
*xendev
, const char *node
, const char *val
)
104 return xenstore_write_str(xendev
->be
, node
, val
);
107 int xenstore_write_be_int(struct XenDevice
*xendev
, const char *node
, int ival
)
109 return xenstore_write_int(xendev
->be
, node
, ival
);
112 char *xenstore_read_be_str(struct XenDevice
*xendev
, const char *node
)
114 return xenstore_read_str(xendev
->be
, node
);
117 int xenstore_read_be_int(struct XenDevice
*xendev
, const char *node
, int *ival
)
119 return xenstore_read_int(xendev
->be
, node
, ival
);
122 char *xenstore_read_fe_str(struct XenDevice
*xendev
, const char *node
)
124 return xenstore_read_str(xendev
->fe
, node
);
127 int xenstore_read_fe_int(struct XenDevice
*xendev
, const char *node
, int *ival
)
129 return xenstore_read_int(xendev
->fe
, node
, ival
);
132 /* ------------------------------------------------------------- */
134 const char *xenbus_strstate(enum xenbus_state state
)
136 static const char *const name
[] = {
137 [ XenbusStateUnknown
] = "Unknown",
138 [ XenbusStateInitialising
] = "Initialising",
139 [ XenbusStateInitWait
] = "InitWait",
140 [ XenbusStateInitialised
] = "Initialised",
141 [ XenbusStateConnected
] = "Connected",
142 [ XenbusStateClosing
] = "Closing",
143 [ XenbusStateClosed
] = "Closed",
145 return (state
< ARRAY_SIZE(name
)) ? name
[state
] : "INVALID";
148 int xen_be_set_state(struct XenDevice
*xendev
, enum xenbus_state state
)
152 rc
= xenstore_write_be_int(xendev
, "state", state
);
155 xen_be_printf(xendev
, 1, "backend state: %s -> %s\n",
156 xenbus_strstate(xendev
->be_state
), xenbus_strstate(state
));
157 xendev
->be_state
= state
;
161 /* ------------------------------------------------------------- */
163 struct XenDevice
*xen_be_find_xendev(const char *type
, int dom
, int dev
)
165 struct XenDevice
*xendev
;
167 TAILQ_FOREACH(xendev
, &xendevs
, next
) {
168 if (xendev
->dom
!= dom
)
170 if (xendev
->dev
!= dev
)
172 if (strcmp(xendev
->type
, type
) != 0)
180 * get xen backend device, allocate a new one if it doesn't exist.
182 static struct XenDevice
*xen_be_get_xendev(const char *type
, int dom
, int dev
,
183 struct XenDevOps
*ops
)
185 struct XenDevice
*xendev
;
188 xendev
= xen_be_find_xendev(type
, dom
, dev
);
192 /* init new xendev */
193 xendev
= qemu_mallocz(ops
->size
);
199 dom0
= xs_get_domain_path(xenstore
, 0);
200 snprintf(xendev
->be
, sizeof(xendev
->be
), "%s/backend/%s/%d/%d",
201 dom0
, xendev
->type
, xendev
->dom
, xendev
->dev
);
202 snprintf(xendev
->name
, sizeof(xendev
->name
), "%s-%d",
203 xendev
->type
, xendev
->dev
);
206 xendev
->debug
= debug
;
207 xendev
->local_port
= -1;
209 xendev
->evtchndev
= xc_evtchn_open();
210 if (xendev
->evtchndev
< 0) {
211 xen_be_printf(NULL
, 0, "can't open evtchn device\n");
215 fcntl(xc_evtchn_fd(xendev
->evtchndev
), F_SETFD
, FD_CLOEXEC
);
217 if (ops
->flags
& DEVOPS_FLAG_NEED_GNTDEV
) {
218 xendev
->gnttabdev
= xc_gnttab_open();
219 if (xendev
->gnttabdev
< 0) {
220 xen_be_printf(NULL
, 0, "can't open gnttab device\n");
221 xc_evtchn_close(xendev
->evtchndev
);
226 xendev
->gnttabdev
= -1;
229 TAILQ_INSERT_TAIL(&xendevs
, xendev
, next
);
231 if (xendev
->ops
->alloc
)
232 xendev
->ops
->alloc(xendev
);
238 * release xen backend device.
240 static struct XenDevice
*xen_be_del_xendev(int dom
, int dev
)
242 struct XenDevice
*xendev
, *xnext
;
245 * This is pretty much like TAILQ_FOREACH(xendev, &xendevs, next) but
246 * we save the next pointer in xnext because we might free xendev.
248 xnext
= xendevs
.tqh_first
;
251 xnext
= xendev
->next
.tqe_next
;
253 if (xendev
->dom
!= dom
)
255 if (xendev
->dev
!= dev
&& dev
!= -1)
258 if (xendev
->ops
->free
)
259 xendev
->ops
->free(xendev
);
262 char token
[XEN_BUFSIZE
];
263 snprintf(token
, sizeof(token
), "fe:%p", xendev
);
264 xs_unwatch(xenstore
, xendev
->fe
, token
);
265 qemu_free(xendev
->fe
);
268 if (xendev
->evtchndev
>= 0)
269 xc_evtchn_close(xendev
->evtchndev
);
270 if (xendev
->gnttabdev
>= 0)
271 xc_gnttab_close(xendev
->gnttabdev
);
273 TAILQ_REMOVE(&xendevs
, xendev
, next
);
280 * Sync internal data structures on xenstore updates.
281 * Node specifies the changed field. node = NULL means
282 * update all fields (used for initialization).
284 static void xen_be_backend_changed(struct XenDevice
*xendev
, const char *node
)
286 if (node
== NULL
|| strcmp(node
, "online") == 0) {
287 if (xenstore_read_be_int(xendev
, "online", &xendev
->online
) == -1)
292 xen_be_printf(xendev
, 2, "backend update: %s\n", node
);
293 if (xendev
->ops
->backend_changed
)
294 xendev
->ops
->backend_changed(xendev
, node
);
298 static void xen_be_frontend_changed(struct XenDevice
*xendev
, const char *node
)
302 if (node
== NULL
|| strcmp(node
, "state") == 0) {
303 if (xenstore_read_fe_int(xendev
, "state", &fe_state
) == -1)
304 fe_state
= XenbusStateUnknown
;
305 if (xendev
->fe_state
!= fe_state
)
306 xen_be_printf(xendev
, 1, "frontend state: %s -> %s\n",
307 xenbus_strstate(xendev
->fe_state
),
308 xenbus_strstate(fe_state
));
309 xendev
->fe_state
= fe_state
;
311 if (node
== NULL
|| strcmp(node
, "protocol") == 0) {
312 qemu_free(xendev
->protocol
);
313 xendev
->protocol
= xenstore_read_fe_str(xendev
, "protocol");
314 if (xendev
->protocol
)
315 xen_be_printf(xendev
, 1, "frontend protocol: %s\n", xendev
->protocol
);
319 xen_be_printf(xendev
, 2, "frontend update: %s\n", node
);
320 if (xendev
->ops
->frontend_changed
)
321 xendev
->ops
->frontend_changed(xendev
, node
);
325 /* ------------------------------------------------------------- */
326 /* Check for possible state transitions and perform them. */
329 * Initial xendev setup. Read frontend path, register watch for it.
330 * Should succeed once xend finished setting up the backend device.
332 * Also sets initial state (-> Initializing) when done. Which
333 * only affects the xendev->be_state variable as xenbus should
334 * already be put into that state by xend.
336 static int xen_be_try_setup(struct XenDevice
*xendev
)
338 char token
[XEN_BUFSIZE
];
341 if (xenstore_read_be_int(xendev
, "state", &be_state
) == -1) {
342 xen_be_printf(xendev
, 0, "reading backend state failed\n");
346 if (be_state
!= XenbusStateInitialising
) {
347 xen_be_printf(xendev
, 0, "initial backend state is wrong (%s)\n",
348 xenbus_strstate(be_state
));
352 xendev
->fe
= xenstore_read_be_str(xendev
, "frontend");
353 if (xendev
->fe
== NULL
) {
354 xen_be_printf(xendev
, 0, "reading frontend path failed\n");
358 /* setup frontend watch */
359 snprintf(token
, sizeof(token
), "fe:%p", xendev
);
360 if (!xs_watch(xenstore
, xendev
->fe
, token
)) {
361 xen_be_printf(xendev
, 0, "watching frontend path (%s) failed\n",
365 xen_be_set_state(xendev
, XenbusStateInitialising
);
367 xen_be_backend_changed(xendev
, NULL
);
368 xen_be_frontend_changed(xendev
, NULL
);
373 * Try initialize xendev. Prepare everything the backend can do
374 * without synchronizing with the frontend. Fakes hotplug-status. No
375 * hotplug involved here because this is about userspace drivers, thus
376 * there are kernel backend devices which could invoke hotplug.
378 * Goes to InitWait on success.
380 static int xen_be_try_init(struct XenDevice
*xendev
)
384 if (!xendev
->online
) {
385 xen_be_printf(xendev
, 1, "not online\n");
389 if (xendev
->ops
->init
)
390 rc
= xendev
->ops
->init(xendev
);
392 xen_be_printf(xendev
, 1, "init() failed\n");
396 xenstore_write_be_str(xendev
, "hotplug-status", "connected");
397 xen_be_set_state(xendev
, XenbusStateInitWait
);
402 * Try to connect xendev. Depends on the frontend being ready
403 * for it (shared ring and evtchn info in xenstore, state being
404 * Initialised or Connected).
406 * Goes to Connected on success.
408 static int xen_be_try_connect(struct XenDevice
*xendev
)
412 if (xendev
->fe_state
!= XenbusStateInitialised
&&
413 xendev
->fe_state
!= XenbusStateConnected
) {
414 if (xendev
->ops
->flags
& DEVOPS_FLAG_IGNORE_STATE
) {
415 xen_be_printf(xendev
, 2, "frontend not ready, ignoring\n");
417 xen_be_printf(xendev
, 2, "frontend not ready (yet)\n");
422 if (xendev
->ops
->connect
)
423 rc
= xendev
->ops
->connect(xendev
);
425 xen_be_printf(xendev
, 0, "connect() failed\n");
429 xen_be_set_state(xendev
, XenbusStateConnected
);
434 * Teardown connection.
436 * Goes to Closed when done.
438 static void xen_be_disconnect(struct XenDevice
*xendev
, enum xenbus_state state
)
440 if (xendev
->be_state
!= XenbusStateClosing
&&
441 xendev
->be_state
!= XenbusStateClosed
&&
442 xendev
->ops
->disconnect
)
443 xendev
->ops
->disconnect(xendev
);
444 if (xendev
->be_state
!= state
)
445 xen_be_set_state(xendev
, state
);
449 * Try to reset xendev, for reconnection by another frontend instance.
451 static int xen_be_try_reset(struct XenDevice
*xendev
)
453 if (xendev
->fe_state
!= XenbusStateInitialising
)
456 xen_be_printf(xendev
, 1, "device reset (for re-connect)\n");
457 xen_be_set_state(xendev
, XenbusStateInitialising
);
462 * state change dispatcher function
464 void xen_be_check_state(struct XenDevice
*xendev
)
468 /* frontend may request shutdown from almost anywhere */
469 if (xendev
->fe_state
== XenbusStateClosing
||
470 xendev
->fe_state
== XenbusStateClosed
) {
471 xen_be_disconnect(xendev
, xendev
->fe_state
);
475 /* check for possible backend state transitions */
477 switch (xendev
->be_state
) {
478 case XenbusStateUnknown
:
479 rc
= xen_be_try_setup(xendev
);
481 case XenbusStateInitialising
:
482 rc
= xen_be_try_init(xendev
);
484 case XenbusStateInitWait
:
485 rc
= xen_be_try_connect(xendev
);
487 case XenbusStateClosed
:
488 rc
= xen_be_try_reset(xendev
);
498 /* ------------------------------------------------------------- */
500 static int xenstore_scan(const char *type
, int dom
, struct XenDevOps
*ops
)
502 struct XenDevice
*xendev
;
503 char path
[XEN_BUFSIZE
], token
[XEN_BUFSIZE
];
504 char **dev
= NULL
, *dom0
;
505 unsigned int cdev
, j
;
508 dom0
= xs_get_domain_path(xenstore
, 0);
509 snprintf(token
, sizeof(token
), "be:%p:%d:%p", type
, dom
, ops
);
510 snprintf(path
, sizeof(path
), "%s/backend/%s/%d", dom0
, type
, dom
);
512 if (!xs_watch(xenstore
, path
, token
)) {
513 xen_be_printf(NULL
, 0, "xen be: watching backend path (%s) failed\n", path
);
517 /* look for backends */
518 dev
= xs_directory(xenstore
, 0, path
, &cdev
);
521 for (j
= 0; j
< cdev
; j
++) {
522 xendev
= xen_be_get_xendev(type
, dom
, atoi(dev
[j
]), ops
);
525 xen_be_check_state(xendev
);
531 static void xenstore_update_be(char *watch
, char *type
, int dom
,
532 struct XenDevOps
*ops
)
534 struct XenDevice
*xendev
;
535 char path
[XEN_BUFSIZE
], *dom0
;
536 unsigned int len
, dev
;
538 dom0
= xs_get_domain_path(xenstore
, 0);
539 len
= snprintf(path
, sizeof(path
), "%s/backend/%s/%d", dom0
, type
, dom
);
541 if (strncmp(path
, watch
, len
) != 0)
543 if (sscanf(watch
+len
, "/%u/%255s", &dev
, path
) != 2) {
545 if (sscanf(watch
+len
, "/%u", &dev
) != 1)
552 /* FIXME: detect devices being deleted from xenstore ... */
553 xen_be_del_xendev(dom
, dev
);
556 xendev
= xen_be_get_xendev(type
, dom
, dev
, ops
);
557 if (xendev
!= NULL
) {
558 xen_be_backend_changed(xendev
, path
);
559 xen_be_check_state(xendev
);
563 static void xenstore_update_fe(char *watch
, struct XenDevice
*xendev
)
568 len
= strlen(xendev
->fe
);
569 if (strncmp(xendev
->fe
, watch
, len
) != 0)
571 if (watch
[len
] != '/')
573 node
= watch
+ len
+ 1;
575 xen_be_frontend_changed(xendev
, node
);
576 xen_be_check_state(xendev
);
579 static void xenstore_update(void *unused
)
582 intptr_t type
, ops
, ptr
;
583 unsigned int dom
, count
;
585 vec
= xs_read_watch(xenstore
, &count
);
589 if (sscanf(vec
[XS_WATCH_TOKEN
], "be:%" PRIxPTR
":%d:%" PRIxPTR
,
590 &type
, &dom
, &ops
) == 3)
591 xenstore_update_be(vec
[XS_WATCH_PATH
], (void*)type
, dom
, (void*)ops
);
592 if (sscanf(vec
[XS_WATCH_TOKEN
], "fe:%" PRIxPTR
, &ptr
) == 1)
593 xenstore_update_fe(vec
[XS_WATCH_PATH
], (void*)ptr
);
599 static void xen_be_evtchn_event(void *opaque
)
601 struct XenDevice
*xendev
= opaque
;
604 port
= xc_evtchn_pending(xendev
->evtchndev
);
605 if (port
!= xendev
->local_port
) {
606 xen_be_printf(xendev
, 0, "xc_evtchn_pending returned %d (expected %d)\n",
607 port
, xendev
->local_port
);
610 xc_evtchn_unmask(xendev
->evtchndev
, port
);
612 if (xendev
->ops
->event
)
613 xendev
->ops
->event(xendev
);
616 /* -------------------------------------------------------------------- */
618 int xen_be_init(void)
620 xenstore
= xs_daemon_open();
622 xen_be_printf(NULL
, 0, "can't connect to xenstored\n");
626 if (qemu_set_fd_handler(xs_fileno(xenstore
), xenstore_update
, NULL
, NULL
) < 0)
629 xen_xc
= xc_interface_open();
631 xen_be_printf(NULL
, 0, "can't open xen interface\n");
637 qemu_set_fd_handler(xs_fileno(xenstore
), NULL
, NULL
, NULL
);
638 xs_daemon_close(xenstore
);
644 int xen_be_register(const char *type
, struct XenDevOps
*ops
)
646 return xenstore_scan(type
, xen_domid
, ops
);
649 int xen_be_bind_evtchn(struct XenDevice
*xendev
)
651 if (xendev
->local_port
!= -1)
653 xendev
->local_port
= xc_evtchn_bind_interdomain
654 (xendev
->evtchndev
, xendev
->dom
, xendev
->remote_port
);
655 if (xendev
->local_port
== -1) {
656 xen_be_printf(xendev
, 0, "xc_evtchn_bind_interdomain failed\n");
659 xen_be_printf(xendev
, 2, "bind evtchn port %d\n", xendev
->local_port
);
660 qemu_set_fd_handler(xc_evtchn_fd(xendev
->evtchndev
),
661 xen_be_evtchn_event
, NULL
, xendev
);
665 void xen_be_unbind_evtchn(struct XenDevice
*xendev
)
667 if (xendev
->local_port
== -1)
669 qemu_set_fd_handler(xc_evtchn_fd(xendev
->evtchndev
), NULL
, NULL
, NULL
);
670 xc_evtchn_unbind(xendev
->evtchndev
, xendev
->local_port
);
671 xen_be_printf(xendev
, 2, "unbind evtchn port %d\n", xendev
->local_port
);
672 xendev
->local_port
= -1;
675 int xen_be_send_notify(struct XenDevice
*xendev
)
677 return xc_evtchn_notify(xendev
->evtchndev
, xendev
->local_port
);
682 * 0 == errors (stderr + logfile).
683 * 1 == informative debug messages (logfile only).
684 * 2 == noisy debug messages (logfile only).
685 * 3 == will flood your log (logfile only).
687 void xen_be_printf(struct XenDevice
*xendev
, int msg_level
, const char *fmt
, ...)
692 if (msg_level
> xendev
->debug
)
694 qemu_log("xen be: %s: ", xendev
->name
);
696 fprintf(stderr
, "xen be: %s: ", xendev
->name
);
698 if (msg_level
> debug
)
700 qemu_log("xen be core: ");
702 fprintf(stderr
, "xen be core: ");
705 qemu_log_vprintf(fmt
, args
);
707 if (msg_level
== 0) {
709 vfprintf(stderr
, fmt
, args
);