/* $NetBSD: xenbus_probe.c,v 1.62 2025/02/06 15:51:58 bouyer Exp $ */
/******************************************************************************
 * Talks to Xen Store to figure out what devices we have.
 *
 * Copyright (C) 2005 Rusty Russell, IBM Corporation
 * Copyright (C) 2005 Mike Wray, Hewlett-Packard
 * Copyright (C) 2005 XenSource Ltd
 * 
 * This file may be distributed separately from the Linux kernel, or
 * incorporated into other software packages, subject to the following license:
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this source file (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use, copy, modify,
 * merge, publish, distribute, sublicense, and/or sell copies of the Software,
 * and to permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 * IN THE SOFTWARE.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: xenbus_probe.c,v 1.62 2025/02/06 15:51:58 bouyer Exp $");

#if 0
#define DPRINTK(fmt, args...) \
    printf("xenbus_probe (%s:%d) " fmt ".\n", __func__, __LINE__, ##args)
#else
#define DPRINTK(fmt, args...) ((void)0)
#endif

#include <sys/types.h>
#include <sys/null.h>
#include <sys/errno.h>
#include <sys/kmem.h>
#include <sys/systm.h>
#include <sys/param.h>
#include <sys/kthread.h>
#include <sys/mutex.h>
#include <uvm/uvm.h>

#include <xen/xen.h>    /* for xendomain_is_dom0() */
#include <xen/hypervisor.h>
#include <xen/xenbus.h>
#include <xen/evtchn.h>
#include <xen/shutdown_xenbus.h>

#include "xenbus_comms.h"

#include "kernfs.h"

static int  xenbus_match(device_t, cfdata_t, void *);
static void xenbus_attach(device_t, device_t, void *);
static int  xenbus_print(void *, const char *);

/* power management, for save/restore */
static bool xenbus_suspend(device_t, const pmf_qual_t *);
static bool xenbus_resume(device_t, const pmf_qual_t *);

/* routines gathering device information from XenStore */
static int  read_otherend_details(struct xenbus_device *,
                const char *, const char *);
static int  read_backend_details (struct xenbus_device *);
static int  read_frontend_details(struct xenbus_device *);
static void free_otherend_details(struct xenbus_device *);

static int  watch_otherend     (struct xenbus_device *);
static void free_otherend_watch(struct xenbus_device *);

static void xenbus_probe_init(void *);

static struct xenbus_device *xenbus_lookup_device_path(const char *);

CFATTACH_DECL_NEW(xenbus, 0, xenbus_match, xenbus_attach,
    NULL, NULL);

device_t xenbus_dev;
bus_dma_tag_t xenbus_dmat;

SLIST_HEAD(, xenbus_device) xenbus_device_list;
SLIST_HEAD(, xenbus_backend_driver) xenbus_backend_driver_list =
        SLIST_HEAD_INITIALIZER(xenbus_backend_driver);

int
xenbus_match(device_t parent, cfdata_t match, void *aux)
{
        struct xenbus_attach_args *xa = (struct xenbus_attach_args *)aux;

        if (strcmp(xa->xa_device, "xenbus") == 0)
                return 1;
        return 0;
}

static void
xenbus_attach(device_t parent, device_t self, void *aux)
{
        struct xenbus_attach_args *xa = (struct xenbus_attach_args *)aux;
        int err;

        aprint_normal(": Xen Virtual Bus Interface\n");
        xenbus_dev = self;
        xenbus_dmat = xa->xa_dmat;
        config_pending_incr(self);

        err = kthread_create(PRI_NONE, KTHREAD_MPSAFE, NULL,
            xenbus_probe_init, NULL, NULL, "xenbus_probe");
        if (err)
                aprint_error_dev(xenbus_dev,
                                "kthread_create(xenbus_probe): %d\n", err);

        if (!pmf_device_register(self, xenbus_suspend, xenbus_resume))
                aprint_error_dev(self, "couldn't establish power handler\n");
}

static bool
xenbus_suspend(device_t dev, const pmf_qual_t *qual)
{
        xs_suspend();
        xb_suspend_comms(dev);

        return true;
}

static bool
xenbus_resume(device_t dev, const pmf_qual_t *qual)
{
        xb_resume_comms(dev);
        xs_resume();

        return true;
}

