The following changes since commit d992f2f1368ceb92e6bfd8efece174110f4236ff:

Merge remote-tracking branch 'remotes/artyom/tags/pull-sun4v-20170226' into staging (2017-02-26 22:40:23 +0000)

git://github.com/stefanha/qemu.git tags/block-pull-request

for you to fetch changes up to 1ab17f9f5c63c2798d707aeb22588e4fcc17b2cd:

tests-aio-multithread: use atomic_read properly (2017-02-27 14:00:53 +0000)

Paolo Bonzini (4):

curl: do not use aio_context_acquire/release

nfs: do not use aio_context_acquire/release

iscsi: do not use aio_context_acquire/release

tests-aio-multithread: use atomic_read properly

block/curl.c | 24 ++++++++-----

block/iscsi.c | 83 ++++++++++++++++++++++++++++++++++----------

block/nfs.c | 23 +++++++++---

tests/test-aio-multithread.c | 4 +--

4 files changed, 100 insertions(+), 34 deletions(-)

From: Paolo Bonzini <pbonzini@redhat.com>

Now that all bottom halves and callbacks take care of taking the

AioContext lock, we can migrate some users away from it and to a

specific QemuMutex or CoMutex.

Protect libnfs calls with a QemuMutex. Callbacks are invoked

using bottom halves, so we don't even have to drop it around

callback invocations.

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>

Message-id: 20170222180725.28611-3-pbonzini@redhat.com

block/nfs.c | 23 +++++++++++++++++++----

1 file changed, 19 insertions(+), 4 deletions(-)

diff --git a/block/nfs.c b/block/nfs.c

--- a/block/nfs.c

+++ b/block/nfs.c

@@ -XXX,XX +XXX,XX @@ typedef struct NFSClient {

int events;

bool has_zero_init;

AioContext *aio_context;

+ QemuMutex mutex;

blkcnt_t st_blocks;

bool cache_used;

NFSServer *server;

@@ -XXX,XX +XXX,XX @@ static void nfs_parse_filename(const char *filename, QDict *options,

static void nfs_process_read(void *arg);

static void nfs_process_write(void *arg);

+/* Called with QemuMutex held. */

static void nfs_set_events(NFSClient *client)

{

int ev = nfs_which_events(client->context);

@@ -XXX,XX +XXX,XX @@ static void nfs_process_read(void *arg)

{

NFSClient *client = arg;

- aio_context_acquire(client->aio_context);

+ qemu_mutex_lock(&client->mutex);

nfs_service(client->context, POLLIN);

nfs_set_events(client);

- aio_context_release(client->aio_context);

+ qemu_mutex_unlock(&client->mutex);

static void nfs_process_write(void *arg)

NFSClient *client = arg;

- aio_context_acquire(client->aio_context);

+ qemu_mutex_lock(&client->mutex);

nfs_service(client->context, POLLOUT);

nfs_set_events(client);

- aio_context_release(client->aio_context);

+ qemu_mutex_unlock(&client->mutex);

}

static void nfs_co_init_task(BlockDriverState *bs, NFSRPC *task)

@@ -XXX,XX +XXX,XX @@ static void nfs_co_generic_bh_cb(void *opaque)

aio_co_wake(task->co);

}

+/* Called (via nfs_service) with QemuMutex held. */

static void

nfs_co_generic_cb(int ret, struct nfs_context *nfs, void *data,

void *private_data)

@@ -XXX,XX +XXX,XX @@ 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);

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();

}

@@ -XXX,XX +XXX,XX @@ static int coroutine_fn nfs_co_pwritev(BlockDriverState *bs, uint64_t offset,

buf = iov->iov[0].iov_base;

}

+ qemu_mutex_lock(&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);

}

@@ -XXX,XX +XXX,XX @@ 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();

}

@@ -XXX,XX +XXX,XX @@ static int coroutine_fn nfs_co_flush(BlockDriverState *bs)

nfs_co_init_task(bs, &task);

+ qemu_mutex_lock(&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();

}

@@ -XXX,XX +XXX,XX @@ static void nfs_file_close(BlockDriverState *bs)

