Commit 240ab11f authored by Peter Maydell's avatar Peter Maydell
Browse files

Merge remote-tracking branch 'remotes/aperard/tags/pull-xen-20190924' into staging 



Xen queue

* Update of maintainer email address
* Fixes for xen-bus and xen-block

# gpg: Signature made Tue 24 Sep 2019 12:27:56 BST
# gpg:                using RSA key F80C006308E22CFD8A92E7980CF5572FD7FB55AF
# gpg:                issuer "anthony.perard@citrix.com"
# gpg: Good signature from "Anthony PERARD <anthony.perard@gmail.com>" [marginal]
# gpg:                 aka "Anthony PERARD <anthony.perard@citrix.com>" [marginal]
# gpg: WARNING: This key is not certified with sufficiently trusted signatures!
# gpg:          It is not certain that the signature belongs to the owner.
# Primary key fingerprint: 5379 2F71 024C 600F 778A  7161 D8D5 7199 DF83 42C8
#      Subkey fingerprint: F80C 0063 08E2 2CFD 8A92  E798 0CF5 572F D7FB 55AF

* remotes/aperard/tags/pull-xen-20190924:
  xen-bus: only set the xen device frontend state if it is missing
  xen-block: treat XenbusStateUnknown the same as XenbusStateClosed
  MAINTAINERS: update my email address
  xen: perform XenDevice clean-up in XenBus watch handler
  xen: introduce separate XenWatchList for XenDevice objects
  xen / notify: introduce a new XenWatchList abstraction
  xen-bus: check whether the frontend is active during device reset...

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents 860d9048 6bd6b955

MAINTAINERS

+1 −1
Original line number Diff line number Diff line
@@ -406,7 +406,7 @@ Guest CPU Cores (Xen) 
X86 Xen CPUs

M: Stefano Stabellini <sstabellini@kernel.org>

M: Anthony Perard <anthony.perard@citrix.com>

M: Paul Durrant <paul.durrant@citrix.com>

M: Paul Durrant <paul@xen.org>

L: xen-devel@lists.xenproject.org

S: Supported

F: */xen*

hw/block/xen-block.c