/*
 * Suspend a xenbus device
 */
bool
xenbus_device_suspend(struct xenbus_device *dev) {

        free_otherend_details(dev);
        return true;
}

/*
 * Resume a xenbus device
 */
bool
xenbus_device_resume(struct xenbus_device *dev) {

        if (dev->xbusd_type == XENBUS_FRONTEND_DEVICE) {
                read_backend_details(dev);
        }

        return true;
}

void
xenbus_backend_register(struct xenbus_backend_driver *xbakd)
{
        SLIST_INSERT_HEAD(&xenbus_backend_driver_list, xbakd, xbakd_entries);
}

static int
read_otherend_details(struct xenbus_device *xendev,
                                 const char *id_node, const char *path_node)
{
        int err;
        unsigned long id;

        err = xenbus_read_ul(NULL, xendev->xbusd_path, id_node, &id, 10);
        if (err) {
                printf("reading other end details %s from %s\n",
                    id_node, xendev->xbusd_path);
                xenbus_dev_fatal(xendev, err,
                                 "reading other end details %s from %s",
                                 id_node, xendev->xbusd_path);
                return err;
        }
        xendev->xbusd_otherend_id = (int)id;

        err = xenbus_read(NULL, xendev->xbusd_path, path_node,
            xendev->xbusd_otherend, sizeof(xendev->xbusd_otherend));
        if (err) {
                printf("reading other end details %s from %s (%d)\n",
                    path_node, xendev->xbusd_path, err);
                xenbus_dev_fatal(xendev, err,
                                 "reading other end details %s from %s",
                                 path_node, xendev->xbusd_path);
                return err;
        }
        DPRINTK("read_otherend_details: read %s/%s returned %s\n",
            xendev->xbusd_path, path_node, xendev->xbusd_otherend);

        if (strlen(xendev->xbusd_otherend) == 0 ||
            !xenbus_exists(NULL, xendev->xbusd_otherend, "")) {
                printf("missing other end from %s\n", xendev->xbusd_path);
                xenbus_dev_fatal(xendev, -ENOENT, "missing other end from %s",
                                 xendev->xbusd_path);
                free_otherend_details(xendev);
                return ENOENT;
        }

        return 0;
}

static int
read_backend_details(struct xenbus_device *xendev)
{
        return read_otherend_details(xendev, "backend-id", "backend");
}


static int
read_frontend_details(struct xenbus_device *xendev)
{
        return read_otherend_details(xendev, "frontend-id", "frontend");
}

static void
free_otherend_details(struct xenbus_device *dev)
{
        /* Nothing to free */
        dev->xbusd_otherend[0] = '\0';
}

static void
free_otherend_watch(struct xenbus_device *dev)
{
        if (dev->xbusd_otherend_watch.node)
                xenbus_unwatch_path(&dev->xbusd_otherend_watch);
}

static void
otherend_changed(struct xenbus_watch *watch,
                             const char **vec, unsigned int len)
{
        struct xenbus_device *xdev = watch->xbw_dev;
        XenbusState state;

        /* Protect us against watches firing on old details when the otherend
           details change, say immediately after a resume. */
        if (strncmp(xdev->xbusd_otherend, vec[XS_WATCH_PATH],
                    strlen(xdev->xbusd_otherend))) {
                DPRINTK("Ignoring watch at %s", vec[XS_WATCH_PATH]);
                return;
        }

        state = xenbus_read_driver_state(xdev->xbusd_otherend);

        DPRINTK("state is %d, %s, %s",
                state, xdev->xbusd_otherend_watch.node, vec[XS_WATCH_PATH]);
        if (state == XenbusStateClosed) {
                int error;
                if (xdev->xbusd_type == XENBUS_BACKEND_DEVICE) {
                        error = xdev->xbusd_u.b.b_detach(
                            xdev->xbusd_u.b.b_cookie);
                        if (error) {
                                printf("could not detach %s: %d\n",
                                    xdev->xbusd_path, error);
                                return;
                        }
                } else {
                        error = config_detach(xdev->xbusd_u.f.f_dev,
                            DETACH_FORCE);
                        if (error) {
                                printf("could not detach %s: %d\n",
                                    device_xname(xdev->xbusd_u.f.f_dev), error);
                                return;
                        }
                }
                xenbus_free_device(xdev);
                return;
        }
        if (xdev->xbusd_otherend_changed)
                xdev->xbusd_otherend_changed(
                    (xdev->xbusd_type == XENBUS_BACKEND_DEVICE) ?
                    xdev->xbusd_u.b.b_cookie : xdev->xbusd_u.f.f_dev, state);
}

