Commit 1bc0e405 authored by Peter Maydell's avatar Peter Maydell
Browse files

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



Block pull request

# gpg: Signature made Mon 08 Sep 2014 11:49:31 BST using RSA key ID 81AB73C8
# gpg: Good signature from "Stefan Hajnoczi <stefanha@redhat.com>"
# gpg:                 aka "Stefan Hajnoczi <stefanha@gmail.com>"

* remotes/stefanha/tags/block-pull-request: (24 commits)
  ide: Add resize callback to ide/core
  IDE: Fill the IDENTIFY request consistently
  vmdk: fix buf leak in vmdk_parse_extents()
  vmdk: fix vmdk_parse_extents() extent_file leaks
  ide: Add wwn support to IDE-ATAPI drive
  qtest/ide: Uninitialize PC allocator
  libqos: add a simple first-fit memory allocator
  MAINTAINERS: update sheepdog maintainer
  qemu-nbd: fix indentation and coding style
  qemu-nbd: add option to set detect-zeroes mode
  rename parse_enum_option to qapi_enum_parse and make it public
  block/archipelago: Use QEMU atomic builtins
  qemu-img: fix rebase src_cache option documentation
  qemu-img: clarify src_cache option documentation
  libqos: Added EVENT_IDX support
  libqos: Added MSI-X support
  libqos: Added test case for configuration changes in virtio-blk test
  libqos: Added indirect descriptor support to virtio implementation
  libqos: Added basic virtqueue support to virtio implementation
  tests: Add virtio device initialization
  ...

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents 2d6838e8 01ce352e

MAINTAINERS

+1 −1
Original line number Diff line number Diff line
@@ -980,7 +980,7 @@ S: Supported 
F: block/rbd.c



Sheepdog

M: MORITA Kazutaka <morita.kazutaka@lab.ntt.co.jp>

M: Hitoshi Mitake <mitake.hitoshi@lab.ntt.co.jp>

M: Liu Yuan <namei.unix@gmail.com>

L: sheepdog@lists.wpkg.org

S: Supported

block/archipelago.c

+23 −53
Original line number Diff line number Diff line
@@ -57,6 +57,7 @@ 
#include "qapi/qmp/qint.h"

#include "qapi/qmp/qstring.h"

#include "qapi/qmp/qjson.h"

#include "qemu/atomic.h"



#include <inttypes.h>

