Commit 5c7c46fe authored by Peter Maydell's avatar Peter Maydell
Browse files

Merge remote-tracking branch 'remotes/stefanha/tags/block-pull-request' into staging 



Pull request

v2:
 * Fixed stray slirp submodule change [Peter]

Fixes for the lock guard macros, code conversions to the lock guard macros, and
support for selecting fuzzer targets with argv[0].

# gpg: Signature made Mon 04 May 2020 16:11:11 BST
# gpg:                using RSA key 8695A8BFD3F97CDAAC35775A9CA4ABB381AB73C8
# gpg: Good signature from "Stefan Hajnoczi <stefanha@redhat.com>" [full]
# gpg:                 aka "Stefan Hajnoczi <stefanha@gmail.com>" [full]
# Primary key fingerprint: 8695 A8BF D3F9 7CDA AC35  775A 9CA4 ABB3 81AB 73C8

* remotes/stefanha/tags/block-pull-request:
  lockable: Replace locks with lock guard macros
  lockable: replaced locks with lock guard macros where appropriate
  lockable: fix __COUNTER__ macro to be referenced properly
  fuzz: select fuzz target using executable name

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents 5375af3c 08b689aa

block/iscsi.c

+2 −5
Original line number Diff line number Diff line
@@ -1394,20 +1394,17 @@ static void iscsi_nop_timed_event(void *opaque) 
{

    IscsiLun *iscsilun = opaque;



    qemu_mutex_lock(&iscsilun->mutex);

    QEMU_LOCK_GUARD(&iscsilun->mutex);

    if (iscsi_get_nops_in_flight(iscsilun->iscsi) >= MAX_NOP_FAILURES) {

        error_report("iSCSI: NOP timeout. Reconnecting...");

        iscsilun->request_timed_out = true;

    } else if (iscsi_nop_out_async(iscsilun->iscsi, NULL, NULL, 0, NULL) != 0) {

        error_report("iSCSI: failed to sent NOP-Out. Disabling NOP messages.");

        goto out;

        return;

    }



    timer_mod(iscsilun->nop_timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + NOP_INTERVAL);

    iscsi_set_events(iscsilun);



out:

    qemu_mutex_unlock(&iscsilun->mutex);

}



static void iscsi_readcapacity_sync(IscsiLun *iscsilun, Error **errp)

block/nfs.c