static int
watch_otherend(struct xenbus_device *dev)
{
        free_otherend_watch(dev);

        return xenbus_watch_path2(dev, dev->xbusd_otherend, "state",
                                  &dev->xbusd_otherend_watch,
                                  otherend_changed);
}

static struct xenbus_device *
xenbus_lookup_device_path(const char *path)
{
        struct xenbus_device *xbusd;

        SLIST_FOREACH(xbusd, &xenbus_device_list, xbusd_entries) {
                if (strcmp(xbusd->xbusd_path, path) == 0)
                        return xbusd;
        }
        return NULL;
}

static int
xenbus_probe_device_type(const char *path, const char *type,
    int (*create)(struct xenbus_device *))
{
        int err, i, pos, msize;
        int *lookup = NULL;
        size_t lookup_sz = 0;
        unsigned long state;
        char **dir;
        unsigned int orig_dir_n = 0, dir_n;
        struct xenbus_device *xbusd;
        struct xenbusdev_attach_args xa;
        char *ep;

        DPRINTK("probe %s type %s", path, type);
        err = xenbus_directory(NULL, path, "", &orig_dir_n, &dir);
        DPRINTK("directory err %d dir_n %d", err, orig_dir_n);
        if (err)
                return err;
        dir_n = orig_dir_n;

        /* Only sort frontend devices i.e. create == NULL*/
        if (dir_n > 1 && create == NULL) {
                int minp;
                unsigned long minv;
                unsigned long *id;
                size_t id_sz;

                lookup_sz = sizeof(int) * dir_n;
                lookup = kmem_zalloc(lookup_sz, KM_SLEEP);

                id_sz = sizeof(unsigned long) * dir_n;
                id = kmem_zalloc(id_sz, KM_SLEEP);

                /* Convert string values to numeric; skip invalid */
                for (i = 0; i < dir_n; i++) {
                        /*
                         * Add one to differentiate numerical zero from invalid
                         * string. Has no effect on sort order.
                         */
                        id[i] = strtoul(dir[i], &ep, 10) + 1;
                        if (dir[i][0] == '\0' || *ep != '\0')
                                id[i] = 0;
                }
                
                /* Build lookup table in ascending order */
                for (pos = 0; pos < dir_n; ) {
                        minv = UINT32_MAX;
                        minp = -1;
                        for (i = 0; i < dir_n; i++) {
                                if (id[i] < minv && id[i] > 0) {
                                        minv = id[i];
                                        minp = i;
                                }
                        }
                        if (minp >= 0) {
                                lookup[pos++] = minp;
                                id[minp] = 0;
                        }
                        else
                                break;
                }

                kmem_free(id, id_sz);

                /* Adjust in case we had to skip non-numeric entries */
                dir_n = pos;
        }

        for (pos = 0; pos < dir_n; pos++) {
                err = 0;
                if (lookup)
                        i = lookup[pos];
                else
                        i = pos;
                /*
                 * add size of path to size of xenbus_device. xenbus_device
                 * already has room for one char in xbusd_path.
                 */
                msize = sizeof(*xbusd) + strlen(path) + strlen(dir[i]) + 2;
                xbusd = kmem_zalloc(msize, KM_SLEEP);
                xbusd->xbusd_sz = msize;
                xbusd->xbusd_dmat = xenbus_dmat;

                snprintf(__UNCONST(xbusd->xbusd_path),
                    msize - sizeof(*xbusd) + 1, "%s/%s", path, dir[i]);
                if (xenbus_lookup_device_path(xbusd->xbusd_path) != NULL) {
                        /* device already registered */
                        kmem_free(xbusd, xbusd->xbusd_sz);
                        continue;
                }
                err = xenbus_read_ul(NULL, xbusd->xbusd_path, "state",
                    &state, 10);
                if (err) {
                        aprint_error_dev(xenbus_dev, "can't get state "
                            "for %s (%d)\n", xbusd->xbusd_path, err);
                        kmem_free(xbusd, xbusd->xbusd_sz);
                        err = 0;
                        continue;
                }
                if (state != XenbusStateInitialising) {
                        /* device is not new */
                        kmem_free(xbusd, xbusd->xbusd_sz);
                        continue;
                }

                xbusd->xbusd_otherend_watch.xbw_dev = xbusd;
                DPRINTK("xenbus_probe_device_type probe %s\n",
                    xbusd->xbusd_path);
                if (create != NULL) {
                        xbusd->xbusd_type = XENBUS_BACKEND_DEVICE;
                        err = read_frontend_details(xbusd);
                        if (err != 0) {
                                aprint_error_dev(xenbus_dev,
                                    "can't get frontend details for %s (%d)\n",
                                    xbusd->xbusd_path, err);
                                break;
                        }
                        if (create(xbusd)) {
                                kmem_free(xbusd, xbusd->xbusd_sz);
                                continue;
                        }
                } else {
                        xbusd->xbusd_type = XENBUS_FRONTEND_DEVICE;
                        xa.xa_xbusd = xbusd;
                        xa.xa_type = type;
                        xa.xa_id = strtoul(dir[i], &ep, 0);
                        if (dir[i][0] == '\0' || *ep != '\0') {
                                aprint_error_dev(xenbus_dev,
                                    "device type %s: id %s is not a number\n",
                                    type, dir[i]);
                                err = EFTYPE;
                                kmem_free(xbusd, xbusd->xbusd_sz);
                                break;
                        }
                        if (strcmp(xa.xa_type, "vbd") == 0) {
                                char dtype[10];
                                if (xenbus_read(NULL, xbusd->xbusd_path,
                                    "device-type", dtype, sizeof(dtype)) !=0) {
                                        aprint_error_dev(xenbus_dev,
                                            "%s: can't read device-type\n",
                                            xbusd->xbusd_path);
                                        kmem_free(xbusd, xbusd->xbusd_sz);
                                        break;
                                }
                                if (vm_guest == VM_GUEST_XENPVHVM &&
                                    strcmp(dtype, "cdrom") == 0) {
                                        aprint_verbose_dev(xenbus_dev,
                                            "ignoring %s type cdrom\n",
                                            xbusd->xbusd_path);
                                        kmem_free(xbusd, xbusd->xbusd_sz);
                                        continue;
                                }
                        }
                        err = read_backend_details(xbusd);
                        if (err != 0) {
                                aprint_error_dev(xenbus_dev,
                                    "can't get backend details for %s (%d)\n",
                                    xbusd->xbusd_path, err);
                                kmem_free(xbusd, xbusd->xbusd_sz);
                                break;
                        }

                        KERNEL_LOCK(1, curlwp);
                        xbusd->xbusd_u.f.f_dev = config_found(xenbus_dev,
                            &xa, xenbus_print, CFARGS_NONE);
                        KERNEL_UNLOCK_ONE(curlwp);
                        if (xbusd->xbusd_u.f.f_dev == NULL) {
                                kmem_free(xbusd, xbusd->xbusd_sz);
                                continue;
                        }
                }
                SLIST_INSERT_HEAD(&xenbus_device_list,
                    xbusd, xbusd_entries);
                watch_otherend(xbusd);
        }
        xenbus_directory_free(orig_dir_n, dir);
        if (lookup)
                kmem_free(lookup, lookup_sz);
        
        return err;
}