#include <xseg/xseg.h>
@@ -214,7 +215,7 @@ static void xseg_request_handler(void *state) 


                xseg_put_request(s->xseg, req, s->srcport);



                if ((__sync_add_and_fetch(&segreq->ref, -1)) == 0) {

                if (atomic_fetch_dec(&segreq->ref) == 1) {

                    if (!segreq->failed) {

                        reqdata->aio_cb->ret = segreq->count;

                        archipelago_finish_aiocb(reqdata);
@@ -233,7 +234,7 @@ static void xseg_request_handler(void *state) 
                segreq->count += req->serviced;

                xseg_put_request(s->xseg, req, s->srcport);



                if ((__sync_add_and_fetch(&segreq->ref, -1)) == 0) {

                if (atomic_fetch_dec(&segreq->ref) == 1) {

                    if (!segreq->failed) {

                        reqdata->aio_cb->ret = segreq->count;

                        archipelago_finish_aiocb(reqdata);
@@ -824,78 +825,47 @@ static int archipelago_aio_segmented_rw(BDRVArchipelagoState *s, 
                                        ArchipelagoAIOCB *aio_cb,

                                        int op)

{

    int i, ret, segments_nr, last_segment_size;

    int ret, segments_nr;

    size_t pos = 0;

    ArchipelagoSegmentedRequest *segreq;



    segreq = g_new(ArchipelagoSegmentedRequest, 1);

    segreq = g_new0(ArchipelagoSegmentedRequest, 1);



    if (op == ARCHIP_OP_FLUSH) {

        segments_nr = 1;

        segreq->ref = segments_nr;

        segreq->total = count;

        segreq->count = 0;

        segreq->failed = 0;

        ret = archipelago_submit_request(s, 0, count, offset, aio_cb,

                                           segreq, ARCHIP_OP_FLUSH);

        if (ret < 0) {

            goto err_exit;

        }

        return 0;

    }



    } else {

        segments_nr = (int)(count / MAX_REQUEST_SIZE) + \

                      ((count % MAX_REQUEST_SIZE) ? 1 : 0);

    last_segment_size = (int)(count % MAX_REQUEST_SIZE);



    segreq->ref = segments_nr;

    }

    segreq->total = count;

    segreq->count = 0;

    segreq->failed = 0;

    atomic_mb_set(&segreq->ref, segments_nr);



    for (i = 0; i < segments_nr - 1; i++) {

        ret = archipelago_submit_request(s, i * MAX_REQUEST_SIZE,

    while (segments_nr > 1) {

        ret = archipelago_submit_request(s, pos,

                                            MAX_REQUEST_SIZE,

                                           offset + i * MAX_REQUEST_SIZE,

                                            offset + pos,

                                            aio_cb, segreq, op);



        if (ret < 0) {

            goto err_exit;

        }

        count -= MAX_REQUEST_SIZE;

        pos += MAX_REQUEST_SIZE;

        segments_nr--;

    }



    if ((segments_nr > 1) && last_segment_size) {

        ret = archipelago_submit_request(s, i * MAX_REQUEST_SIZE,

                                           last_segment_size,

                                           offset + i * MAX_REQUEST_SIZE,

                                           aio_cb, segreq, op);

    } else if ((segments_nr > 1) && !last_segment_size) {

        ret = archipelago_submit_request(s, i * MAX_REQUEST_SIZE,

                                           MAX_REQUEST_SIZE,

                                           offset + i * MAX_REQUEST_SIZE,

    ret = archipelago_submit_request(s, pos, count, offset + pos,

                                     aio_cb, segreq, op);

    } else if (segments_nr == 1) {

            ret = archipelago_submit_request(s, 0, count, offset, aio_cb,

                                               segreq, op);

    }



    if (ret < 0) {

        goto err_exit;

    }



    return 0;



err_exit:

    __sync_add_and_fetch(&segreq->failed, 1);

    if (segments_nr == 1) {

        if (__sync_add_and_fetch(&segreq->ref, -1) == 0) {

    segreq->failed = 1;

    if (atomic_fetch_sub(&segreq->ref, segments_nr) == segments_nr) {

        g_free(segreq);

    }

    } else {

        if ((__sync_add_and_fetch(&segreq->ref, -segments_nr + i)) == 0) {

            g_free(segreq);

        }

    }



    return ret;

}

block/vmdk.c

+3 −1
Original line number Diff line number Diff line
@@ -834,6 +834,7 @@ static int vmdk_parse_extents(const char *desc, BlockDriverState *bs, 
            ret = vmdk_add_extent(bs, extent_file, true, sectors,

                            0, 0, 0, 0, 0, &extent, errp);

            if (ret < 0) {

                bdrv_unref(extent_file);

                return ret;

            }

            extent->flat_start_offset = flat_offset << 9;
@@ -845,14 +846,15 @@ static int vmdk_parse_extents(const char *desc, BlockDriverState *bs, 
            } else {

                ret = vmdk_open_sparse(bs, extent_file, bs->open_flags, buf, errp);

            }

            if (ret) {

            g_free(buf);

            if (ret) {

                bdrv_unref(extent_file);

                return ret;

            }

            extent = &s->extents[s->num_extents - 1];

        } else {

            error_setg(errp, "Unsupported extent type '%s'", type);

            bdrv_unref(extent_file);

            return -ENOTSUP;

        }

        extent->type = g_strdup(type);

blockdev.c

+6 −24
Original line number Diff line number Diff line
@@ -39,6 +39,7 @@ 
#include "qapi/qmp/types.h"

#include "qapi-visit.h"

#include "qapi/qmp-output-visitor.h"

#include "qapi/util.h"

#include "sysemu/sysemu.h"

#include "block/block_int.h"

#include "qmp-commands.h"
@@ -274,25 +275,6 @@ static int parse_block_error_action(const char *buf, bool is_read, Error **errp) 
    }

}



static inline int parse_enum_option(const char *lookup[], const char *buf,

                                    int max, int def, Error **errp)

{

    int i;



    if (!buf) {

        return def;

    }



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

        if (!strcmp(buf, lookup[i])) {

            return i;

        }

    }



    error_setg(errp, "invalid parameter value: %s", buf);

    return def;

}



static bool check_throttle_config(ThrottleConfig *cfg, Error **errp)

{

    if (throttle_conflicting(cfg)) {
@@ -456,7 +438,7 @@ static DriveInfo *blockdev_init(const char *file, QDict *bs_opts, 
    }



    detect_zeroes =

        parse_enum_option(BlockdevDetectZeroesOptions_lookup,

        qapi_enum_parse(BlockdevDetectZeroesOptions_lookup,

                        qemu_opt_get(opts, "detect-zeroes"),

                        BLOCKDEV_DETECT_ZEROES_OPTIONS_MAX,

                        BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF,

hw/block/pflash_cfi01.c

+16 −2
Original line number Diff line number Diff line
@@ -94,10 +94,13 @@ struct pflash_t { 
    void *storage;

};



static int pflash_post_load(void *opaque, int version_id);



static const VMStateDescription vmstate_pflash = {

    .name = "pflash_cfi01",

    .version_id = 1,

    .minimum_version_id = 1,

    .post_load = pflash_post_load,

    .fields = (VMStateField[]) {

        VMSTATE_UINT8(wcycle, pflash_t),

        VMSTATE_UINT8(cmd, pflash_t),
@@ -209,11 +212,11 @@ static uint32_t pflash_devid_query(pflash_t *pfl, hwaddr offset) 
    switch (boff & 0xFF) {

    case 0:

        resp = pfl->ident0;

        DPRINTF("%s: Manufacturer Code %04x\n", __func__, ret);

        DPRINTF("%s: Manufacturer Code %04x\n", __func__, resp);

        break;

    case 1:

        resp = pfl->ident1;

        DPRINTF("%s: Device ID Code %04x\n", __func__, ret);

        DPRINTF("%s: Device ID Code %04x\n", __func__, resp);

        break;

    default:

        DPRINTF("%s: Read Device Information offset=%x\n", __func__,
@@ -982,3 +985,14 @@ MemoryRegion *pflash_cfi01_get_memory(pflash_t *fl) 
{

    return &fl->mem;

}



static int pflash_post_load(void *opaque, int version_id)

{

    pflash_t *pfl = opaque;



    if (!pfl->ro) {

        DPRINTF("%s: updating bdrv for %s\n", __func__, pfl->name);

        pflash_update(pfl, 0, pfl->sector_len * pfl->nb_blocs);

    }

    return 0;

}