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, see <http://www.gnu.org/licenses/>.
17 * Contributions after 2012-01-13 are licensed under the terms of the
18 * GNU GPL, version 2 or (at your option) any later version.
22 * TODO: add some xenbus / xenstore concepts overview here.
25 #include "qemu/osdep.h"
26 #include <sys/signal.h>
29 #include "sysemu/char.h"
31 #include "hw/xen/xen_backend.h"
33 #include <xen/grant_table.h>
35 /* ------------------------------------------------------------- */
38 xc_interface
*xen_xc
= NULL
;
39 xenforeignmemory_handle
*xen_fmem
= NULL
;
40 struct xs_handle
*xenstore
= NULL
;
41 const char *xen_protocol
;
46 QTAILQ_ENTRY(xs_dirs
) list
;
48 static QTAILQ_HEAD(xs_dirs_head
, xs_dirs
) xs_cleanup
=
49 QTAILQ_HEAD_INITIALIZER(xs_cleanup
);
51 static QTAILQ_HEAD(XenDeviceHead
, XenDevice
) xendevs
= QTAILQ_HEAD_INITIALIZER(xendevs
);
54 /* ------------------------------------------------------------- */
56 static void xenstore_cleanup_dir(char *dir
)
60 d
= g_malloc(sizeof(*d
));
62 QTAILQ_INSERT_TAIL(&xs_cleanup
, d
, list
);
65 void xen_config_cleanup(void)
69 QTAILQ_FOREACH(d
, &xs_cleanup
, list
) {
70 xs_rm(xenstore
, 0, d
->xs_dir
);
74 int xenstore_write_str(const char *base
, const char *node
, const char *val
)
76 char abspath
[XEN_BUFSIZE
];
78 snprintf(abspath
, sizeof(abspath
), "%s/%s", base
, node
);
79 if (!xs_write(xenstore
, 0, abspath
, val
, strlen(val
))) {
85 char *xenstore_read_str(const char *base
, const char *node
)
87 char abspath
[XEN_BUFSIZE
];
89 char *str
, *ret
= NULL
;
91 snprintf(abspath
, sizeof(abspath
), "%s/%s", base
, node
);
92 str
= xs_read(xenstore
, 0, abspath
, &len
);
94 /* move to qemu-allocated memory to make sure
95 * callers can savely g_free() stuff. */
102 int xenstore_mkdir(char *path
, int p
)
104 struct xs_permissions perms
[2] = {
106 .id
= 0, /* set owner: dom0 */
113 if (!xs_mkdir(xenstore
, 0, path
)) {
114 xen_be_printf(NULL
, 0, "xs_mkdir %s: failed\n", path
);
117 xenstore_cleanup_dir(g_strdup(path
));
119 if (!xs_set_permissions(xenstore
, 0, path
, perms
, 2)) {
120 xen_be_printf(NULL
, 0, "xs_set_permissions %s: failed\n", path
);
126 int xenstore_write_int(const char *base
, const char *node
, int ival
)
130 snprintf(val
, sizeof(val
), "%d", ival
);
131 return xenstore_write_str(base
, node
, val
);
134 int xenstore_write_int64(const char *base
, const char *node
, int64_t ival
)
138 snprintf(val
, sizeof(val
), "%"PRId64
, ival
);
139 return xenstore_write_str(base
, node
, val
);
142 int xenstore_read_int(const char *base
, const char *node
, int *ival
)
147 val
= xenstore_read_str(base
, node
);
148 if (val
&& 1 == sscanf(val
, "%d", ival
)) {
155 int xenstore_read_uint64(const char *base
, const char *node
, uint64_t *uval
)
160 val
= xenstore_read_str(base
, node
);
161 if (val
&& 1 == sscanf(val
, "%"SCNu64
, uval
)) {
168 int xenstore_write_be_str(struct XenDevice
*xendev
, const char *node
, const char *val
)
170 return xenstore_write_str(xendev
->be
, node
, val
);
173 int xenstore_write_be_int(struct XenDevice
*xendev
, const char *node
, int ival
)
175 return xenstore_write_int(xendev
->be
, node
, ival
);
178 int xenstore_write_be_int64(struct XenDevice
*xendev
, const char *node
, int64_t ival
)
180 return xenstore_write_int64(xendev
->be
, node
, ival
);
183 char *xenstore_read_be_str(struct XenDevice
*xendev
, const char *node
)
185 return xenstore_read_str(xendev
->be
, node
);
188 int xenstore_read_be_int(struct XenDevice
*xendev
, const char *node
, int *ival
)
190 return xenstore_read_int(xendev
->be
, node
, ival
);
193 char *xenstore_read_fe_str(struct XenDevice
*xendev
, const char *node
)
195 return xenstore_read_str(xendev
->fe
, node
);
198 int xenstore_read_fe_int(struct XenDevice
*xendev
, const char *node
, int *ival
)
200 return xenstore_read_int(xendev
->fe
, node
, ival
);
203 int xenstore_read_fe_uint64(struct XenDevice
*xendev
, const char *node
, uint64_t *uval
)
205 return xenstore_read_uint64(xendev
->fe
, node
, uval
);
208 /* ------------------------------------------------------------- */
210 const char *xenbus_strstate(enum xenbus_state state
)
212 static const char *const name
[] = {
213 [ XenbusStateUnknown
] = "Unknown",
214 [ XenbusStateInitialising
] = "Initialising",
215 [ XenbusStateInitWait
] = "InitWait",
216 [ XenbusStateInitialised
] = "Initialised",
217 [ XenbusStateConnected
] = "Connected",
218 [ XenbusStateClosing
] = "Closing",
219 [ XenbusStateClosed
] = "Closed",
221 return (state
< ARRAY_SIZE(name
)) ? name
[state
] : "INVALID";
224 int xen_be_set_state(struct XenDevice
*xendev
, enum xenbus_state state
)
228 rc
= xenstore_write_be_int(xendev
, "state", state
);
232 xen_be_printf(xendev
, 1, "backend state: %s -> %s\n",
233 xenbus_strstate(xendev
->be_state
), xenbus_strstate(state
));
234 xendev
->be_state
= state
;
238 /* ------------------------------------------------------------- */
240 struct XenDevice
*xen_be_find_xendev(const char *type
, int dom
, int dev
)
242 struct XenDevice
*xendev
;
244 QTAILQ_FOREACH(xendev
, &xendevs
, next
) {
245 if (xendev
->dom
!= dom
) {
248 if (xendev
->dev
!= dev
) {
251 if (strcmp(xendev
->type
, type
) != 0) {
260 * get xen backend device, allocate a new one if it doesn't exist.
262 static struct XenDevice
*xen_be_get_xendev(const char *type
, int dom
, int dev
,
263 struct XenDevOps
*ops
)
265 struct XenDevice
*xendev
;
267 xendev
= xen_be_find_xendev(type
, dom
, dev
);
272 /* init new xendev */
273 xendev
= g_malloc0(ops
->size
);
279 snprintf(xendev
->be
, sizeof(xendev
->be
), "backend/%s/%d/%d",
280 xendev
->type
, xendev
->dom
, xendev
->dev
);
281 snprintf(xendev
->name
, sizeof(xendev
->name
), "%s-%d",
282 xendev
->type
, xendev
->dev
);
284 xendev
->debug
= debug
;
285 xendev
->local_port
= -1;
287 xendev
->evtchndev
= xenevtchn_open(NULL
, 0);
288 if (xendev
->evtchndev
== NULL
) {
289 xen_be_printf(NULL
, 0, "can't open evtchn device\n");
293 fcntl(xenevtchn_fd(xendev
->evtchndev
), F_SETFD
, FD_CLOEXEC
);
295 if (ops
->flags
& DEVOPS_FLAG_NEED_GNTDEV
) {
296 xendev
->gnttabdev
= xengnttab_open(NULL
, 0);
297 if (xendev
->gnttabdev
== NULL
) {
298 xen_be_printf(NULL
, 0, "can't open gnttab device\n");
299 xenevtchn_close(xendev
->evtchndev
);
304 xendev
->gnttabdev
= NULL
;
307 QTAILQ_INSERT_TAIL(&xendevs
, xendev
, next
);
309 if (xendev
->ops
->alloc
) {
310 xendev
->ops
->alloc(xendev
);
317 * release xen backend device.
319 static struct XenDevice
*xen_be_del_xendev(int dom
, int dev
)
321 struct XenDevice
*xendev
, *xnext
;
324 * This is pretty much like QTAILQ_FOREACH(xendev, &xendevs, next) but
325 * we save the next pointer in xnext because we might free xendev.
327 xnext
= xendevs
.tqh_first
;
330 xnext
= xendev
->next
.tqe_next
;
332 if (xendev
->dom
!= dom
) {
335 if (xendev
->dev
!= dev
&& dev
!= -1) {
339 if (xendev
->ops
->free
) {
340 xendev
->ops
->free(xendev
);
344 char token
[XEN_BUFSIZE
];
345 snprintf(token
, sizeof(token
), "fe:%p", xendev
);
346 xs_unwatch(xenstore
, xendev
->fe
, token
);
350 if (xendev
->evtchndev
!= NULL
) {
351 xenevtchn_close(xendev
->evtchndev
);
353 if (xendev
->gnttabdev
!= NULL
) {
354 xengnttab_close(xendev
->gnttabdev
);
357 QTAILQ_REMOVE(&xendevs
, xendev
, next
);
364 * Sync internal data structures on xenstore updates.
365 * Node specifies the changed field. node = NULL means
366 * update all fields (used for initialization).
368 static void xen_be_backend_changed(struct XenDevice
*xendev
, const char *node
)
370 if (node
== NULL
|| strcmp(node
, "online") == 0) {
371 if (xenstore_read_be_int(xendev
, "online", &xendev
->online
) == -1) {
377 xen_be_printf(xendev
, 2, "backend update: %s\n", node
);
378 if (xendev
->ops
->backend_changed
) {
379 xendev
->ops
->backend_changed(xendev
, node
);
384 static void xen_be_frontend_changed(struct XenDevice
*xendev
, const char *node
)
388 if (node
== NULL
|| strcmp(node
, "state") == 0) {
389 if (xenstore_read_fe_int(xendev
, "state", &fe_state
) == -1) {
390 fe_state
= XenbusStateUnknown
;
392 if (xendev
->fe_state
!= fe_state
) {
393 xen_be_printf(xendev
, 1, "frontend state: %s -> %s\n",
394 xenbus_strstate(xendev
->fe_state
),
395 xenbus_strstate(fe_state
));
397 xendev
->fe_state
= fe_state
;
399 if (node
== NULL
|| strcmp(node
, "protocol") == 0) {
400 g_free(xendev
->protocol
);
401 xendev
->protocol
= xenstore_read_fe_str(xendev
, "protocol");
402 if (xendev
->protocol
) {
403 xen_be_printf(xendev
, 1, "frontend protocol: %s\n", xendev
->protocol
);
408 xen_be_printf(xendev
, 2, "frontend update: %s\n", node
);
409 if (xendev
->ops
->frontend_changed
) {
410 xendev
->ops
->frontend_changed(xendev
, node
);
415 /* ------------------------------------------------------------- */
416 /* Check for possible state transitions and perform them. */
419 * Initial xendev setup. Read frontend path, register watch for it.
420 * Should succeed once xend finished setting up the backend device.
422 * Also sets initial state (-> Initializing) when done. Which
423 * only affects the xendev->be_state variable as xenbus should
424 * already be put into that state by xend.
426 static int xen_be_try_setup(struct XenDevice
*xendev
)
428 char token
[XEN_BUFSIZE
];
431 if (xenstore_read_be_int(xendev
, "state", &be_state
) == -1) {
432 xen_be_printf(xendev
, 0, "reading backend state failed\n");
436 if (be_state
!= XenbusStateInitialising
) {
437 xen_be_printf(xendev
, 0, "initial backend state is wrong (%s)\n",
438 xenbus_strstate(be_state
));
442 xendev
->fe
= xenstore_read_be_str(xendev
, "frontend");
443 if (xendev
->fe
== NULL
) {
444 xen_be_printf(xendev
, 0, "reading frontend path failed\n");
448 /* setup frontend watch */
449 snprintf(token
, sizeof(token
), "fe:%p", xendev
);
450 if (!xs_watch(xenstore
, xendev
->fe
, token
)) {
451 xen_be_printf(xendev
, 0, "watching frontend path (%s) failed\n",
455 xen_be_set_state(xendev
, XenbusStateInitialising
);
457 xen_be_backend_changed(xendev
, NULL
);
458 xen_be_frontend_changed(xendev
, NULL
);
463 * Try initialize xendev. Prepare everything the backend can do
464 * without synchronizing with the frontend. Fakes hotplug-status. No
465 * hotplug involved here because this is about userspace drivers, thus
466 * there are kernel backend devices which could invoke hotplug.
468 * Goes to InitWait on success.
470 static int xen_be_try_init(struct XenDevice
*xendev
)
474 if (!xendev
->online
) {
475 xen_be_printf(xendev
, 1, "not online\n");
479 if (xendev
->ops
->init
) {
480 rc
= xendev
->ops
->init(xendev
);
483 xen_be_printf(xendev
, 1, "init() failed\n");
487 xenstore_write_be_str(xendev
, "hotplug-status", "connected");
488 xen_be_set_state(xendev
, XenbusStateInitWait
);
493 * Try to initialise xendev. Depends on the frontend being ready
494 * for it (shared ring and evtchn info in xenstore, state being
495 * Initialised or Connected).
497 * Goes to Connected on success.
499 static int xen_be_try_initialise(struct XenDevice
*xendev
)
503 if (xendev
->fe_state
!= XenbusStateInitialised
&&
504 xendev
->fe_state
!= XenbusStateConnected
) {
505 if (xendev
->ops
->flags
& DEVOPS_FLAG_IGNORE_STATE
) {
506 xen_be_printf(xendev
, 2, "frontend not ready, ignoring\n");
508 xen_be_printf(xendev
, 2, "frontend not ready (yet)\n");
513 if (xendev
->ops
->initialise
) {
514 rc
= xendev
->ops
->initialise(xendev
);
517 xen_be_printf(xendev
, 0, "initialise() failed\n");
521 xen_be_set_state(xendev
, XenbusStateConnected
);
526 * Try to let xendev know that it is connected. Depends on the
527 * frontend being Connected. Note that this may be called more
528 * than once since the backend state is not modified.
530 static void xen_be_try_connected(struct XenDevice
*xendev
)
532 if (!xendev
->ops
->connected
) {
536 if (xendev
->fe_state
!= XenbusStateConnected
) {
537 if (xendev
->ops
->flags
& DEVOPS_FLAG_IGNORE_STATE
) {
538 xen_be_printf(xendev
, 2, "frontend not ready, ignoring\n");
540 xen_be_printf(xendev
, 2, "frontend not ready (yet)\n");
545 xendev
->ops
->connected(xendev
);
549 * Teardown connection.
551 * Goes to Closed when done.
553 static void xen_be_disconnect(struct XenDevice
*xendev
, enum xenbus_state state
)
555 if (xendev
->be_state
!= XenbusStateClosing
&&
556 xendev
->be_state
!= XenbusStateClosed
&&
557 xendev
->ops
->disconnect
) {
558 xendev
->ops
->disconnect(xendev
);
560 if (xendev
->be_state
!= state
) {
561 xen_be_set_state(xendev
, state
);
566 * Try to reset xendev, for reconnection by another frontend instance.
568 static int xen_be_try_reset(struct XenDevice
*xendev
)
570 if (xendev
->fe_state
!= XenbusStateInitialising
) {
574 xen_be_printf(xendev
, 1, "device reset (for re-connect)\n");
575 xen_be_set_state(xendev
, XenbusStateInitialising
);
580 * state change dispatcher function
582 void xen_be_check_state(struct XenDevice
*xendev
)
586 /* frontend may request shutdown from almost anywhere */
587 if (xendev
->fe_state
== XenbusStateClosing
||
588 xendev
->fe_state
== XenbusStateClosed
) {
589 xen_be_disconnect(xendev
, xendev
->fe_state
);
593 /* check for possible backend state transitions */
595 switch (xendev
->be_state
) {
596 case XenbusStateUnknown
:
597 rc
= xen_be_try_setup(xendev
);
599 case XenbusStateInitialising
:
600 rc
= xen_be_try_init(xendev
);
602 case XenbusStateInitWait
:
603 rc
= xen_be_try_initialise(xendev
);
605 case XenbusStateConnected
:
606 /* xendev->be_state doesn't change */
607 xen_be_try_connected(xendev
);
610 case XenbusStateClosed
:
611 rc
= xen_be_try_reset(xendev
);
622 /* ------------------------------------------------------------- */
624 static int xenstore_scan(const char *type
, int dom
, struct XenDevOps
*ops
)
626 struct XenDevice
*xendev
;
627 char path
[XEN_BUFSIZE
], token
[XEN_BUFSIZE
];
629 unsigned int cdev
, j
;
632 snprintf(token
, sizeof(token
), "be:%p:%d:%p", type
, dom
, ops
);
633 snprintf(path
, sizeof(path
), "backend/%s/%d", type
, dom
);
634 if (!xs_watch(xenstore
, path
, token
)) {
635 xen_be_printf(NULL
, 0, "xen be: watching backend path (%s) failed\n", path
);
639 /* look for backends */
640 dev
= xs_directory(xenstore
, 0, path
, &cdev
);
644 for (j
= 0; j
< cdev
; j
++) {
645 xendev
= xen_be_get_xendev(type
, dom
, atoi(dev
[j
]), ops
);
646 if (xendev
== NULL
) {
649 xen_be_check_state(xendev
);
655 static void xenstore_update_be(char *watch
, char *type
, int dom
,
656 struct XenDevOps
*ops
)
658 struct XenDevice
*xendev
;
659 char path
[XEN_BUFSIZE
], *bepath
;
660 unsigned int len
, dev
;
662 len
= snprintf(path
, sizeof(path
), "backend/%s/%d", type
, dom
);
663 if (strncmp(path
, watch
, len
) != 0) {
666 if (sscanf(watch
+len
, "/%u/%255s", &dev
, path
) != 2) {
668 if (sscanf(watch
+len
, "/%u", &dev
) != 1) {
676 xendev
= xen_be_get_xendev(type
, dom
, dev
, ops
);
677 if (xendev
!= NULL
) {
678 bepath
= xs_read(xenstore
, 0, xendev
->be
, &len
);
679 if (bepath
== NULL
) {
680 xen_be_del_xendev(dom
, dev
);
683 xen_be_backend_changed(xendev
, path
);
684 xen_be_check_state(xendev
);
689 static void xenstore_update_fe(char *watch
, struct XenDevice
*xendev
)
694 len
= strlen(xendev
->fe
);
695 if (strncmp(xendev
->fe
, watch
, len
) != 0) {
698 if (watch
[len
] != '/') {
701 node
= watch
+ len
+ 1;
703 xen_be_frontend_changed(xendev
, node
);
704 xen_be_check_state(xendev
);
707 static void xenstore_update(void *unused
)
710 intptr_t type
, ops
, ptr
;
711 unsigned int dom
, count
;
713 vec
= xs_read_watch(xenstore
, &count
);
718 if (sscanf(vec
[XS_WATCH_TOKEN
], "be:%" PRIxPTR
":%d:%" PRIxPTR
,
719 &type
, &dom
, &ops
) == 3) {
720 xenstore_update_be(vec
[XS_WATCH_PATH
], (void*)type
, dom
, (void*)ops
);
722 if (sscanf(vec
[XS_WATCH_TOKEN
], "fe:%" PRIxPTR
, &ptr
) == 1) {
723 xenstore_update_fe(vec
[XS_WATCH_PATH
], (void*)ptr
);
730 static void xen_be_evtchn_event(void *opaque
)
732 struct XenDevice
*xendev
= opaque
;
735 port
= xenevtchn_pending(xendev
->evtchndev
);
736 if (port
!= xendev
->local_port
) {
737 xen_be_printf(xendev
, 0,
738 "xenevtchn_pending returned %d (expected %d)\n",
739 port
, xendev
->local_port
);
742 xenevtchn_unmask(xendev
->evtchndev
, port
);
744 if (xendev
->ops
->event
) {
745 xendev
->ops
->event(xendev
);
749 /* -------------------------------------------------------------------- */
751 int xen_be_init(void)
753 xenstore
= xs_daemon_open();
755 xen_be_printf(NULL
, 0, "can't connect to xenstored\n");
759 qemu_set_fd_handler(xs_fileno(xenstore
), xenstore_update
, NULL
, NULL
);
761 if (xen_xc
== NULL
|| xen_fmem
== NULL
) {
762 /* Check if xen_init() have been called */
768 qemu_set_fd_handler(xs_fileno(xenstore
), NULL
, NULL
, NULL
);
769 xs_daemon_close(xenstore
);
775 int xen_be_register(const char *type
, struct XenDevOps
*ops
)
780 if (ops
->backend_register
) {
781 rc
= ops
->backend_register();
787 snprintf(path
, sizeof(path
), "device-model/%u/backends/%s", xen_domid
,
789 xenstore_mkdir(path
, XS_PERM_NONE
);
791 return xenstore_scan(type
, xen_domid
, ops
);
794 int xen_be_bind_evtchn(struct XenDevice
*xendev
)
796 if (xendev
->local_port
!= -1) {
799 xendev
->local_port
= xenevtchn_bind_interdomain
800 (xendev
->evtchndev
, xendev
->dom
, xendev
->remote_port
);
801 if (xendev
->local_port
== -1) {
802 xen_be_printf(xendev
, 0, "xenevtchn_bind_interdomain failed\n");
805 xen_be_printf(xendev
, 2, "bind evtchn port %d\n", xendev
->local_port
);
806 qemu_set_fd_handler(xenevtchn_fd(xendev
->evtchndev
),
807 xen_be_evtchn_event
, NULL
, xendev
);
811 void xen_be_unbind_evtchn(struct XenDevice
*xendev
)
813 if (xendev
->local_port
== -1) {
816 qemu_set_fd_handler(xenevtchn_fd(xendev
->evtchndev
), NULL
, NULL
, NULL
);
817 xenevtchn_unbind(xendev
->evtchndev
, xendev
->local_port
);
818 xen_be_printf(xendev
, 2, "unbind evtchn port %d\n", xendev
->local_port
);
819 xendev
->local_port
= -1;
822 int xen_be_send_notify(struct XenDevice
*xendev
)
824 return xenevtchn_notify(xendev
->evtchndev
, xendev
->local_port
);
829 * 0 == errors (stderr + logfile).
830 * 1 == informative debug messages (logfile only).
831 * 2 == noisy debug messages (logfile only).
832 * 3 == will flood your log (logfile only).
834 void xen_be_printf(struct XenDevice
*xendev
, int msg_level
, const char *fmt
, ...)
839 if (msg_level
> xendev
->debug
) {
842 qemu_log("xen be: %s: ", xendev
->name
);
843 if (msg_level
== 0) {
844 fprintf(stderr
, "xen be: %s: ", xendev
->name
);
847 if (msg_level
> debug
) {
850 qemu_log("xen be core: ");
851 if (msg_level
== 0) {
852 fprintf(stderr
, "xen be core: ");
856 qemu_log_vprintf(fmt
, args
);
858 if (msg_level
== 0) {
860 vfprintf(stderr
, fmt
, args
);