static int
xenbus_print(void *aux, const char *pnp)
{
        struct xenbusdev_attach_args *xa = aux;

        if (pnp) {
                if (strcmp(xa->xa_type, "vbd") == 0)
                        aprint_normal("xbd");
                else if (strcmp(xa->xa_type, "vif") == 0)
                        aprint_normal("xennet");
                else if (strcmp(xa->xa_type, "balloon") == 0)
                        aprint_normal("balloon");
                else
                        aprint_normal("unknown type %s", xa->xa_type);
                aprint_normal(" at %s", pnp);
        }
        aprint_normal(" id %d", xa->xa_id);
        return(UNCONF);
}

static int
xenbus_probe_frontends(void)
{
        int err;
        char **dir;
        unsigned int i, dir_n;
        char path[30];

        DPRINTK("probe device");
        err = xenbus_directory(NULL, "device", "", &dir_n, &dir);
        DPRINTK("directory err %d dir_n %d", err, dir_n);
        if (err)
                return err;

        for (i = 0; i < dir_n; i++) {
                /*
                 * console is configured through xen_start_info when
                 * xencons is attaching to hypervisor, so avoid console
                 * probing when configuring xenbus devices
                 */
                if (strcmp(dir[i], "console") == 0)
                        continue;

                snprintf(path, sizeof(path), "device/%s", dir[i]);
                err = xenbus_probe_device_type(path, dir[i], NULL);
                if (err)
                        break;
        }
        xenbus_directory_free(dir_n, dir);
        return err;
}

