Commit 521db803 authored by Peter Maydell's avatar Peter Maydell
Browse files

Merge remote-tracking branch 'remotes/maxreitz/tags/pull-block-2019-09-16' into staging 



Block patches:
- Fix for block jobs when used with I/O threads
- Fix for a corruption when using qcow2's LUKS encryption mode
- cURL fix
- check-block.sh cleanups (for make check)
- Refactoring

# gpg: Signature made Mon 16 Sep 2019 14:41:15 BST
# gpg:                using RSA key 91BEB60A30DB3E8857D11829F407DB0061D5CF40
# gpg:                issuer "mreitz@redhat.com"
# gpg: Good signature from "Max Reitz <mreitz@redhat.com>" [full]
# Primary key fingerprint: 91BE B60A 30DB 3E88 57D1  1829 F407 DB00 61D5 CF40

* remotes/maxreitz/tags/pull-block-2019-09-16:
  qemu-iotests: Add test for bz #1745922
  block/qcow2: refactor encryption code
  block/qcow2: Fix corruption introduced by commit 8ac0f15f
  blockjob: update nodes head while removing all bdrv
  curl: Check curl_multi_add_handle()'s return code
  curl: Handle success in multi_check_completion
  curl: Report only ready sockets
  curl: Pass CURLSocket to curl_multi_do()
  curl: Check completion in curl_multi_do()
  curl: Keep *socket until the end of curl_sock_cb()
  curl: Keep pointer to the CURLState in CURLSocket
  tests/qemu-iotests: Fix qemu-io related output in 026.out.nocache
  tests/Makefile: Do not print the name of the check-block.sh shell script
  tests/qemu-iotests/check: Replace "tests" with "iotests" in final status text
  block: Remove unused masks
  block: Use QEMU_IS_ALIGNED

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents 6f214b30 1825cc07

block/bochs.c

+2 −2
Original line number Diff line number Diff line
@@ -248,8 +248,8 @@ bochs_co_preadv(BlockDriverState *bs, uint64_t offset, uint64_t bytes, 
    QEMUIOVector local_qiov;

    int ret;



    assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0);

    assert((bytes & (BDRV_SECTOR_SIZE - 1)) == 0);

    assert(QEMU_IS_ALIGNED(offset, BDRV_SECTOR_SIZE));

    assert(QEMU_IS_ALIGNED(bytes, BDRV_SECTOR_SIZE));



    qemu_iovec_init(&local_qiov, qiov->niov);

    qemu_co_mutex_lock(&s->lock);

block/cloop.c

+2 −2
Original line number Diff line number Diff line
@@ -253,8 +253,8 @@ cloop_co_preadv(BlockDriverState *bs, uint64_t offset, uint64_t bytes, 
    int nb_sectors = bytes >> BDRV_SECTOR_BITS;

    int ret, i;



    assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0);

    assert((bytes & (BDRV_SECTOR_SIZE - 1)) == 0);

    assert(QEMU_IS_ALIGNED(offset, BDRV_SECTOR_SIZE));

    assert(QEMU_IS_ALIGNED(bytes, BDRV_SECTOR_SIZE));



    qemu_co_mutex_lock(&s->lock);

block/curl.c