+24 −27
Original line number Diff line number Diff line
@@ -273,15 +273,14 @@ static int coroutine_fn nfs_co_preadv(BlockDriverState *bs, uint64_t offset, 
    nfs_co_init_task(bs, &task);

    task.iov = iov;



    qemu_mutex_lock(&client->mutex);

    WITH_QEMU_LOCK_GUARD(&client->mutex) {

        if (nfs_pread_async(client->context, client->fh,

                            offset, bytes, nfs_co_generic_cb, &task) != 0) {

        qemu_mutex_unlock(&client->mutex);

            return -ENOMEM;

        }



        nfs_set_events(client);

    qemu_mutex_unlock(&client->mutex);

    }

    while (!task.complete) {

        qemu_coroutine_yield();

    }
@@ -320,11 +319,10 @@ static int coroutine_fn nfs_co_pwritev(BlockDriverState *bs, uint64_t offset, 
        buf = iov->iov[0].iov_base;

    }



    qemu_mutex_lock(&client->mutex);

    WITH_QEMU_LOCK_GUARD(&client->mutex) {

        if (nfs_pwrite_async(client->context, client->fh,

                             offset, bytes, buf,

                             nfs_co_generic_cb, &task) != 0) {

        qemu_mutex_unlock(&client->mutex);

            if (my_buffer) {

                g_free(buf);

            }
@@ -332,7 +330,7 @@ static int coroutine_fn nfs_co_pwritev(BlockDriverState *bs, uint64_t offset, 
        }



        nfs_set_events(client);

    qemu_mutex_unlock(&client->mutex);

    }

    while (!task.complete) {

        qemu_coroutine_yield();

    }
@@ -355,15 +353,14 @@ static int coroutine_fn nfs_co_flush(BlockDriverState *bs) 


    nfs_co_init_task(bs, &task);



    qemu_mutex_lock(&client->mutex);

    WITH_QEMU_LOCK_GUARD(&client->mutex) {

        if (nfs_fsync_async(client->context, client->fh, nfs_co_generic_cb,

                            &task) != 0) {

        qemu_mutex_unlock(&client->mutex);

            return -ENOMEM;

        }



        nfs_set_events(client);

    qemu_mutex_unlock(&client->mutex);

    }

    while (!task.complete) {

        qemu_coroutine_yield();

    }

cpus-common.c

+5 −9
Original line number Diff line number Diff line
@@ -22,6 +22,7 @@ 
#include "exec/cpu-common.h"

#include "hw/core/cpu.h"

#include "sysemu/cpus.h"

#include "qemu/lockable.h"



static QemuMutex qemu_cpu_list_lock;

static QemuCond exclusive_cond;
@@ -71,7 +72,7 @@ static int cpu_get_free_index(void) 


void cpu_list_add(CPUState *cpu)

{

    qemu_mutex_lock(&qemu_cpu_list_lock);

    QEMU_LOCK_GUARD(&qemu_cpu_list_lock);

    if (cpu->cpu_index == UNASSIGNED_CPU_INDEX) {

        cpu->cpu_index = cpu_get_free_index();

        assert(cpu->cpu_index != UNASSIGNED_CPU_INDEX);
@@ -79,15 +80,13 @@ void cpu_list_add(CPUState *cpu) 
        assert(!cpu_index_auto_assigned);

    }

    QTAILQ_INSERT_TAIL_RCU(&cpus, cpu, node);

    qemu_mutex_unlock(&qemu_cpu_list_lock);

}



void cpu_list_remove(CPUState *cpu)

{

    qemu_mutex_lock(&qemu_cpu_list_lock);

    QEMU_LOCK_GUARD(&qemu_cpu_list_lock);

    if (!QTAILQ_IN_USE(cpu, node)) {

        /* there is nothing to undo since cpu_exec_init() hasn't been called */

        qemu_mutex_unlock(&qemu_cpu_list_lock);

        return;

    }
@@ -95,7 +94,6 @@ void cpu_list_remove(CPUState *cpu) 


    QTAILQ_REMOVE_RCU(&cpus, cpu, node);

    cpu->cpu_index = UNASSIGNED_CPU_INDEX;

    qemu_mutex_unlock(&qemu_cpu_list_lock);

}



struct qemu_work_item {
@@ -237,7 +235,7 @@ void cpu_exec_start(CPUState *cpu) 
     * see cpu->running == true, and it will kick the CPU.

     */

    if (unlikely(atomic_read(&pending_cpus))) {

        qemu_mutex_lock(&qemu_cpu_list_lock);

        QEMU_LOCK_GUARD(&qemu_cpu_list_lock);

        if (!cpu->has_waiter) {

            /* Not counted in pending_cpus, let the exclusive item

             * run.  Since we have the lock, just set cpu->running to true
@@ -252,7 +250,6 @@ void cpu_exec_start(CPUState *cpu) 
             * waiter at cpu_exec_end.

             */

        }

        qemu_mutex_unlock(&qemu_cpu_list_lock);

    }

}
@@ -280,7 +277,7 @@ void cpu_exec_end(CPUState *cpu) 
     * next cpu_exec_start.

     */

    if (unlikely(atomic_read(&pending_cpus))) {

        qemu_mutex_lock(&qemu_cpu_list_lock);

        QEMU_LOCK_GUARD(&qemu_cpu_list_lock);

        if (cpu->has_waiter) {

            cpu->has_waiter = false;

            atomic_set(&pending_cpus, pending_cpus - 1);
@@ -288,7 +285,6 @@ void cpu_exec_end(CPUState *cpu) 
                qemu_cond_signal(&exclusive_cond);

            }

        }

        qemu_mutex_unlock(&qemu_cpu_list_lock);

    }

}

hw/display/qxl.c

+20 −23
Original line number Diff line number Diff line
@@ -478,18 +478,19 @@ static int qxl_track_command(PCIQXLDevice *qxl, struct QXLCommandExt *ext) 
                              cmd->u.surface_create.stride);

            return 1;

        }

        qemu_mutex_lock(&qxl->track_lock);

        WITH_QEMU_LOCK_GUARD(&qxl->track_lock) {

            if (cmd->type == QXL_SURFACE_CMD_CREATE) {

                qxl->guest_surfaces.cmds[id] = ext->cmd.data;

                qxl->guest_surfaces.count++;

            if (qxl->guest_surfaces.max < qxl->guest_surfaces.count)

                if (qxl->guest_surfaces.max < qxl->guest_surfaces.count) {

                    qxl->guest_surfaces.max = qxl->guest_surfaces.count;

                }

            }

            if (cmd->type == QXL_SURFACE_CMD_DESTROY) {

                qxl->guest_surfaces.cmds[id] = 0;

                qxl->guest_surfaces.count--;

            }

        qemu_mutex_unlock(&qxl->track_lock);

        }

        break;

    }

    case QXL_CMD_CURSOR:
@@ -958,10 +959,9 @@ static void interface_update_area_complete(QXLInstance *sin, 
    int i;

    int qxl_i;



    qemu_mutex_lock(&qxl->ssd.lock);

    QEMU_LOCK_GUARD(&qxl->ssd.lock);

    if (surface_id != 0 || !num_updated_rects ||

        !qxl->render_update_cookie_num) {

        qemu_mutex_unlock(&qxl->ssd.lock);

        return;

    }

    trace_qxl_interface_update_area_complete(qxl->id, surface_id, dirty->left,
@@ -980,7 +980,6 @@ static void interface_update_area_complete(QXLInstance *sin, 
         * Don't bother copying or scheduling the bh since we will flip

         * the whole area anyway on completion of the update_area async call

         */

        qemu_mutex_unlock(&qxl->ssd.lock);

        return;

    }

    qxl_i = qxl->num_dirty_rects;
@@ -991,7 +990,6 @@ static void interface_update_area_complete(QXLInstance *sin, 
    trace_qxl_interface_update_area_complete_schedule_bh(qxl->id,

                                                         qxl->num_dirty_rects);

    qemu_bh_schedule(qxl->update_area_bh);

    qemu_mutex_unlock(&qxl->ssd.lock);

}



/* called from spice server thread context only */
@@ -1694,15 +1692,14 @@ static void ioport_write(void *opaque, hwaddr addr, 
    case QXL_IO_MONITORS_CONFIG_ASYNC:

async_common:

        async = QXL_ASYNC;

        qemu_mutex_lock(&d->async_lock);

        WITH_QEMU_LOCK_GUARD(&d->async_lock) {

            if (d->current_async != QXL_UNDEFINED_IO) {

                qxl_set_guest_bug(d, "%d async started before last (%d) complete",

                    io_port, d->current_async);

            qemu_mutex_unlock(&d->async_lock);

                return;

            }

            d->current_async = orig_io_port;

        qemu_mutex_unlock(&d->async_lock);

        }

        break;

    default:

        break;

hw/hyperv/hyperv.c

+7 −8
Original line number Diff line number Diff line
@@ -15,6 +15,7 @@ 
#include "sysemu/kvm.h"

#include "qemu/bitops.h"

#include "qemu/error-report.h"

#include "qemu/lockable.h"

#include "qemu/queue.h"

#include "qemu/rcu.h"

#include "qemu/rcu_queue.h"
@@ -491,7 +492,7 @@ int hyperv_set_msg_handler(uint32_t conn_id, HvMsgHandler handler, void *data) 
    int ret;

    MsgHandler *mh;



    qemu_mutex_lock(&handlers_mutex);

    QEMU_LOCK_GUARD(&handlers_mutex);

    QLIST_FOREACH(mh, &msg_handlers, link) {

        if (mh->conn_id == conn_id) {

            if (handler) {
@@ -501,7 +502,7 @@ int hyperv_set_msg_handler(uint32_t conn_id, HvMsgHandler handler, void *data) 
                g_free_rcu(mh, rcu);

                ret = 0;

            }

            goto unlock;

            return ret;

        }

    }
@@ -515,8 +516,7 @@ int hyperv_set_msg_handler(uint32_t conn_id, HvMsgHandler handler, void *data) 
    } else {

        ret = -ENOENT;

    }

unlock:

    qemu_mutex_unlock(&handlers_mutex);



    return ret;

}
@@ -565,7 +565,7 @@ static int set_event_flag_handler(uint32_t conn_id, EventNotifier *notifier) 
    int ret;

    EventFlagHandler *handler;



    qemu_mutex_lock(&handlers_mutex);

    QEMU_LOCK_GUARD(&handlers_mutex);

    QLIST_FOREACH(handler, &event_flag_handlers, link) {

        if (handler->conn_id == conn_id) {

            if (notifier) {
@@ -575,7 +575,7 @@ static int set_event_flag_handler(uint32_t conn_id, EventNotifier *notifier) 
                g_free_rcu(handler, rcu);

                ret = 0;

            }

            goto unlock;

            return ret;

        }

    }
@@ -588,8 +588,7 @@ static int set_event_flag_handler(uint32_t conn_id, EventNotifier *notifier) 
    } else {

        ret = -ENOENT;

    }

unlock:

    qemu_mutex_unlock(&handlers_mutex);



    return ret;

}