static int
xenbus_probe_backends(void)
{
        int err;
        char **dirt, **dirid;
        unsigned int type, id, dirt_n, dirid_n;
        char path[30];
        struct xenbus_backend_driver *xbakd;

        DPRINTK("probe backend");
        err = xenbus_directory(NULL, "backend", "", &dirt_n, &dirt);
        DPRINTK("directory err %d dirt_n %d", err, dirt_n);
        if (err)
                return err;

        for (type = 0; type < dirt_n; type++) {
                SLIST_FOREACH(xbakd, &xenbus_backend_driver_list,
                    xbakd_entries) {
                        if (strcmp(dirt[type], xbakd->xbakd_type) == 0)
                                break;
                }
                if (xbakd == NULL)
                        continue;
                err = xenbus_directory(NULL, "backend", dirt[type],
                    &dirid_n, &dirid);
                DPRINTK("directory backend/%s err %d dirid_n %d",
                    dirt[type], err, dirid_n);
                if (err)
                        goto out;

                for (id = 0; id < dirid_n; id++) {
                        snprintf(path, sizeof(path), "backend/%s/%s",
                            dirt[type], dirid[id]);
                        err = xenbus_probe_device_type(path, dirt[type],
                            xbakd->xbakd_create);
                        if (err)
                                break;
                }
                xenbus_directory_free(dirid_n, dirid);
        }

out:
        xenbus_directory_free(dirt_n, dirt);
        return err;
}

int
xenbus_free_device(struct xenbus_device *xbusd)
{
        KASSERT(xenbus_lookup_device_path(xbusd->xbusd_path) == xbusd);
        SLIST_REMOVE(&xenbus_device_list, xbusd, xenbus_device, xbusd_entries);
        free_otherend_watch(xbusd);
        free_otherend_details(xbusd);
        xenbus_switch_state(xbusd, NULL, XenbusStateClosed);
        kmem_free(xbusd, xbusd->xbusd_sz);
        return 0;
}

static void
frontend_changed(struct xenbus_watch *watch,
                             const char **vec, unsigned int len)
{
        DPRINTK("frontend_changed %s\n", vec[XS_WATCH_PATH]);
        xenbus_probe_frontends();
}

static void
backend_changed(struct xenbus_watch *watch,
                            const char **vec, unsigned int len)
{
        DPRINTK("backend_changed %s\n", vec[XS_WATCH_PATH]);
        xenbus_probe_backends();
}


/* We watch for devices appearing and vanishing. */
static struct xenbus_watch fe_watch;

static struct xenbus_watch be_watch;

/* A flag to determine if xenstored is 'ready' (i.e. has started) */
int xenstored_ready = 0;
static kmutex_t xenstored_lock;
static kcondvar_t xenstored_cv;