+59 −74
Original line number Diff line number Diff line
@@ -80,6 +80,7 @@ static CURLMcode __curl_multi_socket_action(CURLM *multi_handle, 
#define CURL_BLOCK_OPT_TIMEOUT_DEFAULT 5



struct BDRVCURLState;

struct CURLState;



static bool libcurl_initialized;
@@ -97,6 +98,7 @@ typedef struct CURLAIOCB { 


typedef struct CURLSocket {

    int fd;

    struct CURLState *state;

    QLIST_ENTRY(CURLSocket) next;

} CURLSocket;
@@ -137,7 +139,6 @@ typedef struct BDRVCURLState { 


static void curl_clean_state(CURLState *s);

static void curl_multi_do(void *arg);

static void curl_multi_read(void *arg);



#ifdef NEED_CURL_TIMER_CALLBACK

/* Called from curl_multi_do_locked, with s->mutex held.  */
@@ -170,33 +171,29 @@ static int curl_sock_cb(CURL *curl, curl_socket_t fd, int action, 


    QLIST_FOREACH(socket, &state->sockets, next) {

        if (socket->fd == fd) {

            if (action == CURL_POLL_REMOVE) {

                QLIST_REMOVE(socket, next);

                g_free(socket);

            }

            break;

        }

    }

    if (!socket) {

        socket = g_new0(CURLSocket, 1);

        socket->fd = fd;

        socket->state = state;

        QLIST_INSERT_HEAD(&state->sockets, socket, next);

    }

    socket = NULL;



    trace_curl_sock_cb(action, (int)fd);

    switch (action) {

        case CURL_POLL_IN:

            aio_set_fd_handler(s->aio_context, fd, false,

                               curl_multi_read, NULL, NULL, state);

                               curl_multi_do, NULL, NULL, socket);

            break;

        case CURL_POLL_OUT:

            aio_set_fd_handler(s->aio_context, fd, false,

                               NULL, curl_multi_do, NULL, state);

                               NULL, curl_multi_do, NULL, socket);

            break;

        case CURL_POLL_INOUT:

            aio_set_fd_handler(s->aio_context, fd, false,

                               curl_multi_read, curl_multi_do, NULL, state);

                               curl_multi_do, curl_multi_do, NULL, socket);

            break;

        case CURL_POLL_REMOVE:

            aio_set_fd_handler(s->aio_context, fd, false,
@@ -204,6 +201,11 @@ static int curl_sock_cb(CURL *curl, curl_socket_t fd, int action, 
            break;

    }



    if (action == CURL_POLL_REMOVE) {

        QLIST_REMOVE(socket, next);

        g_free(socket);

    }



    return 0;

}
@@ -227,7 +229,6 @@ static size_t curl_read_cb(void *ptr, size_t size, size_t nmemb, void *opaque) 
{

    CURLState *s = ((CURLState*)opaque);

    size_t realsize = size * nmemb;

    int i;



    trace_curl_read_cb(realsize);
@@ -243,32 +244,6 @@ static size_t curl_read_cb(void *ptr, size_t size, size_t nmemb, void *opaque) 
    memcpy(s->orig_buf + s->buf_off, ptr, realsize);

    s->buf_off += realsize;



    for(i=0; i<CURL_NUM_ACB; i++) {

        CURLAIOCB *acb = s->acb[i];



        if (!acb)

            continue;



        if ((s->buf_off >= acb->end)) {

            size_t request_length = acb->bytes;



            qemu_iovec_from_buf(acb->qiov, 0, s->orig_buf + acb->start,

                                acb->end - acb->start);



            if (acb->end - acb->start < request_length) {

                size_t offset = acb->end - acb->start;

                qemu_iovec_memset(acb->qiov, offset, 0,

                                  request_length - offset);

            }



            acb->ret = 0;

            s->acb[i] = NULL;

            qemu_mutex_unlock(&s->s->mutex);

            aio_co_wake(acb->co);

            qemu_mutex_lock(&s->s->mutex);

        }

    }



read_end:

    /* curl will error out if we do not return this value */

    return size * nmemb;
@@ -349,13 +324,14 @@ static void curl_multi_check_completion(BDRVCURLState *s) 
            break;



        if (msg->msg == CURLMSG_DONE) {

            int i;

            CURLState *state = NULL;

            bool error = msg->data.result != CURLE_OK;



            curl_easy_getinfo(msg->easy_handle, CURLINFO_PRIVATE,

                              (char **)&state);



            /* ACBs for successful messages get completed in curl_read_cb */

            if (msg->data.result != CURLE_OK) {

                int i;

            if (error) {

                static int errcount = 100;



                /* Don't lose the original error message from curl, since
@@ -367,6 +343,7 @@ static void curl_multi_check_completion(BDRVCURLState *s) 
                        error_report("curl: further errors suppressed");

                    }

                }

            }



            for (i = 0; i < CURL_NUM_ACB; i++) {

                CURLAIOCB *acb = state->acb[i];
@@ -375,13 +352,27 @@ static void curl_multi_check_completion(BDRVCURLState *s) 
                    continue;

                }



                    acb->ret = -EIO;

                if (!error) {

                    /* Assert that we have read all data */

                    assert(state->buf_off >= acb->end);



                    qemu_iovec_from_buf(acb->qiov, 0,

                                        state->orig_buf + acb->start,

                                        acb->end - acb->start);



                    if (acb->end - acb->start < acb->bytes) {

                        size_t offset = acb->end - acb->start;

                        qemu_iovec_memset(acb->qiov, offset, 0,

                                          acb->bytes - offset);

                    }

                }



                acb->ret = error ? -EIO : 0;

                state->acb[i] = NULL;

                qemu_mutex_unlock(&s->mutex);

                aio_co_wake(acb->co);

                qemu_mutex_lock(&s->mutex);

            }

            }



            curl_clean_state(state);

            break;
@@ -390,42 +381,30 @@ static void curl_multi_check_completion(BDRVCURLState *s) 
}



/* Called with s->mutex held.  */

static void curl_multi_do_locked(CURLState *s)

static void curl_multi_do_locked(CURLSocket *socket)

{

    CURLSocket *socket, *next_socket;

    BDRVCURLState *s = socket->state->s;

    int running;

    int r;



    if (!s->s->multi) {

    if (!s->multi) {

        return;

    }



    /* Need to use _SAFE because curl_multi_socket_action() may trigger

     * curl_sock_cb() which might modify this list */

    QLIST_FOREACH_SAFE(socket, &s->sockets, next, next_socket) {

    do {

            r = curl_multi_socket_action(s->s->multi, socket->fd, 0, &running);

        r = curl_multi_socket_action(s->multi, socket->fd, 0, &running);

    } while (r == CURLM_CALL_MULTI_PERFORM);

}

}



static void curl_multi_do(void *arg)

{

    CURLState *s = (CURLState *)arg;



    qemu_mutex_lock(&s->s->mutex);

    curl_multi_do_locked(s);

    qemu_mutex_unlock(&s->s->mutex);

}

    CURLSocket *socket = arg;

    BDRVCURLState *s = socket->state->s;



static void curl_multi_read(void *arg)

{

    CURLState *s = (CURLState *)arg;



    qemu_mutex_lock(&s->s->mutex);

    curl_multi_do_locked(s);

    curl_multi_check_completion(s->s);

    qemu_mutex_unlock(&s->s->mutex);

    qemu_mutex_lock(&s->mutex);

    curl_multi_do_locked(socket);

    curl_multi_check_completion(s);

    qemu_mutex_unlock(&s->mutex);

}



static void curl_multi_timeout_do(void *arg)
@@ -903,7 +882,13 @@ static void curl_setup_preadv(BlockDriverState *bs, CURLAIOCB *acb) 
    trace_curl_setup_preadv(acb->bytes, start, state->range);

    curl_easy_setopt(state->curl, CURLOPT_RANGE, state->range);



    curl_multi_add_handle(s->multi, state->curl);

    if (curl_multi_add_handle(s->multi, state->curl) != CURLM_OK) {

        state->acb[0] = NULL;

        acb->ret = -EIO;



        curl_clean_state(state);

        goto out;

    }



    /* Tell curl it needs to kick things off */

    curl_multi_socket_action(s->multi, CURL_SOCKET_TIMEOUT, 0, &running);

block/dmg.c

+2 −2
Original line number Diff line number Diff line
@@ -697,8 +697,8 @@ dmg_co_preadv(BlockDriverState *bs, uint64_t offset, uint64_t bytes, 
    int nb_sectors = bytes >> BDRV_SECTOR_BITS;

    int ret, i;



    assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0);

    assert((bytes & (BDRV_SECTOR_SIZE - 1)) == 0);

    assert(QEMU_IS_ALIGNED(offset, BDRV_SECTOR_SIZE));

    assert(QEMU_IS_ALIGNED(bytes, BDRV_SECTOR_SIZE));



    qemu_co_mutex_lock(&s->lock);

block/io.c

+4 −4
Original line number Diff line number Diff line
@@ -1097,8 +1097,8 @@ static int coroutine_fn bdrv_driver_preadv(BlockDriverState *bs, 
    sector_num = offset >> BDRV_SECTOR_BITS;

    nb_sectors = bytes >> BDRV_SECTOR_BITS;



    assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0);

    assert((bytes & (BDRV_SECTOR_SIZE - 1)) == 0);

    assert(QEMU_IS_ALIGNED(offset, BDRV_SECTOR_SIZE));

    assert(QEMU_IS_ALIGNED(bytes, BDRV_SECTOR_SIZE));

    assert(bytes <= BDRV_REQUEST_MAX_BYTES);

    assert(drv->bdrv_co_readv);
@@ -1171,8 +1171,8 @@ static int coroutine_fn bdrv_driver_pwritev(BlockDriverState *bs, 
    sector_num = offset >> BDRV_SECTOR_BITS;

    nb_sectors = bytes >> BDRV_SECTOR_BITS;



    assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0);

    assert((bytes & (BDRV_SECTOR_SIZE - 1)) == 0);

    assert(QEMU_IS_ALIGNED(offset, BDRV_SECTOR_SIZE));

    assert(QEMU_IS_ALIGNED(bytes, BDRV_SECTOR_SIZE));

    assert(bytes <= BDRV_REQUEST_MAX_BYTES);



    assert(drv->bdrv_co_writev);