+1 −0
Original line number Diff line number Diff line
@@ -313,6 +313,7 @@ static void xen_block_frontend_changed(XenDevice *xendev, 
        break;



    case XenbusStateClosed:

    case XenbusStateUnknown:

        xen_block_disconnect(xendev, &local_err);

        if (local_err) {

            error_propagate(errp, local_err);

hw/xen/trace-events

+6 −3
Original line number Diff line number Diff line
@@ -17,11 +17,12 @@ xen_domid_restrict(int err) "err: %u" 
xen_bus_realize(void) ""

xen_bus_unrealize(void) ""

xen_bus_enumerate(void) ""

xen_bus_cleanup(void) ""

xen_bus_type_enumerate(const char *type) "type: %s"

xen_bus_backend_create(const char *type, const char *path) "type: %s path: %s"

xen_bus_add_watch(const char *node, const char *key, char *token) "node: %s key: %s token: %s"

xen_bus_remove_watch(const char *node, const char *key, char *token) "node: %s key: %s token: %s"

xen_bus_watch(const char *token) "token: %s"

xen_bus_device_cleanup(const char *type, char *name) "type: %s name: %s"

xen_bus_add_watch(const char *node, const char *key) "node: %s key: %s"

xen_bus_remove_watch(const char *node, const char *key) "node: %s key: %s"

xen_device_realize(const char *type, char *name) "type: %s name: %s"

xen_device_unrealize(const char *type, char *name) "type: %s name: %s"

xen_device_backend_state(const char *type, char *name, const char *state) "type: %s name: %s -> %s"
@@ -30,6 +31,8 @@ xen_device_backend_changed(const char *type, char *name) "type: %s name: %s" 
xen_device_frontend_state(const char *type, char *name, const char *state) "type: %s name: %s -> %s"

xen_device_frontend_changed(const char *type, char *name) "type: %s name: %s"

xen_device_unplug(const char *type, char *name) "type: %s name: %s"

xen_device_add_watch(const char *type, char *name, const char *node, const char *key) "type: %s name: %s node: %s key: %s"

xen_device_remove_watch(const char *type, char *name, const char *node, const char *key) "type: %s name: %s node: %s key: %s"



# xen-bus-helper.c

xs_node_create(const char *node) "%s"

hw/xen/xen-bus.c

+227 −89
Original line number Diff line number Diff line
@@ -157,18 +157,60 @@ static void free_watch(XenWatch *watch) 
    g_free(watch);

}



static XenWatch *xen_bus_add_watch(XenBus *xenbus, const char *node,

struct XenWatchList {

    struct xs_handle *xsh;

    NotifierList notifiers;

};



static void watch_list_event(void *opaque)

{

    XenWatchList *watch_list = opaque;

    char **v;

    const char *token;



    v = xs_check_watch(watch_list->xsh);

    if (!v) {

        return;

    }



    token = v[XS_WATCH_TOKEN];



    notifier_list_notify(&watch_list->notifiers, (void *)token);



    free(v);

}



static XenWatchList *watch_list_create(struct xs_handle *xsh)

{

    XenWatchList *watch_list = g_new0(XenWatchList, 1);



    g_assert(xsh);



    watch_list->xsh = xsh;

    notifier_list_init(&watch_list->notifiers);

    qemu_set_fd_handler(xs_fileno(watch_list->xsh), watch_list_event, NULL,

                        watch_list);



    return watch_list;

}



static void watch_list_destroy(XenWatchList *watch_list)

{

    g_assert(notifier_list_empty(&watch_list->notifiers));

    qemu_set_fd_handler(xs_fileno(watch_list->xsh), NULL, NULL, NULL);

    g_free(watch_list);

}



static XenWatch *watch_list_add(XenWatchList *watch_list, const char *node,

                                const char *key, XenWatchHandler handler,

                                void *opaque, Error **errp)

{

    XenWatch *watch = new_watch(node, key, handler, opaque);

    Error *local_err = NULL;



    trace_xen_bus_add_watch(watch->node, watch->key, watch->token);

    notifier_list_add(&watch_list->notifiers, &watch->notifier);



    notifier_list_add(&xenbus->watch_notifiers, &watch->notifier);



    xs_node_watch(xenbus->xsh, node, key, watch->token, &local_err);

    xs_node_watch(watch_list->xsh, node, key, watch->token, &local_err);

    if (local_err) {

        error_propagate(errp, local_err);
@@ -181,18 +223,34 @@ static XenWatch *xen_bus_add_watch(XenBus *xenbus, const char *node, 
    return watch;

}



static void xen_bus_remove_watch(XenBus *xenbus, XenWatch *watch,

static void watch_list_remove(XenWatchList *watch_list, XenWatch *watch,

                              Error **errp)

{

    trace_xen_bus_remove_watch(watch->node, watch->key, watch->token);



    xs_node_unwatch(xenbus->xsh, watch->node, watch->key, watch->token,

    xs_node_unwatch(watch_list->xsh, watch->node, watch->key, watch->token,

                    errp);



    notifier_remove(&watch->notifier);

    free_watch(watch);

}



static XenWatch *xen_bus_add_watch(XenBus *xenbus, const char *node,

                                   const char *key, XenWatchHandler handler,

                                   Error **errp)

{

    trace_xen_bus_add_watch(node, key);



    return watch_list_add(xenbus->watch_list, node, key, handler, xenbus,

                          errp);

}



static void xen_bus_remove_watch(XenBus *xenbus, XenWatch *watch,

                                 Error **errp)

{

    trace_xen_bus_remove_watch(watch->node, watch->key);



    watch_list_remove(xenbus->watch_list, watch, errp);

}



static void xen_bus_backend_create(XenBus *xenbus, const char *type,

                                   const char *name, char *path,

                                   Error **errp)
@@ -282,13 +340,18 @@ static void xen_bus_type_enumerate(XenBus *xenbus, const char *type) 
    for (i = 0; i < n; i++) {

        char *backend_path = g_strdup_printf("%s/%s", domain_path,

                                             backend[i]);

        enum xenbus_state backend_state;

        enum xenbus_state state;

        unsigned int online;



        if (xs_node_scanf(xenbus->xsh, XBT_NULL, backend_path, "state",

                          NULL, "%u", &backend_state) != 1)

            backend_state = XenbusStateUnknown;

                          NULL, "%u", &state) != 1)

            state = XenbusStateUnknown;



        if (xs_node_scanf(xenbus->xsh, XBT_NULL, backend_path, "online",

                          NULL, "%u", &online) != 1)

            online = 0;



        if (backend_state == XenbusStateInitialising) {

        if (online && state == XenbusStateInitialising) {

            Error *local_err = NULL;



            xen_bus_backend_create(xenbus, type, backend[i], backend_path,
@@ -307,9 +370,8 @@ out: 
    g_free(domain_path);

}



static void xen_bus_enumerate(void *opaque)

static void xen_bus_enumerate(XenBus *xenbus)

{

    XenBus *xenbus = opaque;

    char **type;

    unsigned int i, n;
@@ -327,46 +389,64 @@ static void xen_bus_enumerate(void *opaque) 
    free(type);

}



static void xen_bus_unrealize(BusState *bus, Error **errp)

static void xen_bus_device_cleanup(XenDevice *xendev)

{

    XenBus *xenbus = XEN_BUS(bus);

    const char *type = object_get_typename(OBJECT(xendev));

    Error *local_err = NULL;



    trace_xen_bus_unrealize();

    trace_xen_bus_device_cleanup(type, xendev->name);



    if (xenbus->backend_watch) {

        xen_bus_remove_watch(xenbus, xenbus->backend_watch, NULL);

        xenbus->backend_watch = NULL;

    g_assert(!xendev->backend_online);



    if (!xen_backend_try_device_destroy(xendev, &local_err)) {

        object_unparent(OBJECT(xendev));

    }



    if (!xenbus->xsh) {

        return;

    if (local_err) {

        error_report_err(local_err);

    }

}



    qemu_set_fd_handler(xs_fileno(xenbus->xsh), NULL, NULL, NULL);

static void xen_bus_cleanup(XenBus *xenbus)

{

    XenDevice *xendev, *next;



    xs_close(xenbus->xsh);

    trace_xen_bus_cleanup();



    QLIST_FOREACH_SAFE(xendev, &xenbus->inactive_devices, list, next) {

        g_assert(xendev->inactive);

        QLIST_REMOVE(xendev, list);

        xen_bus_device_cleanup(xendev);

    }

}



static void xen_bus_watch(void *opaque)

static void xen_bus_backend_changed(void *opaque)

{

    XenBus *xenbus = opaque;

    char **v;

    const char *token;



    g_assert(xenbus->xsh);



    v = xs_check_watch(xenbus->xsh);

    if (!v) {

        return;

    xen_bus_enumerate(xenbus);

    xen_bus_cleanup(xenbus);

}



    token = v[XS_WATCH_TOKEN];

static void xen_bus_unrealize(BusState *bus, Error **errp)

{

    XenBus *xenbus = XEN_BUS(bus);



    trace_xen_bus_unrealize();



    trace_xen_bus_watch(token);

    if (xenbus->backend_watch) {

        xen_bus_remove_watch(xenbus, xenbus->backend_watch, NULL);

        xenbus->backend_watch = NULL;

    }



    notifier_list_notify(&xenbus->watch_notifiers, (void *)token);

    if (xenbus->watch_list) {

        watch_list_destroy(xenbus->watch_list);

        xenbus->watch_list = NULL;

    }



    free(v);

    if (xenbus->xsh) {

        xs_close(xenbus->xsh);

    }

}



static void xen_bus_realize(BusState *bus, Error **errp)
@@ -390,15 +470,13 @@ static void xen_bus_realize(BusState *bus, Error **errp) 
        xenbus->backend_id = 0; /* Assume lack of node means dom0 */

    }



    notifier_list_init(&xenbus->watch_notifiers);

    qemu_set_fd_handler(xs_fileno(xenbus->xsh), xen_bus_watch, NULL,

                        xenbus);

    xenbus->watch_list = watch_list_create(xenbus->xsh);



    module_call_init(MODULE_INIT_XEN_BACKEND);



    xenbus->backend_watch =

        xen_bus_add_watch(xenbus, "", /* domain root node */

                          "backend", xen_bus_enumerate, xenbus, &local_err);

                          "backend", xen_bus_backend_changed, &local_err);

    if (local_err) {

        /* This need not be treated as a hard error so don't propagate */

        error_reportf_err(local_err,
@@ -520,9 +598,9 @@ static void xen_device_backend_set_online(XenDevice *xendev, bool online) 
 * Tell from the state whether the frontend is likely alive,

 * i.e. it will react to a change of state of the backend.

 */

static bool xen_device_state_is_active(enum xenbus_state state)

static bool xen_device_frontend_is_active(XenDevice *xendev)

{

    switch (state) {

    switch (xendev->frontend_state) {

    case XenbusStateInitWait:

    case XenbusStateInitialised:

    case XenbusStateConnected:
@@ -559,33 +637,59 @@ static void xen_device_backend_changed(void *opaque) 
     * state to Closing, but there is no active frontend then set the

     * backend state to Closed.

     */

    if (xendev->backend_state == XenbusStateClosing &&

        !xen_device_state_is_active(state)) {

    if (state == XenbusStateClosing &&

        !xen_device_frontend_is_active(xendev)) {

        xen_device_backend_set_state(xendev, XenbusStateClosed);

    }



    /*

     * If a backend is still 'online' then we should leave it alone but,

     * if a backend is not 'online', then the device should be destroyed

     * once the state is Closed.

     * if a backend is not 'online', then the device is a candidate

     * for destruction. Hence add it to the 'inactive' list to be cleaned

     * by xen_bus_cleanup().

     */

    if (!xendev->backend_online &&

        (xendev->backend_state == XenbusStateClosed ||

         xendev->backend_state == XenbusStateInitialising ||

         xendev->backend_state == XenbusStateInitWait ||

         xendev->backend_state == XenbusStateUnknown)) {

        Error *local_err = NULL;

    if (!online &&

        (state == XenbusStateClosed ||  state == XenbusStateInitialising ||

         state == XenbusStateInitWait || state == XenbusStateUnknown) &&

        !xendev->inactive) {

        XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev)));



        if (!xen_backend_try_device_destroy(xendev, &local_err)) {

            object_unparent(OBJECT(xendev));

        }

        xendev->inactive = true;

        QLIST_INSERT_HEAD(&xenbus->inactive_devices, xendev, list);



        if (local_err) {

            error_report_err(local_err);

        /*

         * Re-write the state to cause a XenBus backend_watch notification,

         * resulting in a call to xen_bus_cleanup().

         */

        xen_device_backend_printf(xendev, "state", "%u", state);

    }

}



static XenWatch *xen_device_add_watch(XenDevice *xendev, const char *node,

                                      const char *key,

                                      XenWatchHandler handler,

                                      Error **errp)

{

    const char *type = object_get_typename(OBJECT(xendev));



    trace_xen_device_add_watch(type, xendev->name, node, key);



    return watch_list_add(xendev->watch_list, node, key, handler, xendev,

                          errp);

}



static void xen_device_remove_watch(XenDevice *xendev, XenWatch *watch,

                                    Error **errp)

{

    const char *type = object_get_typename(OBJECT(xendev));



    trace_xen_device_remove_watch(type, xendev->name, watch->node,

                                  watch->key);



    watch_list_remove(xendev->watch_list, watch, errp);

}





static void xen_device_backend_create(XenDevice *xendev, Error **errp)

{

    XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev)));
@@ -610,9 +714,9 @@ static void xen_device_backend_create(XenDevice *xendev, Error **errp) 
    }



    xendev->backend_state_watch =

        xen_bus_add_watch(xenbus, xendev->backend_path,

        xen_device_add_watch(xendev, xendev->backend_path,

                             "state", xen_device_backend_changed,

                          xendev, &local_err);

                             &local_err);

    if (local_err) {

        error_propagate_prepend(errp, local_err,

                                "failed to watch backend state: ");
@@ -620,9 +724,9 @@ static void xen_device_backend_create(XenDevice *xendev, Error **errp) 
    }



    xendev->backend_online_watch =

        xen_bus_add_watch(xenbus, xendev->backend_path,

        xen_device_add_watch(xendev, xendev->backend_path,

                             "online", xen_device_backend_changed,

                          xendev, &local_err);

                             &local_err);

    if (local_err) {

        error_propagate_prepend(errp, local_err,

                                "failed to watch backend online: ");
@@ -636,12 +740,12 @@ static void xen_device_backend_destroy(XenDevice *xendev) 
    Error *local_err = NULL;



    if (xendev->backend_online_watch) {

        xen_bus_remove_watch(xenbus, xendev->backend_online_watch, NULL);

        xen_device_remove_watch(xendev, xendev->backend_online_watch, NULL);

        xendev->backend_online_watch = NULL;

    }



    if (xendev->backend_state_watch) {

        xen_bus_remove_watch(xenbus, xendev->backend_state_watch, NULL);

        xen_device_remove_watch(xendev, xendev->backend_state_watch, NULL);

        xendev->backend_state_watch = NULL;

    }
@@ -753,6 +857,13 @@ static void xen_device_frontend_changed(void *opaque) 
    }

}



static bool xen_device_frontend_exists(XenDevice *xendev)

{

    enum xenbus_state state;



    return (xen_device_frontend_scanf(xendev, "state", "%u", &state) == 1);

}



static void xen_device_frontend_create(XenDevice *xendev, Error **errp)

{

    XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev)));
@@ -761,6 +872,11 @@ static void xen_device_frontend_create(XenDevice *xendev, Error **errp) 


    xendev->frontend_path = xen_device_get_frontend_path(xendev);



    /*

     * The frontend area may have already been created by a legacy

     * toolstack.

     */

    if (!xen_device_frontend_exists(xendev)) {

        perms[0].id = xendev->frontend_id;

        perms[0].perms = XS_PERM_NONE;

        perms[1].id = xenbus->backend_id;
@@ -775,10 +891,11 @@ static void xen_device_frontend_create(XenDevice *xendev, Error **errp) 
                                    "failed to create frontend: ");

            return;

        }

    }



    xendev->frontend_state_watch =

        xen_bus_add_watch(xenbus, xendev->frontend_path, "state",

                          xen_device_frontend_changed, xendev, &local_err);

        xen_device_add_watch(xendev, xendev->frontend_path, "state",

                             xen_device_frontend_changed, &local_err);

    if (local_err) {

        error_propagate_prepend(errp, local_err,

                                "failed to watch frontend state: ");
@@ -791,7 +908,8 @@ static void xen_device_frontend_destroy(XenDevice *xendev) 
    Error *local_err = NULL;



    if (xendev->frontend_state_watch) {

        xen_bus_remove_watch(xenbus, xendev->frontend_state_watch, NULL);

        xen_device_remove_watch(xendev, xendev->frontend_state_watch,

                                NULL);

        xendev->frontend_state_watch = NULL;

    }
@@ -1087,6 +1205,16 @@ static void xen_device_unrealize(DeviceState *dev, Error **errp) 
        xendev->xgth = NULL;

    }



    if (xendev->watch_list) {

        watch_list_destroy(xendev->watch_list);

        xendev->watch_list = NULL;

    }



    if (xendev->xsh) {

        xs_close(xendev->xsh);

        xendev->xsh = NULL;

    }



    g_free(xendev->name);

    xendev->name = NULL;

}
@@ -1129,6 +1257,14 @@ static void xen_device_realize(DeviceState *dev, Error **errp) 


    trace_xen_device_realize(type, xendev->name);



    xendev->xsh = xs_open(0);

    if (!xendev->xsh) {

        error_setg_errno(errp, errno, "failed xs_open");

        goto unrealize;

    }



    xendev->watch_list = watch_list_create(xendev->xsh);



    xendev->xgth = xengnttab_open(NULL, 0);

    if (!xendev->xgth) {

        error_setg_errno(errp, errno, "failed xengnttab_open");
@@ -1167,12 +1303,14 @@ static void xen_device_realize(DeviceState *dev, Error **errp) 
    xen_device_backend_set_online(xendev, true);

    xen_device_backend_set_state(xendev, XenbusStateInitWait);



    if (!xen_device_frontend_exists(xendev)) {

        xen_device_frontend_printf(xendev, "backend", "%s",

                                   xendev->backend_path);

        xen_device_frontend_printf(xendev, "backend-id", "%u",

                                   xenbus->backend_id);



        xen_device_frontend_set_state(xendev, XenbusStateInitialising, true);

    }



    xendev->exit.notify = xen_device_exit;

    qemu_add_exit_notifier(&xendev->exit);

include/hw/xen/xen-bus.h

+7 −1
Original line number Diff line number Diff line
@@ -14,6 +14,7 @@ 


typedef void (*XenWatchHandler)(void *opaque);



typedef struct XenWatchList XenWatchList;

typedef struct XenWatch XenWatch;

typedef struct XenEventChannel XenEventChannel;
@@ -21,6 +22,8 @@ typedef struct XenDevice { 
    DeviceState qdev;

    domid_t frontend_id;

    char *name;

    struct xs_handle *xsh;

    XenWatchList *watch_list;

    char *backend_path, *frontend_path;

    enum xenbus_state backend_state, frontend_state;

    Notifier exit;
@@ -29,7 +32,9 @@ typedef struct XenDevice { 
    XenWatch *backend_online_watch;

    xengnttab_handle *xgth;

    bool feature_grant_copy;

    bool inactive;

    QLIST_HEAD(, XenEventChannel) event_channels;

    QLIST_ENTRY(XenDevice) list;

} XenDevice;



typedef char *(*XenDeviceGetName)(XenDevice *xendev, Error **errp);
@@ -63,8 +68,9 @@ typedef struct XenBus { 
    BusState qbus;

    domid_t backend_id;

    struct xs_handle *xsh;

    NotifierList watch_notifiers;

    XenWatchList *watch_list;

    XenWatch *backend_watch;

    QLIST_HEAD(, XenDevice) inactive_devices;

} XenBus;



typedef struct XenBusClass {