{

NFSClient *client = bs->opaque;

nfs_client_close(client);

+ qemu_mutex_destroy(&client->mutex);

}

static NFSServer *nfs_config(QDict *options, Error **errp)

@@ -XXX,XX +XXX,XX @@ static int nfs_file_open(BlockDriverState *bs, QDict *options, int flags,

if (ret < 0) {

return ret;

}

+ qemu_mutex_init(&client->mutex);

bs->total_sectors = ret;

ret = 0;

return ret;

@@ -XXX,XX +XXX,XX @@ static int nfs_has_zero_init(BlockDriverState *bs)

return client->has_zero_init;

}

+/* Called (via nfs_service) with QemuMutex held. */

static void

nfs_get_allocated_file_size_cb(int ret, struct nfs_context *nfs, void *data,

void *private_data)

From: Paolo Bonzini <pbonzini@redhat.com>

Now that all bottom halves and callbacks take care of taking the

AioContext lock, we can migrate some users away from it and to a

specific QemuMutex or CoMutex.

Protect libiscsi calls with a QemuMutex. Callbacks are invoked

using bottom halves, so we don't even have to drop it around

callback invocations.

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>

Message-id: 20170222180725.28611-4-pbonzini@redhat.com

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>

---

block/iscsi.c | 83 +++++++++++++++++++++++++++++++++++++++++++++--------------

1 file changed, 64 insertions(+), 19 deletions(-)

diff --git a/block/iscsi.c b/block/iscsi.c

index XXXXXXX..XXXXXXX 100644

--- a/block/iscsi.c

+++ b/block/iscsi.c

@@ -XXX,XX +XXX,XX @@ typedef struct IscsiLun {

int events;

QEMUTimer *nop_timer;

QEMUTimer *event_timer;

+ QemuMutex mutex;

struct scsi_inquiry_logical_block_provisioning lbp;

struct scsi_inquiry_block_limits bl;

unsigned char *zeroblock;

@@ -XXX,XX +XXX,XX @@ static int iscsi_translate_sense(struct scsi_sense *sense)

return ret;

}

+/* Called (via iscsi_service) with QemuMutex held. */

static void

iscsi_co_generic_cb(struct iscsi_context *iscsi, int status,

void *command_data, void *opaque)

@@ -XXX,XX +XXX,XX @@ static const AIOCBInfo iscsi_aiocb_info = {

static void iscsi_process_read(void *arg);

static void iscsi_process_write(void *arg);

+/* Called with QemuMutex held. */

static void

iscsi_set_events(IscsiLun *iscsilun)

{

@@ -XXX,XX +XXX,XX @@ iscsi_process_read(void *arg)

IscsiLun *iscsilun = arg;

struct iscsi_context *iscsi = iscsilun->iscsi;

- aio_context_acquire(iscsilun->aio_context);

+ qemu_mutex_lock(&iscsilun->mutex);

iscsi_service(iscsi, POLLIN);

iscsi_set_events(iscsilun);

- aio_context_release(iscsilun->aio_context);

+ qemu_mutex_unlock(&iscsilun->mutex);

}

static void

@@ -XXX,XX +XXX,XX @@ iscsi_process_write(void *arg)

IscsiLun *iscsilun = arg;

struct iscsi_context *iscsi = iscsilun->iscsi;

- aio_context_acquire(iscsilun->aio_context);

+ qemu_mutex_lock(&iscsilun->mutex);

iscsi_service(iscsi, POLLOUT);

iscsi_set_events(iscsilun);

- aio_context_release(iscsilun->aio_context);

+ qemu_mutex_unlock(&iscsilun->mutex);

}

static int64_t sector_lun2qemu(int64_t sector, IscsiLun *iscsilun)