void
xenbus_probe(void *unused)
{
        struct xenbusdev_attach_args balloon_xa = {
                .xa_id = 0,
                .xa_type = "balloon"
        };

        KASSERT((xenstored_ready > 0));

        /* Enumerate devices in xenstore. */
        xenbus_probe_frontends();
        xenbus_probe_backends();

        /* Watch for changes. */
        fe_watch.node_sz = strlen("device") + 1;
        fe_watch.node = kmem_alloc(fe_watch.node_sz, KM_SLEEP);
        strcpy(fe_watch.node, "device");
        fe_watch.xbw_callback = frontend_changed;
        register_xenbus_watch(&fe_watch);

        be_watch.node_sz = strlen("backend") + 1;
        be_watch.node = kmem_alloc(be_watch.node_sz, KM_SLEEP);
        strcpy(be_watch.node, "backend");
        be_watch.xbw_callback = backend_changed;
        register_xenbus_watch(&be_watch);

        /* attach balloon. */
        KERNEL_LOCK(1, curlwp);
        config_found(xenbus_dev, &balloon_xa, xenbus_print,
            CFARGS_NONE);
        KERNEL_UNLOCK_ONE(curlwp);

        shutdown_xenbus_setup();

        /* Notify others that xenstore is up */
        //notifier_call_chain(&xenstore_chain, 0, NULL);
}

void
xb_xenstored_make_ready(void)
{
        mutex_enter(&xenstored_lock);
        xenstored_ready = 1;
        cv_broadcast(&xenstored_cv);
        mutex_exit(&xenstored_lock);
}

static void
xenbus_probe_init(void *unused)
{
        int err = 0;
        bool dom0;
        vaddr_t page = 0;

        DPRINTK("");

        SLIST_INIT(&xenbus_device_list);
        mutex_init(&xenstored_lock, MUTEX_DEFAULT, IPL_TTY);
        cv_init(&xenstored_cv, "xsready");

        /*
        ** Domain0 doesn't have a store_evtchn or store_mfn yet.
        */
        dom0 = xendomain_is_dom0();
        if (dom0) {
#if defined(DOM0OPS)
                paddr_t ma;
                evtchn_op_t op = { .cmd = 0 };

                /* Allocate page. */
                page = uvm_km_alloc(kernel_map, PAGE_SIZE, 0,
                    UVM_KMF_ZERO | UVM_KMF_WIRED);
                if (!page) 
                        panic("can't get xenstore page");

                (void)pmap_extract_ma(pmap_kernel(), page, &ma);
                xen_start_info.store_mfn = ma >> PAGE_SHIFT;
                xenstore_interface = (void *)page;
                
                /* Next allocate a local port which xenstored can bind to */
                op.cmd = EVTCHNOP_alloc_unbound;
                op.u.alloc_unbound.dom        = DOMID_SELF;
                op.u.alloc_unbound.remote_dom = 0;

                err = HYPERVISOR_event_channel_op(&op);
                if (err) {
                        aprint_error_dev(xenbus_dev,
                                "can't register xenstore event\n");
                        goto err0;
                }
                
                xen_start_info.store_evtchn = op.u.alloc_unbound.port;

                DELAY(1000);
#else /* DOM0OPS */
                panic("dom0 support not compiled in");
#endif /* DOM0OPS */
        }

#if NKERNFS > 0
        /* Publish xenbus and Xenstore info in /kern/xen */
        xenbus_kernfs_init();
#endif

        /* register event handler */
        xb_init_comms(xenbus_dev);

        /* Initialize the interface to xenstore. */
        err = xs_init(xenbus_dev);
        if (err) {
                aprint_error_dev(xenbus_dev,
                    "Error initializing xenstore comms: %i\n", err);
                goto err0;
        }

        if (!dom0) {
                xenstored_ready = 1;
                xenbus_probe(NULL);
        }

        DPRINTK("done");
        config_pending_decr(xenbus_dev);
#ifdef DOM0OPS
        if (dom0) {
                mutex_enter(&xenstored_lock);
                while (xenstored_ready == 0) {
                        cv_wait(&xenstored_cv, &xenstored_lock);
                        mutex_exit(&xenstored_lock);
                        xenbus_probe(NULL);
                        mutex_enter(&xenstored_lock);
                }
                mutex_exit(&xenstored_lock);
        }
#endif
        kthread_exit(0);

err0:
        if (page)
                uvm_km_free(kernel_map, page, PAGE_SIZE,
                                UVM_KMF_ZERO | UVM_KMF_WIRED);
        kthread_exit(err);
}

/*
 * Local variables:
 *  c-file-style: "linux"
 *  indent-tabs-mode: t
 *  c-indent-level: 8
 *  c-basic-offset: 8
 *  tab-width: 8
 * End:
 */