Commit 1de7096d authored by Vladimir Sementsov-Ogievskiy's avatar Vladimir Sementsov-Ogievskiy Committed by Markus Armbruster
Browse files

xen: Use ERRP_GUARD() 



If we want to check error after errp-function call, we need to
introduce local_err and then propagate it to errp. Instead, use
the ERRP_GUARD() macro, benefits are:
1. No need of explicit error_propagate call
2. No need of explicit local_err variable: use errp directly
3. ERRP_GUARD() leaves errp as is if it's not NULL or
   &error_fatal, this means that we don't break error_abort
   (we'll abort on error_set, not on error_propagate)

If we want to add some info to errp (by error_prepend() or
error_append_hint()), we must use the ERRP_GUARD() macro.
Otherwise, this info will not be added when errp == &error_fatal
(the program will exit prior to the error_append_hint() or
error_prepend() call).  No such cases are being fixed here.

This commit is generated by command

    sed -n '/^X86 Xen CPUs$/,/^$/{s/^F: //p}' MAINTAINERS | \
    xargs git ls-files | grep '\.[hc]$' | \
    xargs spatch \
        --sp-file scripts/coccinelle/errp-guard.cocci \
        --macro-file scripts/cocci-macro-file.h \
        --in-place --no-show-diff --max-width 80

Reported-by: default avatarKevin Wolf <kwolf@redhat.com>
Reported-by: default avatarGreg Kurz <groug@kaod.org>
Signed-off-by: default avatarVladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: default avatarPhilippe Mathieu-Daudé <philmd@redhat.com>
[Commit message tweaked]
Signed-off-by: default avatarMarkus Armbruster <armbru@redhat.com>
Message-Id: <20200707165037.1026246-9-armbru@redhat.com>
[ERRP_AUTO_PROPAGATE() renamed to ERRP_GUARD(), and
auto-propagated-errp.cocci to errp-guard.cocci.  Commit message
tweaked again.]
parent 795d946d

hw/block/dataplane/xen-block.c

+7 −10
Original line number Diff line number Diff line
@@ -723,8 +723,8 @@ void xen_block_dataplane_start(XenBlockDataPlane *dataplane, 
                               unsigned int protocol,

                               Error **errp)

{

    ERRP_GUARD();

    XenDevice *xendev = dataplane->xendev;

    Error *local_err = NULL;

    unsigned int ring_size;

    unsigned int i;
@@ -760,9 +760,8 @@ void xen_block_dataplane_start(XenBlockDataPlane *dataplane, 
    }



    xen_device_set_max_grant_refs(xendev, dataplane->nr_ring_ref,

                                  &local_err);

    if (local_err) {

        error_propagate(errp, local_err);

                                  errp);

    if (*errp) {

        goto stop;

    }
@@ -770,9 +769,8 @@ void xen_block_dataplane_start(XenBlockDataPlane *dataplane, 
                                              dataplane->ring_ref,

                                              dataplane->nr_ring_ref,

                                              PROT_READ | PROT_WRITE,

                                              &local_err);

    if (local_err) {

        error_propagate(errp, local_err);

                                              errp);

    if (*errp) {

        goto stop;

    }
@@ -805,9 +803,8 @@ void xen_block_dataplane_start(XenBlockDataPlane *dataplane, 
    dataplane->event_channel =

        xen_device_bind_event_channel(xendev, event_channel,

                                      xen_block_dataplane_event, dataplane,

                                      &local_err);

    if (local_err) {

        error_propagate(errp, local_err);

                                      errp);

    if (*errp) {

        goto stop;

    }

hw/block/xen-block.c

+43 −59
Original line number Diff line number Diff line
@@ -195,6 +195,7 @@ static const BlockDevOps xen_block_dev_ops = { 


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

{

    ERRP_GUARD();

    XenBlockDevice *blockdev = XEN_BLOCK_DEVICE(xendev);

    XenBlockDeviceClass *blockdev_class =

        XEN_BLOCK_DEVICE_GET_CLASS(xendev);
@@ -202,7 +203,6 @@ static void xen_block_realize(XenDevice *xendev, Error **errp) 
    XenBlockVdev *vdev = &blockdev->props.vdev;

    BlockConf *conf = &blockdev->props.conf;

    BlockBackend *blk = conf->blk;

    Error *local_err = NULL;



    if (vdev->type == XEN_BLOCK_VDEV_TYPE_INVALID) {

        error_setg(errp, "vdev property not set");
@@ -212,9 +212,8 @@ static void xen_block_realize(XenDevice *xendev, Error **errp) 
    trace_xen_block_realize(type, vdev->disk, vdev->partition);



    if (blockdev_class->realize) {

        blockdev_class->realize(blockdev, &local_err);

        if (local_err) {

            error_propagate(errp, local_err);

        blockdev_class->realize(blockdev, errp);

        if (*errp) {

            return;

        }

    }
@@ -280,8 +279,8 @@ static void xen_block_frontend_changed(XenDevice *xendev, 
                                       enum xenbus_state frontend_state,

                                       Error **errp)

{

    ERRP_GUARD();

    enum xenbus_state backend_state = xen_device_backend_get_state(xendev);

    Error *local_err = NULL;



    switch (frontend_state) {

    case XenbusStateInitialised:
@@ -290,15 +289,13 @@ static void xen_block_frontend_changed(XenDevice *xendev, 
            break;

        }



        xen_block_disconnect(xendev, &local_err);

        if (local_err) {

            error_propagate(errp, local_err);

        xen_block_disconnect(xendev, errp);

        if (*errp) {

            break;

        }



        xen_block_connect(xendev, &local_err);

        if (local_err) {

            error_propagate(errp, local_err);

        xen_block_connect(xendev, errp);

        if (*errp) {

            break;

        }
@@ -311,9 +308,8 @@ static void xen_block_frontend_changed(XenDevice *xendev, 


    case XenbusStateClosed:

    case XenbusStateUnknown:

        xen_block_disconnect(xendev, &local_err);

        if (local_err) {

            error_propagate(errp, local_err);

        xen_block_disconnect(xendev, errp);

        if (*errp) {

            break;

        }
@@ -665,9 +661,9 @@ static void xen_block_blockdev_del(const char *node_name, Error **errp) 
static char *xen_block_blockdev_add(const char *id, QDict *qdict,

                                    Error **errp)

{

    ERRP_GUARD();

    const char *driver = qdict_get_try_str(qdict, "driver");

    BlockdevOptions *options = NULL;

    Error *local_err = NULL;

    char *node_name;

    Visitor *v;
@@ -688,10 +684,9 @@ static char *xen_block_blockdev_add(const char *id, QDict *qdict, 
        goto fail;

    }



    qmp_blockdev_add(options, &local_err);

    qmp_blockdev_add(options, errp);



    if (local_err) {

        error_propagate(errp, local_err);

    if (*errp) {

        goto fail;

    }
@@ -710,14 +705,12 @@ fail: 


static void xen_block_drive_destroy(XenBlockDrive *drive, Error **errp)

{

    ERRP_GUARD();

    char *node_name = drive->node_name;



    if (node_name) {

        Error *local_err = NULL;



        xen_block_blockdev_del(node_name, &local_err);

        if (local_err) {

            error_propagate(errp, local_err);

        xen_block_blockdev_del(node_name, errp);

        if (*errp) {

            return;

        }

        g_free(node_name);
@@ -731,6 +724,7 @@ static XenBlockDrive *xen_block_drive_create(const char *id, 
                                             const char *device_type,

                                             QDict *opts, Error **errp)

{

    ERRP_GUARD();

    const char *params = qdict_get_try_str(opts, "params");

    const char *mode = qdict_get_try_str(opts, "mode");

    const char *direct_io_safe = qdict_get_try_str(opts, "direct-io-safe");
@@ -738,7 +732,6 @@ static XenBlockDrive *xen_block_drive_create(const char *id, 
    char *driver = NULL;

    char *filename = NULL;

    XenBlockDrive *drive = NULL;

    Error *local_err = NULL;

    QDict *file_layer;

    QDict *driver_layer;
@@ -817,13 +810,12 @@ static XenBlockDrive *xen_block_drive_create(const char *id, 


    g_assert(!drive->node_name);

    drive->node_name = xen_block_blockdev_add(drive->id, driver_layer,

                                              &local_err);

                                              errp);



    qobject_unref(driver_layer);



done:

    if (local_err) {

        error_propagate(errp, local_err);

    if (*errp) {

        xen_block_drive_destroy(drive, NULL);

        return NULL;

    }
@@ -848,8 +840,8 @@ static void xen_block_iothread_destroy(XenBlockIOThread *iothread, 
static XenBlockIOThread *xen_block_iothread_create(const char *id,

                                                   Error **errp)

{

    ERRP_GUARD();

    XenBlockIOThread *iothread = g_new(XenBlockIOThread, 1);

    Error *local_err = NULL;

    QDict *opts;

    QObject *ret_data = NULL;
@@ -858,13 +850,11 @@ static XenBlockIOThread *xen_block_iothread_create(const char *id, 
    opts = qdict_new();

    qdict_put_str(opts, "qom-type", TYPE_IOTHREAD);

    qdict_put_str(opts, "id", id);

    qmp_object_add(opts, &ret_data, &local_err);

    qmp_object_add(opts, &ret_data, errp);

    qobject_unref(opts);

    qobject_unref(ret_data);



    if (local_err) {

        error_propagate(errp, local_err);



    if (*errp) {

        g_free(iothread->id);

        g_free(iothread);

        return NULL;
@@ -876,6 +866,7 @@ static XenBlockIOThread *xen_block_iothread_create(const char *id, 
static void xen_block_device_create(XenBackendInstance *backend,

                                    QDict *opts, Error **errp)

{

    ERRP_GUARD();

    XenBus *xenbus = xen_backend_get_bus(backend);

    const char *name = xen_backend_get_name(backend);

    unsigned long number;
@@ -883,7 +874,6 @@ static void xen_block_device_create(XenBackendInstance *backend, 
    XenBlockDrive *drive = NULL;

    XenBlockIOThread *iothread = NULL;

    XenDevice *xendev = NULL;

    Error *local_err = NULL;

    const char *type;

    XenBlockDevice *blockdev;
@@ -915,16 +905,15 @@ static void xen_block_device_create(XenBackendInstance *backend, 
        goto fail;

    }



    drive = xen_block_drive_create(vdev, device_type, opts, &local_err);

    drive = xen_block_drive_create(vdev, device_type, opts, errp);

    if (!drive) {

        error_propagate_prepend(errp, local_err, "failed to create drive: ");

        error_prepend(errp, "failed to create drive: ");

        goto fail;

    }



    iothread = xen_block_iothread_create(vdev, &local_err);

    if (local_err) {

        error_propagate_prepend(errp, local_err,

                                "failed to create iothread: ");

    iothread = xen_block_iothread_create(vdev, errp);

    if (*errp) {

        error_prepend(errp, "failed to create iothread: ");

        goto fail;

    }
@@ -932,32 +921,29 @@ static void xen_block_device_create(XenBackendInstance *backend, 
    blockdev = XEN_BLOCK_DEVICE(xendev);



    if (!object_property_set_str(OBJECT(xendev), "vdev", vdev,

                                 &local_err)) {

        error_propagate_prepend(errp, local_err, "failed to set 'vdev': ");

                                 errp)) {

        error_prepend(errp, "failed to set 'vdev': ");

        goto fail;

    }



    if (!object_property_set_str(OBJECT(xendev), "drive",

                                 xen_block_drive_get_node_name(drive),

                                 &local_err)) {

        error_propagate_prepend(errp, local_err, "failed to set 'drive': ");

                                 errp)) {

        error_prepend(errp, "failed to set 'drive': ");

        goto fail;

    }



    if (!object_property_set_str(OBJECT(xendev), "iothread", iothread->id,

                                 &local_err)) {

        error_propagate_prepend(errp, local_err,

                                "failed to set 'iothread': ");

                                 errp)) {

        error_prepend(errp, "failed to set 'iothread': ");

        goto fail;

    }



    blockdev->iothread = iothread;

    blockdev->drive = drive;



    if (!qdev_realize_and_unref(DEVICE(xendev), BUS(xenbus), &local_err)) {

        error_propagate_prepend(errp, local_err,

                                "realization of device %s failed: ",

                                type);

    if (!qdev_realize_and_unref(DEVICE(xendev), BUS(xenbus), errp)) {

        error_prepend(errp, "realization of device %s failed: ", type);

        goto fail;

    }
@@ -981,31 +967,29 @@ fail: 
static void xen_block_device_destroy(XenBackendInstance *backend,

                                     Error **errp)

{

    ERRP_GUARD();

    XenDevice *xendev = xen_backend_get_device(backend);

    XenBlockDevice *blockdev = XEN_BLOCK_DEVICE(xendev);

    XenBlockVdev *vdev = &blockdev->props.vdev;

    XenBlockDrive *drive = blockdev->drive;

    XenBlockIOThread *iothread = blockdev->iothread;

    Error *local_err = NULL;



    trace_xen_block_device_destroy(vdev->number);



    object_unparent(OBJECT(xendev));



    if (iothread) {

        xen_block_iothread_destroy(iothread, &local_err);

        if (local_err) {

            error_propagate_prepend(errp, local_err,

                                    "failed to destroy iothread: ");

        xen_block_iothread_destroy(iothread, errp);

        if (*errp) {

            error_prepend(errp, "failed to destroy iothread: ");

            return;

        }

    }



    if (drive) {

        xen_block_drive_destroy(drive, &local_err);

        if (local_err) {

            error_propagate_prepend(errp, local_err,

                                    "failed to destroy drive: ");

        xen_block_drive_destroy(drive, errp);

        if (*errp) {

            error_prepend(errp, "failed to destroy drive: ");

            return;

        }

    }

hw/pci-host/xen_igd_pt.c

+3 −4
Original line number Diff line number Diff line
@@ -79,17 +79,16 @@ static void host_pci_config_read(int pos, int len, uint32_t *val, Error **errp) 


static void igd_pt_i440fx_realize(PCIDevice *pci_dev, Error **errp)

{

    ERRP_GUARD();

    uint32_t val = 0;

    size_t i;

    int pos, len;

    Error *local_err = NULL;



    for (i = 0; i < ARRAY_SIZE(igd_host_bridge_infos); i++) {

        pos = igd_host_bridge_infos[i].offset;

        len = igd_host_bridge_infos[i].len;

        host_pci_config_read(pos, len, &val, &local_err);

        if (local_err) {

            error_propagate(errp, local_err);

        host_pci_config_read(pos, len, &val, errp);

        if (*errp) {

            return;

        }

        pci_default_write_config(pci_dev, pos, val, len);

hw/xen/xen-backend.c

+3 −4
Original line number Diff line number Diff line
@@ -98,9 +98,9 @@ static void xen_backend_list_remove(XenBackendInstance *backend) 
void xen_backend_device_create(XenBus *xenbus, const char *type,

                               const char *name, QDict *opts, Error **errp)

{

    ERRP_GUARD();

    const XenBackendImpl *impl = xen_backend_table_lookup(type);

    XenBackendInstance *backend;

    Error *local_error = NULL;



    if (!impl) {

        return;
@@ -110,9 +110,8 @@ void xen_backend_device_create(XenBus *xenbus, const char *type, 
    backend->xenbus = xenbus;

    backend->name = g_strdup(name);



    impl->create(backend, opts, &local_error);

    if (local_error) {

        error_propagate(errp, local_error);

    impl->create(backend, opts, errp);

    if (*errp) {

        g_free(backend->name);

        g_free(backend);

        return;

hw/xen/xen-bus.c

+39 −53
Original line number Diff line number Diff line
@@ -53,9 +53,9 @@ static char *xen_device_get_frontend_path(XenDevice *xendev) 


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

{

    ERRP_GUARD();

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

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

    Error *local_err = NULL;

    xs_transaction_t tid;



    trace_xen_device_unplug(type, xendev->name);
@@ -69,14 +69,14 @@ again: 
    }



    xs_node_printf(xenbus->xsh, tid, xendev->backend_path, "online",

                   &local_err, "%u", 0);

    if (local_err) {

                   errp, "%u", 0);

    if (*errp) {

        goto abort;

    }



    xs_node_printf(xenbus->xsh, tid, xendev->backend_path, "state",

                   &local_err, "%u", XenbusStateClosing);

    if (local_err) {

                   errp, "%u", XenbusStateClosing);

    if (*errp) {

        goto abort;

    }
@@ -96,7 +96,6 @@ abort: 
     * from ending the transaction.

     */

    xs_transaction_end(xenbus->xsh, tid, true);

    error_propagate(errp, local_err);

}



static void xen_bus_print_dev(Monitor *mon, DeviceState *dev, int indent)
@@ -205,15 +204,13 @@ static XenWatch *watch_list_add(XenWatchList *watch_list, const char *node, 
                                const char *key, XenWatchHandler handler,

                                void *opaque, Error **errp)

{

    ERRP_GUARD();

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

    Error *local_err = NULL;



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



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

    if (local_err) {

        error_propagate(errp, local_err);



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

    if (*errp) {

        notifier_remove(&watch->notifier);

        free_watch(watch);
@@ -255,11 +252,11 @@ static void xen_bus_backend_create(XenBus *xenbus, const char *type, 
                                   const char *name, char *path,

                                   Error **errp)

{

    ERRP_GUARD();

    xs_transaction_t tid;

    char **key;

    QDict *opts;

    unsigned int i, n;

    Error *local_err = NULL;



    trace_xen_bus_backend_create(type, path);
@@ -314,13 +311,11 @@ again: 
        return;

    }



    xen_backend_device_create(xenbus, type, name, opts, &local_err);

    xen_backend_device_create(xenbus, type, name, opts, errp);

    qobject_unref(opts);



    if (local_err) {

        error_propagate_prepend(errp, local_err,

                                "failed to create '%s' device '%s': ",

                                type, name);

    if (*errp) {

        error_prepend(errp, "failed to create '%s' device '%s': ", type, name);

    }

}
@@ -692,9 +687,9 @@ static void xen_device_remove_watch(XenDevice *xendev, XenWatch *watch, 


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

{

    ERRP_GUARD();

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

    struct xs_permissions perms[2];

    Error *local_err = NULL;



    xendev->backend_path = xen_device_get_backend_path(xendev);
@@ -706,30 +701,27 @@ static void xen_device_backend_create(XenDevice *xendev, Error **errp) 
    g_assert(xenbus->xsh);



    xs_node_create(xenbus->xsh, XBT_NULL, xendev->backend_path, perms,

                   ARRAY_SIZE(perms), &local_err);

    if (local_err) {

        error_propagate_prepend(errp, local_err,

                                "failed to create backend: ");

                   ARRAY_SIZE(perms), errp);

    if (*errp) {

        error_prepend(errp, "failed to create backend: ");

        return;

    }



    xendev->backend_state_watch =

        xen_device_add_watch(xendev, xendev->backend_path,

                             "state", xen_device_backend_changed,

                             &local_err);

    if (local_err) {

        error_propagate_prepend(errp, local_err,

                                "failed to watch backend state: ");

                             errp);

    if (*errp) {

        error_prepend(errp, "failed to watch backend state: ");

        return;

    }



    xendev->backend_online_watch =

        xen_device_add_watch(xendev, xendev->backend_path,

                             "online", xen_device_backend_changed,

                             &local_err);

    if (local_err) {

        error_propagate_prepend(errp, local_err,

                                "failed to watch backend online: ");

                             errp);

    if (*errp) {

        error_prepend(errp, "failed to watch backend online: ");

        return;

    }

}
@@ -866,9 +858,9 @@ static bool xen_device_frontend_exists(XenDevice *xendev) 


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

{

    ERRP_GUARD();

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

    struct xs_permissions perms[2];

    Error *local_err = NULL;



    xendev->frontend_path = xen_device_get_frontend_path(xendev);
@@ -885,20 +877,18 @@ static void xen_device_frontend_create(XenDevice *xendev, Error **errp) 
        g_assert(xenbus->xsh);



        xs_node_create(xenbus->xsh, XBT_NULL, xendev->frontend_path, perms,

                       ARRAY_SIZE(perms), &local_err);

        if (local_err) {

            error_propagate_prepend(errp, local_err,

                                    "failed to create frontend: ");

                       ARRAY_SIZE(perms), errp);

        if (*errp) {

            error_prepend(errp, "failed to create frontend: ");

            return;

        }

    }



    xendev->frontend_state_watch =

        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: ");

                             xen_device_frontend_changed, errp);

    if (*errp) {

        error_prepend(errp, "failed to watch frontend state: ");

    }

}
@@ -1247,11 +1237,11 @@ static void xen_device_exit(Notifier *n, void *data) 


static void xen_device_realize(DeviceState *dev, Error **errp)

{

    ERRP_GUARD();

    XenDevice *xendev = XEN_DEVICE(dev);

    XenDeviceClass *xendev_class = XEN_DEVICE_GET_CLASS(xendev);

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

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

    Error *local_err = NULL;



    if (xendev->frontend_id == DOMID_INVALID) {

        xendev->frontend_id = xen_domid;
@@ -1267,10 +1257,9 @@ static void xen_device_realize(DeviceState *dev, Error **errp) 
        goto unrealize;

    }



    xendev->name = xendev_class->get_name(xendev, &local_err);

    if (local_err) {

        error_propagate_prepend(errp, local_err,

                                "failed to get device name: ");

    xendev->name = xendev_class->get_name(xendev, errp);

    if (*errp) {

        error_prepend(errp, "failed to get device name: ");

        goto unrealize;

    }
@@ -1293,22 +1282,19 @@ static void xen_device_realize(DeviceState *dev, Error **errp) 
    xendev->feature_grant_copy =

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



    xen_device_backend_create(xendev, &local_err);

    if (local_err) {

        error_propagate(errp, local_err);

    xen_device_backend_create(xendev, errp);

    if (*errp) {

        goto unrealize;

    }



    xen_device_frontend_create(xendev, &local_err);

    if (local_err) {

        error_propagate(errp, local_err);

    xen_device_frontend_create(xendev, errp);

    if (*errp) {

        goto unrealize;

    }



    if (xendev_class->realize) {

        xendev_class->realize(xendev, &local_err);

        if (local_err) {

            error_propagate(errp, local_err);

        xendev_class->realize(xendev, errp);

        if (*errp) {

            goto unrealize;

        }

    }