@@ -XXX,XX +XXX,XX @@ iscsi_co_writev_flags(BlockDriverState *bs, int64_t sector_num, int nb_sectors,

uint64_t lba;

uint32_t num_sectors;

bool fua = flags & BDRV_REQ_FUA;

+ int r = 0;

if (fua) {

assert(iscsilun->dpofua);

@@ -XXX,XX +XXX,XX @@ iscsi_co_writev_flags(BlockDriverState *bs, int64_t sector_num, int nb_sectors,

lba = sector_qemu2lun(sector_num, iscsilun);

num_sectors = sector_qemu2lun(nb_sectors, iscsilun);

iscsi_co_init_iscsitask(iscsilun, &iTask);

+ qemu_mutex_lock(&iscsilun->mutex);

retry:

if (iscsilun->use_16_for_rw) {

#if LIBISCSI_API_VERSION >= (20160603)

@@ -XXX,XX +XXX,XX @@ retry:

#endif

while (!iTask.complete) {

iscsi_set_events(iscsilun);

+ qemu_mutex_unlock(&iscsilun->mutex);

qemu_coroutine_yield();

+ qemu_mutex_lock(&iscsilun->mutex);

}

if (iTask.task != NULL) {

@@ -XXX,XX +XXX,XX @@ retry:

if (iTask.status != SCSI_STATUS_GOOD) {

iscsi_allocmap_set_invalid(iscsilun, sector_num, nb_sectors);

- return iTask.err_code;

+ r = iTask.err_code;

+ goto out_unlock;

}

iscsi_allocmap_set_allocated(iscsilun, sector_num, nb_sectors);

- return 0;

+out_unlock:

+ qemu_mutex_unlock(&iscsilun->mutex);

+ return r;

}

@@ -XXX,XX +XXX,XX @@ static int64_t coroutine_fn iscsi_co_get_block_status(BlockDriverState *bs,

goto out;

}

+ qemu_mutex_lock(&iscsilun->mutex);

retry:

if (iscsi_get_lba_status_task(iscsilun->iscsi, iscsilun->lun,

sector_qemu2lun(sector_num, iscsilun),

8 + 16, iscsi_co_generic_cb,

&iTask) == NULL) {

ret = -ENOMEM;

- goto out;

+ goto out_unlock;

}

while (!iTask.complete) {

iscsi_set_events(iscsilun);

+ qemu_mutex_unlock(&iscsilun->mutex);

qemu_coroutine_yield();

+ qemu_mutex_lock(&iscsilun->mutex);

}

if (iTask.do_retry) {

@@ -XXX,XX +XXX,XX @@ retry:

* because the device is busy or the cmd is not

* supported) we pretend all blocks are allocated

* for backwards compatibility */

- goto out;

+ goto out_unlock;

}

lbas = scsi_datain_unmarshall(iTask.task);

if (lbas == NULL) {

ret = -EIO;

- goto out;

+ goto out_unlock;

}

lbasd = &lbas->descriptors[0];

if (sector_qemu2lun(sector_num, iscsilun) != lbasd->lba) {

ret = -EIO;

- goto out;

+ goto out_unlock;

}

*pnum = sector_lun2qemu(lbasd->num_blocks, iscsilun);

@@ -XXX,XX +XXX,XX @@ retry:

if (*pnum > nb_sectors) {

*pnum = nb_sectors;

}

+out_unlock:

+ qemu_mutex_unlock(&iscsilun->mutex);

out:

if (iTask.task != NULL) {

scsi_free_scsi_task(iTask.task);

@@ -XXX,XX +XXX,XX @@ static int coroutine_fn iscsi_co_readv(BlockDriverState *bs,

num_sectors = sector_qemu2lun(nb_sectors, iscsilun);

iscsi_co_init_iscsitask(iscsilun, &iTask);

+ qemu_mutex_lock(&iscsilun->mutex);

retry:

if (iscsilun->use_16_for_rw) {

#if LIBISCSI_API_VERSION >= (20160603)

@@ -XXX,XX +XXX,XX @@ retry:

#endif

while (!iTask.complete) {

iscsi_set_events(iscsilun);

+ qemu_mutex_unlock(&iscsilun->mutex);

qemu_coroutine_yield();

+ qemu_mutex_lock(&iscsilun->mutex);

}

if (iTask.task != NULL) {

@@ -XXX,XX +XXX,XX @@ retry:

iTask.complete = 0;

goto retry;

}

+ qemu_mutex_unlock(&iscsilun->mutex);

if (iTask.status != SCSI_STATUS_GOOD) {

return iTask.err_code;

@@ -XXX,XX +XXX,XX @@ static int coroutine_fn iscsi_co_flush(BlockDriverState *bs)

struct IscsiTask iTask;

iscsi_co_init_iscsitask(iscsilun, &iTask);

+ qemu_mutex_lock(&iscsilun->mutex);

retry:

if (iscsi_synchronizecache10_task(iscsilun->iscsi, iscsilun->lun, 0, 0, 0,

0, iscsi_co_generic_cb, &iTask) == NULL) {

@@ -XXX,XX +XXX,XX @@ retry:

while (!iTask.complete) {

iscsi_set_events(iscsilun);

+ qemu_mutex_unlock(&iscsilun->mutex);

qemu_coroutine_yield();

+ qemu_mutex_lock(&iscsilun->mutex);

}

if (iTask.task != NULL) {

@@ -XXX,XX +XXX,XX @@ retry:

iTask.complete = 0;

goto retry;

}

+ qemu_mutex_unlock(&iscsilun->mutex);

if (iTask.status != SCSI_STATUS_GOOD) {

return iTask.err_code;

@@ -XXX,XX +XXX,XX @@ retry:

}

#ifdef __linux__

+/* Called (via iscsi_service) with QemuMutex held. */

static void

iscsi_aio_ioctl_cb(struct iscsi_context *iscsi, int status,

void *command_data, void *opaque)

@@ -XXX,XX +XXX,XX @@ static BlockAIOCB *iscsi_aio_ioctl(BlockDriverState *bs,

acb->task->expxferlen = acb->ioh->dxfer_len;

data.size = 0;

+ qemu_mutex_lock(&iscsilun->mutex);

if (acb->task->xfer_dir == SCSI_XFER_WRITE) {

if (acb->ioh->iovec_count == 0) {

data.data = acb->ioh->dxferp;

@@ -XXX,XX +XXX,XX @@ static BlockAIOCB *iscsi_aio_ioctl(BlockDriverState *bs,

iscsi_aio_ioctl_cb,

(data.size > 0) ? &data : NULL,

acb) != 0) {

+ qemu_mutex_unlock(&iscsilun->mutex);

scsi_free_scsi_task(acb->task);

qemu_aio_unref(acb);

return NULL;

@@ -XXX,XX +XXX,XX @@ static BlockAIOCB *iscsi_aio_ioctl(BlockDriverState *bs,

}

iscsi_set_events(iscsilun);

+ qemu_mutex_unlock(&iscsilun->mutex);

return &acb->common;

}

@@ -XXX,XX +XXX,XX @@ coroutine_fn iscsi_co_pdiscard(BlockDriverState *bs, int64_t offset, int count)

IscsiLun *iscsilun = bs->opaque;

struct IscsiTask iTask;

struct unmap_list list;

+ int r = 0;

if (!is_byte_request_lun_aligned(offset, count, iscsilun)) {

return -ENOTSUP;

@@ -XXX,XX +XXX,XX @@ coroutine_fn iscsi_co_pdiscard(BlockDriverState *bs, int64_t offset, int count)

list.num = count / iscsilun->block_size;

iscsi_co_init_iscsitask(iscsilun, &iTask);

+ qemu_mutex_lock(&iscsilun->mutex);

retry:

if (iscsi_unmap_task(iscsilun->iscsi, iscsilun->lun, 0, 0, &list, 1,

iscsi_co_generic_cb, &iTask) == NULL) {

- return -ENOMEM;

+ r = -ENOMEM;

+ goto out_unlock;

}

while (!iTask.complete) {

iscsi_set_events(iscsilun);

+ qemu_mutex_unlock(&iscsilun->mutex);

qemu_coroutine_yield();

+ qemu_mutex_lock(&iscsilun->mutex);

}

if (iTask.task != NULL) {

@@ -XXX,XX +XXX,XX @@ retry:

/* the target might fail with a check condition if it

is not happy with the alignment of the UNMAP request

we silently fail in this case */

- return 0;

+ goto out_unlock;

}

if (iTask.status != SCSI_STATUS_GOOD) {

- return iTask.err_code;

+ r = iTask.err_code;

+ goto out_unlock;

}

iscsi_allocmap_set_invalid(iscsilun, offset >> BDRV_SECTOR_BITS,

count >> BDRV_SECTOR_BITS);

- return 0;

+out_unlock:

+ qemu_mutex_unlock(&iscsilun->mutex);

+ return r;

}

static int

@@ -XXX,XX +XXX,XX @@ coroutine_fn iscsi_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset,

uint64_t lba;

uint32_t nb_blocks;

bool use_16_for_ws = iscsilun->use_16_for_rw;

+ int r = 0;

if (!is_byte_request_lun_aligned(offset, count, iscsilun)) {

return -ENOTSUP;

@@ -XXX,XX +XXX,XX @@ coroutine_fn iscsi_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset,

}

}

+ qemu_mutex_lock(&iscsilun->mutex);

iscsi_co_init_iscsitask(iscsilun, &iTask);

retry:

if (use_16_for_ws) {

@@ -XXX,XX +XXX,XX @@ retry:

while (!iTask.complete) {

iscsi_set_events(iscsilun);

+ qemu_mutex_unlock(&iscsilun->mutex);

qemu_coroutine_yield();

+ qemu_mutex_lock(&iscsilun->mutex);

}

if (iTask.status == SCSI_STATUS_CHECK_CONDITION &&

@@ -XXX,XX +XXX,XX @@ retry:

/* WRITE SAME is not supported by the target */

iscsilun->has_write_same = false;

scsi_free_scsi_task(iTask.task);

- return -ENOTSUP;

+ r = -ENOTSUP;

+ goto out_unlock;

}

if (iTask.task != NULL) {

@@ -XXX,XX +XXX,XX @@ retry:

if (iTask.status != SCSI_STATUS_GOOD) {

iscsi_allocmap_set_invalid(iscsilun, offset >> BDRV_SECTOR_BITS,

count >> BDRV_SECTOR_BITS);

- return iTask.err_code;

+ r = iTask.err_code;

+ goto out_unlock;

}

if (flags & BDRV_REQ_MAY_UNMAP) {

@@ -XXX,XX +XXX,XX @@ retry:

count >> BDRV_SECTOR_BITS);

}

- return 0;

+out_unlock:

+ qemu_mutex_unlock(&iscsilun->mutex);

+ return r;

}

static void apply_chap(struct iscsi_context *iscsi, QemuOpts *opts,

@@ -XXX,XX +XXX,XX @@ static void iscsi_nop_timed_event(void *opaque)

{

IscsiLun *iscsilun = opaque;

- aio_context_acquire(iscsilun->aio_context);

+ qemu_mutex_lock(&iscsilun->mutex);

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

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

iscsilun->request_timed_out = true;

@@ -XXX,XX +XXX,XX @@ static void iscsi_nop_timed_event(void *opaque)

iscsi_set_events(iscsilun);

out:

- aio_context_release(iscsilun->aio_context);

+ qemu_mutex_unlock(&iscsilun->mutex);

}

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

@@ -XXX,XX +XXX,XX @@ static int iscsi_open(BlockDriverState *bs, QDict *options, int flags,

scsi_free_scsi_task(task);

task = NULL;

+ qemu_mutex_init(&iscsilun->mutex);

iscsi_attach_aio_context(bs, iscsilun->aio_context);

/* Guess the internal cluster (page) size of the iscsi target by the means

@@ -XXX,XX +XXX,XX @@ static void iscsi_close(BlockDriverState *bs)

iscsi_destroy_context(iscsi);

g_free(iscsilun->zeroblock);

iscsi_allocmap_free(iscsilun);

+ qemu_mutex_destroy(&iscsilun->mutex);

memset(iscsilun, 0, sizeof(IscsiLun));

}

--

2.9.3