Archipelago » qemu

/*

 * QEMU System Emulator block driver

 *

 * Copyright (c) 2003 Fabrice Bellard

 *

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to deal

 * in the Software without restriction, including without limitation the rights

 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

 * copies of the Software, and to permit persons to whom the Software is

 * furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included in

 * all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

 * THE SOFTWARE.

 */

#include "config-host.h"

#include "qemu-common.h"

#include "trace.h"

#include "monitor.h"

#include "block_int.h"

#include "module.h"

#include "qjson.h"

#include "qemu-coroutine.h"

#include "qmp-commands.h"

#include "qemu-timer.h"

#ifdef CONFIG_BSD

#include <sys/types.h>

#include <sys/stat.h>

#include <sys/ioctl.h>

#include <sys/queue.h>

#ifndef __DragonFly__

#include <sys/disk.h>

#endif

#endif

#ifdef _WIN32

#include <windows.h>

#endif

#define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */

typedef enum {

    BDRV_REQ_COPY_ON_READ = 0x1,

    BDRV_REQ_ZERO_WRITE   = 0x2,

} BdrvRequestFlags;

static void bdrv_dev_change_media_cb(BlockDriverState *bs, bool load);

static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,

        int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,

        BlockDriverCompletionFunc *cb, void *opaque);

static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,

        int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,

        BlockDriverCompletionFunc *cb, void *opaque);

static int coroutine_fn bdrv_co_readv_em(BlockDriverState *bs,

                                         int64_t sector_num, int nb_sectors,

                                         QEMUIOVector *iov);

static int coroutine_fn bdrv_co_writev_em(BlockDriverState *bs,

                                         int64_t sector_num, int nb_sectors,

                                         QEMUIOVector *iov);

static int coroutine_fn bdrv_co_do_readv(BlockDriverState *bs,

    int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,

    BdrvRequestFlags flags);

static int coroutine_fn bdrv_co_do_writev(BlockDriverState *bs,

    int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,

    BdrvRequestFlags flags);

static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs,

                                               int64_t sector_num,

                                               QEMUIOVector *qiov,

                                               int nb_sectors,

                                               BlockDriverCompletionFunc *cb,

                                               void *opaque,

                                               bool is_write);

static void coroutine_fn bdrv_co_do_rw(void *opaque);

static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs,

    int64_t sector_num, int nb_sectors);

static bool bdrv_exceed_bps_limits(BlockDriverState *bs, int nb_sectors,

        bool is_write, double elapsed_time, uint64_t *wait);

static bool bdrv_exceed_iops_limits(BlockDriverState *bs, bool is_write,

        double elapsed_time, uint64_t *wait);

static bool bdrv_exceed_io_limits(BlockDriverState *bs, int nb_sectors,

        bool is_write, int64_t *wait);

static QTAILQ_HEAD(, BlockDriverState) bdrv_states =

    QTAILQ_HEAD_INITIALIZER(bdrv_states);

static QLIST_HEAD(, BlockDriver) bdrv_drivers =

    QLIST_HEAD_INITIALIZER(bdrv_drivers);

/* The device to use for VM snapshots */

static BlockDriverState *bs_snapshots;

/* If non-zero, use only whitelisted block drivers */

static int use_bdrv_whitelist;

#ifdef _WIN32

static int is_windows_drive_prefix(const char *filename)

{

    return (((filename[0] >= 'a' && filename[0] <= 'z') ||

             (filename[0] >= 'A' && filename[0] <= 'Z')) &&

            filename[1] == ':');

}

int is_windows_drive(const char *filename)

{

    if (is_windows_drive_prefix(filename) &&

        filename[2] == '\0')

        return 1;

    if (strstart(filename, "\\\\.\\", NULL) ||

        strstart(filename, "//./", NULL))

        return 1;

    return 0;

}

#endif

/* throttling disk I/O limits */

void bdrv_io_limits_disable(BlockDriverState *bs)

{

    bs->io_limits_enabled = false;

    while (qemu_co_queue_next(&bs->throttled_reqs));

    if (bs->block_timer) {

        qemu_del_timer(bs->block_timer);

        qemu_free_timer(bs->block_timer);

        bs->block_timer = NULL;

    }

    bs->slice_start = 0;

    bs->slice_end   = 0;

    bs->slice_time  = 0;

    memset(&bs->io_base, 0, sizeof(bs->io_base));

}

static void bdrv_block_timer(void *opaque)

{

    BlockDriverState *bs = opaque;

    qemu_co_queue_next(&bs->throttled_reqs);

}

void bdrv_io_limits_enable(BlockDriverState *bs)

{

    qemu_co_queue_init(&bs->throttled_reqs);

    bs->block_timer = qemu_new_timer_ns(vm_clock, bdrv_block_timer, bs);

    bs->slice_time  = 5 * BLOCK_IO_SLICE_TIME;

    bs->slice_start = qemu_get_clock_ns(vm_clock);

    bs->slice_end   = bs->slice_start + bs->slice_time;

    memset(&bs->io_base, 0, sizeof(bs->io_base));

    bs->io_limits_enabled = true;

}

bool bdrv_io_limits_enabled(BlockDriverState *bs)

{

    BlockIOLimit *io_limits = &bs->io_limits;

    return io_limits->bps[BLOCK_IO_LIMIT_READ]

         || io_limits->bps[BLOCK_IO_LIMIT_WRITE]

         || io_limits->bps[BLOCK_IO_LIMIT_TOTAL]

         || io_limits->iops[BLOCK_IO_LIMIT_READ]

         || io_limits->iops[BLOCK_IO_LIMIT_WRITE]

         || io_limits->iops[BLOCK_IO_LIMIT_TOTAL];

}

static void bdrv_io_limits_intercept(BlockDriverState *bs,

                                     bool is_write, int nb_sectors)

{

    int64_t wait_time = -1;

    if (!qemu_co_queue_empty(&bs->throttled_reqs)) {

        qemu_co_queue_wait(&bs->throttled_reqs);

    }

    /* In fact, we hope to keep each request's timing, in FIFO mode. The next

     * throttled requests will not be dequeued until the current request is

     * allowed to be serviced. So if the current request still exceeds the

     * limits, it will be inserted to the head. All requests followed it will

     * be still in throttled_reqs queue.

     */

    while (bdrv_exceed_io_limits(bs, nb_sectors, is_write, &wait_time)) {

        qemu_mod_timer(bs->block_timer,

                       wait_time + qemu_get_clock_ns(vm_clock));

        qemu_co_queue_wait_insert_head(&bs->throttled_reqs);

    }

    qemu_co_queue_next(&bs->throttled_reqs);

}

/* check if the path starts with "<protocol>:" */

static int path_has_protocol(const char *path)

{

    const char *p;

#ifdef _WIN32

    if (is_windows_drive(path) ||

        is_windows_drive_prefix(path)) {

        return 0;

    }

    p = path + strcspn(path, ":/\\");

#else

    p = path + strcspn(path, ":/");

#endif

    return *p == ':';

}

int path_is_absolute(const char *path)

{

#ifdef _WIN32

    /* specific case for names like: "\\.\d:" */

    if (is_windows_drive(path) || is_windows_drive_prefix(path)) {

        return 1;

    }

    return (*path == '/' || *path == '\\');

#else

    return (*path == '/');

#endif

}

/* if filename is absolute, just copy it to dest. Otherwise, build a

   path to it by considering it is relative to base_path. URL are

   supported. */

void path_combine(char *dest, int dest_size,

                  const char *base_path,

                  const char *filename)

{

    const char *p, *p1;

    int len;

    if (dest_size <= 0)

        return;

    if (path_is_absolute(filename)) {

        pstrcpy(dest, dest_size, filename);

    } else {

        p = strchr(base_path, ':');

        if (p)

            p++;

        else

            p = base_path;

        p1 = strrchr(base_path, '/');

#ifdef _WIN32

        {

            const char *p2;

            p2 = strrchr(base_path, '\\');

            if (!p1 || p2 > p1)

                p1 = p2;

        }

#endif

        if (p1)

            p1++;

        else

            p1 = base_path;

        if (p1 > p)

            p = p1;

        len = p - base_path;

        if (len > dest_size - 1)

            len = dest_size - 1;

        memcpy(dest, base_path, len);

        dest[len] = '\0';

        pstrcat(dest, dest_size, filename);

    }

}

void bdrv_get_full_backing_filename(BlockDriverState *bs, char *dest, size_t sz)

{

    if (bs->backing_file[0] == '\0' || path_has_protocol(bs->backing_file)) {

        pstrcpy(dest, sz, bs->backing_file);

    } else {

        path_combine(dest, sz, bs->filename, bs->backing_file);

    }

}

void bdrv_register(BlockDriver *bdrv)

{

    /* Block drivers without coroutine functions need emulation */

    if (!bdrv->bdrv_co_readv) {

        bdrv->bdrv_co_readv = bdrv_co_readv_em;

        bdrv->bdrv_co_writev = bdrv_co_writev_em;

        /* bdrv_co_readv_em()/brdv_co_writev_em() work in terms of aio, so if

         * the block driver lacks aio we need to emulate that too.

         */

        if (!bdrv->bdrv_aio_readv) {

            /* add AIO emulation layer */

            bdrv->bdrv_aio_readv = bdrv_aio_readv_em;

            bdrv->bdrv_aio_writev = bdrv_aio_writev_em;

        }

    }

    QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list);

}

/* create a new block device (by default it is empty) */

BlockDriverState *bdrv_new(const char *device_name)

{

    BlockDriverState *bs;

    bs = g_malloc0(sizeof(BlockDriverState));

    pstrcpy(bs->device_name, sizeof(bs->device_name), device_name);

    if (device_name[0] != '\0') {

        QTAILQ_INSERT_TAIL(&bdrv_states, bs, list);

    }

    bdrv_iostatus_disable(bs);

    return bs;

}

BlockDriver *bdrv_find_format(const char *format_name)

{

    BlockDriver *drv1;

    QLIST_FOREACH(drv1, &bdrv_drivers, list) {

        if (!strcmp(drv1->format_name, format_name)) {

            return drv1;

        }

    }

    return NULL;

}

static int bdrv_is_whitelisted(BlockDriver *drv)

{

    static const char *whitelist[] = {

        CONFIG_BDRV_WHITELIST

    };

    const char **p;

    if (!whitelist[0])

        return 1;               /* no whitelist, anything goes */

    for (p = whitelist; *p; p++) {

        if (!strcmp(drv->format_name, *p)) {

            return 1;

        }

    }

    return 0;

}

BlockDriver *bdrv_find_whitelisted_format(const char *format_name)

{

    BlockDriver *drv = bdrv_find_format(format_name);

    return drv && bdrv_is_whitelisted(drv) ? drv : NULL;

}

typedef struct CreateCo {

    BlockDriver *drv;

    char *filename;

    QEMUOptionParameter *options;

    int ret;

} CreateCo;

static void coroutine_fn bdrv_create_co_entry(void *opaque)

{

    CreateCo *cco = opaque;

    assert(cco->drv);

    cco->ret = cco->drv->bdrv_create(cco->filename, cco->options);

}

int bdrv_create(BlockDriver *drv, const char* filename,

    QEMUOptionParameter *options)

{

    int ret;

    Coroutine *co;

    CreateCo cco = {

        .drv = drv,

        .filename = g_strdup(filename),

        .options = options,

        .ret = NOT_DONE,

    };

    if (!drv->bdrv_create) {

        return -ENOTSUP;

    }

    if (qemu_in_coroutine()) {

        /* Fast-path if already in coroutine context */

        bdrv_create_co_entry(&cco);

    } else {

        co = qemu_coroutine_create(bdrv_create_co_entry);

        qemu_coroutine_enter(co, &cco);

        while (cco.ret == NOT_DONE) {

            qemu_aio_wait();

        }

    }

    ret = cco.ret;

    g_free(cco.filename);

    return ret;

}

int bdrv_create_file(const char* filename, QEMUOptionParameter *options)

{

    BlockDriver *drv;

    drv = bdrv_find_protocol(filename);

    if (drv == NULL) {

        return -ENOENT;

    }

    return bdrv_create(drv, filename, options);

}

/*

 * Create a uniquely-named empty temporary file.

 * Return 0 upon success, otherwise a negative errno value.

 */

int get_tmp_filename(char *filename, int size)

{

#ifdef _WIN32

    char temp_dir[MAX_PATH];

    /* GetTempFileName requires that its output buffer (4th param)

       have length MAX_PATH or greater.  */

    assert(size >= MAX_PATH);

    return (GetTempPath(MAX_PATH, temp_dir)

            && GetTempFileName(temp_dir, "qem", 0, filename)

            ? 0 : -GetLastError());

#else

    int fd;

    const char *tmpdir;

    tmpdir = getenv("TMPDIR");

    if (!tmpdir)

        tmpdir = "/tmp";

    if (snprintf(filename, size, "%s/vl.XXXXXX", tmpdir) >= size) {

        return -EOVERFLOW;

    }

    fd = mkstemp(filename);

    if (fd < 0) {

        return -errno;

    }

    if (close(fd) != 0) {

        unlink(filename);

        return -errno;

    }

    return 0;

#endif

}

/*

 * Detect host devices. By convention, /dev/cdrom[N] is always

 * recognized as a host CDROM.

 */

static BlockDriver *find_hdev_driver(const char *filename)

{

    int score_max = 0, score;

    BlockDriver *drv = NULL, *d;

    QLIST_FOREACH(d, &bdrv_drivers, list) {

        if (d->bdrv_probe_device) {

            score = d->bdrv_probe_device(filename);

            if (score > score_max) {

                score_max = score;

                drv = d;

            }

        }

    }

    return drv;

}

BlockDriver *bdrv_find_protocol(const char *filename)

{

    BlockDriver *drv1;

    char protocol[128];

    int len;

    const char *p;

    /* TODO Drivers without bdrv_file_open must be specified explicitly */

    /*

     * XXX(hch): we really should not let host device detection

     * override an explicit protocol specification, but moving this

     * later breaks access to device names with colons in them.

     * Thanks to the brain-dead persistent naming schemes on udev-

     * based Linux systems those actually are quite common.

     */

    drv1 = find_hdev_driver(filename);

    if (drv1) {

        return drv1;

    }

    if (!path_has_protocol(filename)) {

        return bdrv_find_format("file");

    }

    p = strchr(filename, ':');

    assert(p != NULL);

    len = p - filename;

    if (len > sizeof(protocol) - 1)

        len = sizeof(protocol) - 1;

    memcpy(protocol, filename, len);

    protocol[len] = '\0';

    QLIST_FOREACH(drv1, &bdrv_drivers, list) {

        if (drv1->protocol_name &&

            !strcmp(drv1->protocol_name, protocol)) {

            return drv1;

        }

    }

    return NULL;

}

static int find_image_format(const char *filename, BlockDriver **pdrv)

{

    int ret, score, score_max;

    BlockDriver *drv1, *drv;

    uint8_t buf[2048];

    BlockDriverState *bs;

    ret = bdrv_file_open(&bs, filename, 0);

    if (ret < 0) {

        *pdrv = NULL;

        return ret;

    }

    /* Return the raw BlockDriver * to scsi-generic devices or empty drives */

    if (bs->sg || !bdrv_is_inserted(bs)) {

        bdrv_delete(bs);

        drv = bdrv_find_format("raw");

        if (!drv) {

            ret = -ENOENT;

        }

        *pdrv = drv;

        return ret;

    }

    ret = bdrv_pread(bs, 0, buf, sizeof(buf));

    bdrv_delete(bs);

    if (ret < 0) {

        *pdrv = NULL;

        return ret;

    }

    score_max = 0;

    drv = NULL;

    QLIST_FOREACH(drv1, &bdrv_drivers, list) {

        if (drv1->bdrv_probe) {

            score = drv1->bdrv_probe(buf, ret, filename);

            if (score > score_max) {

                score_max = score;

                drv = drv1;

            }

        }

    }

    if (!drv) {

        ret = -ENOENT;

    }

    *pdrv = drv;

    return ret;

}

/**

 * Set the current 'total_sectors' value

 */

static int refresh_total_sectors(BlockDriverState *bs, int64_t hint)

{

    BlockDriver *drv = bs->drv;

    /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */

    if (bs->sg)

        return 0;

    /* query actual device if possible, otherwise just trust the hint */

    if (drv->bdrv_getlength) {

        int64_t length = drv->bdrv_getlength(bs);

        if (length < 0) {

            return length;

        }

        hint = length >> BDRV_SECTOR_BITS;

    }

    bs->total_sectors = hint;

    return 0;

}

/**

 * Set open flags for a given cache mode

 *

 * Return 0 on success, -1 if the cache mode was invalid.

 */

int bdrv_parse_cache_flags(const char *mode, int *flags)

{

    *flags &= ~BDRV_O_CACHE_MASK;

    if (!strcmp(mode, "off") || !strcmp(mode, "none")) {

        *flags |= BDRV_O_NOCACHE | BDRV_O_CACHE_WB;

    } else if (!strcmp(mode, "directsync")) {

        *flags |= BDRV_O_NOCACHE;

    } else if (!strcmp(mode, "writeback")) {

        *flags |= BDRV_O_CACHE_WB;

    } else if (!strcmp(mode, "unsafe")) {

        *flags |= BDRV_O_CACHE_WB;

        *flags |= BDRV_O_NO_FLUSH;

    } else if (!strcmp(mode, "writethrough")) {

        /* this is the default */

    } else {

        return -1;

    }

    return 0;

}

/**

 * The copy-on-read flag is actually a reference count so multiple users may

 * use the feature without worrying about clobbering its previous state.

 * Copy-on-read stays enabled until all users have called to disable it.

 */

void bdrv_enable_copy_on_read(BlockDriverState *bs)

{

    bs->copy_on_read++;

}

void bdrv_disable_copy_on_read(BlockDriverState *bs)

{

    assert(bs->copy_on_read > 0);

    bs->copy_on_read--;

}

/*

 * Common part for opening disk images and files

 */

static int bdrv_open_common(BlockDriverState *bs, const char *filename,

    int flags, BlockDriver *drv)

{

    int ret, open_flags;

    assert(drv != NULL);

    assert(bs->file == NULL);

    trace_bdrv_open_common(bs, filename, flags, drv->format_name);

    bs->open_flags = flags;

    bs->buffer_alignment = 512;

    assert(bs->copy_on_read == 0); /* bdrv_new() and bdrv_close() make it so */

    if ((flags & BDRV_O_RDWR) && (flags & BDRV_O_COPY_ON_READ)) {

        bdrv_enable_copy_on_read(bs);

    }

    pstrcpy(bs->filename, sizeof(bs->filename), filename);

    if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv)) {

        return -ENOTSUP;

    }

    bs->drv = drv;

    bs->opaque = g_malloc0(drv->instance_size);

    bs->enable_write_cache = !!(flags & BDRV_O_CACHE_WB);

    open_flags = flags | BDRV_O_CACHE_WB;

    /*

     * Clear flags that are internal to the block layer before opening the

     * image.

     */

    open_flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);

    /*

     * Snapshots should be writable.

     */

    if (bs->is_temporary) {

        open_flags |= BDRV_O_RDWR;

    }

    bs->read_only = !(open_flags & BDRV_O_RDWR);

    /* Open the image, either directly or using a protocol */

    if (drv->bdrv_file_open) {

        ret = drv->bdrv_file_open(bs, filename, open_flags);

    } else {

        ret = bdrv_file_open(&bs->file, filename, open_flags);

        if (ret >= 0) {

            ret = drv->bdrv_open(bs, open_flags);

        }

    }

    if (ret < 0) {

        goto free_and_fail;

    }

    ret = refresh_total_sectors(bs, bs->total_sectors);

    if (ret < 0) {

        goto free_and_fail;

    }

#ifndef _WIN32

    if (bs->is_temporary) {

        unlink(filename);

    }

#endif

    return 0;

free_and_fail:

    if (bs->file) {

        bdrv_delete(bs->file);

        bs->file = NULL;

    }

    g_free(bs->opaque);

    bs->opaque = NULL;

    bs->drv = NULL;

    return ret;

}

/*

 * Opens a file using a protocol (file, host_device, nbd, ...)

 */

int bdrv_file_open(BlockDriverState **pbs, const char *filename, int flags)

{

    BlockDriverState *bs;

    BlockDriver *drv;

    int ret;

    drv = bdrv_find_protocol(filename);

    if (!drv) {

        return -ENOENT;

    }

    bs = bdrv_new("");

    ret = bdrv_open_common(bs, filename, flags, drv);

    if (ret < 0) {

        bdrv_delete(bs);

        return ret;

    }

    bs->growable = 1;

    *pbs = bs;

    return 0;

}

/*

 * Opens a disk image (raw, qcow2, vmdk, ...)

 */

int bdrv_open(BlockDriverState *bs, const char *filename, int flags,

              BlockDriver *drv)

{

    int ret;

    char tmp_filename[PATH_MAX];

    if (flags & BDRV_O_SNAPSHOT) {

        BlockDriverState *bs1;

        int64_t total_size;

        int is_protocol = 0;

        BlockDriver *bdrv_qcow2;

        QEMUOptionParameter *options;

        char backing_filename[PATH_MAX];

        /* if snapshot, we create a temporary backing file and open it

           instead of opening 'filename' directly */

        /* if there is a backing file, use it */

        bs1 = bdrv_new("");

        ret = bdrv_open(bs1, filename, 0, drv);

        if (ret < 0) {

            bdrv_delete(bs1);

            return ret;

        }

        total_size = bdrv_getlength(bs1) & BDRV_SECTOR_MASK;

        if (bs1->drv && bs1->drv->protocol_name)

            is_protocol = 1;

        bdrv_delete(bs1);

        ret = get_tmp_filename(tmp_filename, sizeof(tmp_filename));

        if (ret < 0) {

            return ret;

        }

        /* Real path is meaningless for protocols */

        if (is_protocol)

            snprintf(backing_filename, sizeof(backing_filename),

                     "%s", filename);

        else if (!realpath(filename, backing_filename))

            return -errno;

        bdrv_qcow2 = bdrv_find_format("qcow2");

        options = parse_option_parameters("", bdrv_qcow2->create_options, NULL);

        set_option_parameter_int(options, BLOCK_OPT_SIZE, total_size);

        set_option_parameter(options, BLOCK_OPT_BACKING_FILE, backing_filename);

        if (drv) {

            set_option_parameter(options, BLOCK_OPT_BACKING_FMT,

                drv->format_name);

        }

        ret = bdrv_create(bdrv_qcow2, tmp_filename, options);

        free_option_parameters(options);

        if (ret < 0) {

            return ret;

        }

        filename = tmp_filename;

        drv = bdrv_qcow2;

        bs->is_temporary = 1;

    }

    /* Find the right image format driver */

    if (!drv) {

        ret = find_image_format(filename, &drv);

    }

    if (!drv) {

        goto unlink_and_fail;

    }

    if (flags & BDRV_O_RDWR) {

        flags |= BDRV_O_ALLOW_RDWR;

    }

    /* Open the image */

    ret = bdrv_open_common(bs, filename, flags, drv);

    if (ret < 0) {

        goto unlink_and_fail;

    }

    /* If there is a backing file, use it */

    if ((flags & BDRV_O_NO_BACKING) == 0 && bs->backing_file[0] != '\0') {

        char backing_filename[PATH_MAX];

        int back_flags;

        BlockDriver *back_drv = NULL;

        bs->backing_hd = bdrv_new("");

        bdrv_get_full_backing_filename(bs, backing_filename,

                                       sizeof(backing_filename));

        if (bs->backing_format[0] != '\0') {

            back_drv = bdrv_find_format(bs->backing_format);

        }

        /* backing files always opened read-only */

        back_flags =

            flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);

        ret = bdrv_open(bs->backing_hd, backing_filename, back_flags, back_drv);

        if (ret < 0) {

            bdrv_close(bs);

            return ret;

        }

    }

    if (!bdrv_key_required(bs)) {

        bdrv_dev_change_media_cb(bs, true);

    }

    /* throttling disk I/O limits */

    if (bs->io_limits_enabled) {

        bdrv_io_limits_enable(bs);

    }

    return 0;

unlink_and_fail:

    if (bs->is_temporary) {

        unlink(filename);

    }

    return ret;

}

typedef struct BlockReopenQueueEntry {

     bool prepared;

     BDRVReopenState state;

     QSIMPLEQ_ENTRY(BlockReopenQueueEntry) entry;

} BlockReopenQueueEntry;

/*

 * Adds a BlockDriverState to a simple queue for an atomic, transactional

 * reopen of multiple devices.

 *

 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT

 * already performed, or alternatively may be NULL a new BlockReopenQueue will

 * be created and initialized. This newly created BlockReopenQueue should be

 * passed back in for subsequent calls that are intended to be of the same

 * atomic 'set'.

 *

 * bs is the BlockDriverState to add to the reopen queue.

 *

 * flags contains the open flags for the associated bs

 *

 * returns a pointer to bs_queue, which is either the newly allocated

 * bs_queue, or the existing bs_queue being used.

 *

 */

BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,

                                    BlockDriverState *bs, int flags)

{

    assert(bs != NULL);

    BlockReopenQueueEntry *bs_entry;

    if (bs_queue == NULL) {

        bs_queue = g_new0(BlockReopenQueue, 1);

        QSIMPLEQ_INIT(bs_queue);

    }

    if (bs->file) {

        bdrv_reopen_queue(bs_queue, bs->file, flags);

    }

    bs_entry = g_new0(BlockReopenQueueEntry, 1);

    QSIMPLEQ_INSERT_TAIL(bs_queue, bs_entry, entry);

    bs_entry->state.bs = bs;

    bs_entry->state.flags = flags;

    return bs_queue;

}

/*

 * Reopen multiple BlockDriverStates atomically & transactionally.

 *

 * The queue passed in (bs_queue) must have been built up previous

 * via bdrv_reopen_queue().

 *

 * Reopens all BDS specified in the queue, with the appropriate

 * flags.  All devices are prepared for reopen, and failure of any

 * device will cause all device changes to be abandonded, and intermediate

 * data cleaned up.

 *

 * If all devices prepare successfully, then the changes are committed

 * to all devices.

 *

 */

int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp)

{

    int ret = -1;

    BlockReopenQueueEntry *bs_entry, *next;

    Error *local_err = NULL;

    assert(bs_queue != NULL);

    bdrv_drain_all();

    QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {

        if (bdrv_reopen_prepare(&bs_entry->state, bs_queue, &local_err)) {

            error_propagate(errp, local_err);

            goto cleanup;

        }

        bs_entry->prepared = true;

    }

    /* If we reach this point, we have success and just need to apply the

     * changes

     */

    QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {

        bdrv_reopen_commit(&bs_entry->state);

    }

    ret = 0;

cleanup:

    QSIMPLEQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {

        if (ret && bs_entry->prepared) {

            bdrv_reopen_abort(&bs_entry->state);

        }

        g_free(bs_entry);

    }

    g_free(bs_queue);

    return ret;

}

/* Reopen a single BlockDriverState with the specified flags. */

int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp)

{

    int ret = -1;

    Error *local_err = NULL;

    BlockReopenQueue *queue = bdrv_reopen_queue(NULL, bs, bdrv_flags);

    ret = bdrv_reopen_multiple(queue, &local_err);

    if (local_err != NULL) {

        error_propagate(errp, local_err);

    }

    return ret;

}

/*

 * Prepares a BlockDriverState for reopen. All changes are staged in the

 * 'opaque' field of the BDRVReopenState, which is used and allocated by

 * the block driver layer .bdrv_reopen_prepare()

 *

 * bs is the BlockDriverState to reopen

 * flags are the new open flags

 * queue is the reopen queue

 *

 * Returns 0 on success, non-zero on error.  On error errp will be set

 * as well.

 *

 * On failure, bdrv_reopen_abort() will be called to clean up any data.

 * It is the responsibility of the caller to then call the abort() or

 * commit() for any other BDS that have been left in a prepare() state

 *

 */

int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,

                        Error **errp)

{

    int ret = -1;

    Error *local_err = NULL;

    BlockDriver *drv;

    assert(reopen_state != NULL);

    assert(reopen_state->bs->drv != NULL);

    drv = reopen_state->bs->drv;

    /* if we are to stay read-only, do not allow permission change

     * to r/w */

    if (!(reopen_state->bs->open_flags & BDRV_O_ALLOW_RDWR) &&

        reopen_state->flags & BDRV_O_RDWR) {

        error_set(errp, QERR_DEVICE_IS_READ_ONLY,

                  reopen_state->bs->device_name);

        goto error;

    }

    ret = bdrv_flush(reopen_state->bs);

    if (ret) {

        error_set(errp, ERROR_CLASS_GENERIC_ERROR, "Error (%s) flushing drive",

                  strerror(-ret));

        goto error;

    }

    if (drv->bdrv_reopen_prepare) {

        ret = drv->bdrv_reopen_prepare(reopen_state, queue, &local_err);

        if (ret) {

            if (local_err != NULL) {

                error_propagate(errp, local_err);

            } else {

                error_set(errp, QERR_OPEN_FILE_FAILED,

                          reopen_state->bs->filename);

            }

            goto error;

        }

    } else {

        /* It is currently mandatory to have a bdrv_reopen_prepare()

         * handler for each supported drv. */

        error_set(errp, QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED,

                  drv->format_name, reopen_state->bs->device_name,

                 "reopening of file");

        ret = -1;

        goto error;

    }

    ret = 0;

error:

    return ret;

}

/*

 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and

 * makes them final by swapping the staging BlockDriverState contents into

 * the active BlockDriverState contents.

 */

void bdrv_reopen_commit(BDRVReopenState *reopen_state)

{

    BlockDriver *drv;

    assert(reopen_state != NULL);

    drv = reopen_state->bs->drv;

    assert(drv != NULL);

    /* If there are any driver level actions to take */

    if (drv->bdrv_reopen_commit) {

        drv->bdrv_reopen_commit(reopen_state);

    }

    /* set BDS specific flags now */

    reopen_state->bs->open_flags         = reopen_state->flags;

    reopen_state->bs->enable_write_cache = !!(reopen_state->flags &

                                              BDRV_O_CACHE_WB);

    reopen_state->bs->read_only = !(reopen_state->flags & BDRV_O_RDWR);

}

/*

 * Abort the reopen, and delete and free the staged changes in

 * reopen_state

 */

void bdrv_reopen_abort(BDRVReopenState *reopen_state)

{

    BlockDriver *drv;

    assert(reopen_state != NULL);

    drv = reopen_state->bs->drv;

    assert(drv != NULL);

    if (drv->bdrv_reopen_abort) {

        drv->bdrv_reopen_abort(reopen_state);

    }

}

void bdrv_close(BlockDriverState *bs)

{

    bdrv_flush(bs);

    if (bs->drv) {

        if (bs->job) {

            block_job_cancel_sync(bs->job);

        }

        bdrv_drain_all();

        if (bs == bs_snapshots) {

            bs_snapshots = NULL;

        }

        if (bs->backing_hd) {

            bdrv_delete(bs->backing_hd);

            bs->backing_hd = NULL;

        }

        bs->drv->bdrv_close(bs);

        g_free(bs->opaque);

#ifdef _WIN32

        if (bs->is_temporary) {

            unlink(bs->filename);

        }

#endif

        bs->opaque = NULL;

        bs->drv = NULL;

        bs->copy_on_read = 0;

        bs->backing_file[0] = '\0';

        bs->backing_format[0] = '\0';

        bs->total_sectors = 0;

        bs->encrypted = 0;

        bs->valid_key = 0;

        bs->sg = 0;

        bs->growable = 0;

        if (bs->file != NULL) {

            bdrv_delete(bs->file);

            bs->file = NULL;

        }

    }

    bdrv_dev_change_media_cb(bs, false);

    /*throttling disk I/O limits*/

    if (bs->io_limits_enabled) {

        bdrv_io_limits_disable(bs);

    }

}

void bdrv_close_all(void)

{

    BlockDriverState *bs;

    QTAILQ_FOREACH(bs, &bdrv_states, list) {

        bdrv_close(bs);

    }

}

/*

 * Wait for pending requests to complete across all BlockDriverStates

 *

 * This function does not flush data to disk, use bdrv_flush_all() for that

 * after calling this function.

 *

 * Note that completion of an asynchronous I/O operation can trigger any

 * number of other I/O operations on other devices---for example a coroutine

 * can be arbitrarily complex and a constant flow of I/O can come until the

 * coroutine is complete.  Because of this, it is not possible to have a

 * function to drain a single device's I/O queue.

 */

void bdrv_drain_all(void)

{

    BlockDriverState *bs;

    bool busy;

    do {

        busy = qemu_aio_wait();

        /* FIXME: We do not have timer support here, so this is effectively

         * a busy wait.

         */

        QTAILQ_FOREACH(bs, &bdrv_states, list) {

            if (!qemu_co_queue_empty(&bs->throttled_reqs)) {

                qemu_co_queue_restart_all(&bs->throttled_reqs);

                busy = true;

            }

        }

    } while (busy);

    /* If requests are still pending there is a bug somewhere */

    QTAILQ_FOREACH(bs, &bdrv_states, list) {

        assert(QLIST_EMPTY(&bs->tracked_requests));

        assert(qemu_co_queue_empty(&bs->throttled_reqs));

    }

}

/* make a BlockDriverState anonymous by removing from bdrv_state list.

   Also, NULL terminate the device_name to prevent double remove */

void bdrv_make_anon(BlockDriverState *bs)

{

    if (bs->device_name[0] != '\0') {

        QTAILQ_REMOVE(&bdrv_states, bs, list);

    }

    bs->device_name[0] = '\0';

}

static void bdrv_rebind(BlockDriverState *bs)

{

    if (bs->drv && bs->drv->bdrv_rebind) {

        bs->drv->bdrv_rebind(bs);

    }

}

static void bdrv_move_feature_fields(BlockDriverState *bs_dest,

                                     BlockDriverState *bs_src)

{

    /* move some fields that need to stay attached to the device */

    bs_dest->open_flags         = bs_src->open_flags;

    /* dev info */

    bs_dest->dev_ops            = bs_src->dev_ops;

    bs_dest->dev_opaque         = bs_src->dev_opaque;

    bs_dest->dev                = bs_src->dev;

    bs_dest->buffer_alignment   = bs_src->buffer_alignment;

    bs_dest->copy_on_read       = bs_src->copy_on_read;

    bs_dest->enable_write_cache = bs_src->enable_write_cache;

    /* i/o timing parameters */

    bs_dest->slice_time         = bs_src->slice_time;

    bs_dest->slice_start        = bs_src->slice_start;

    bs_dest->slice_end          = bs_src->slice_end;

    bs_dest->io_limits          = bs_src->io_limits;

    bs_dest->io_base            = bs_src->io_base;

    bs_dest->throttled_reqs     = bs_src->throttled_reqs;

    bs_dest->block_timer        = bs_src->block_timer;

    bs_dest->io_limits_enabled  = bs_src->io_limits_enabled;

    /* r/w error */

    bs_dest->on_read_error      = bs_src->on_read_error;

    bs_dest->on_write_error     = bs_src->on_write_error;

    /* i/o status */

    bs_dest->iostatus_enabled   = bs_src->iostatus_enabled;

    bs_dest->iostatus           = bs_src->iostatus;

    /* dirty bitmap */

    bs_dest->dirty_count        = bs_src->dirty_count;

    bs_dest->dirty_bitmap       = bs_src->dirty_bitmap;

    /* job */

    bs_dest->in_use             = bs_src->in_use;

    bs_dest->job                = bs_src->job;

    /* keep the same entry in bdrv_states */

    pstrcpy(bs_dest->device_name, sizeof(bs_dest->device_name),

            bs_src->device_name);

    bs_dest->list = bs_src->list;

}

/*

 * Swap bs contents for two image chains while they are live,

 * while keeping required fields on the BlockDriverState that is

 * actually attached to a device.

 *

 * This will modify the BlockDriverState fields, and swap contents

 * between bs_new and bs_old. Both bs_new and bs_old are modified.

 *

 * bs_new is required to be anonymous.

 *

 * This function does not create any image files.

 */

void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old)

{

    BlockDriverState tmp;

    /* bs_new must be anonymous and shouldn't have anything fancy enabled */

    assert(bs_new->device_name[0] == '\0');

    assert(bs_new->dirty_bitmap == NULL);

    assert(bs_new->job == NULL);

    assert(bs_new->dev == NULL);

    assert(bs_new->in_use == 0);

    assert(bs_new->io_limits_enabled == false);

    assert(bs_new->block_timer == NULL);

    tmp = *bs_new;

    *bs_new = *bs_old;

    *bs_old = tmp;

    /* there are some fields that should not be swapped, move them back */

    bdrv_move_feature_fields(&tmp, bs_old);

    bdrv_move_feature_fields(bs_old, bs_new);

    bdrv_move_feature_fields(bs_new, &tmp);

    /* bs_new shouldn't be in bdrv_states even after the swap!  */

    assert(bs_new->device_name[0] == '\0');

    /* Check a few fields that should remain attached to the device */

    assert(bs_new->dev == NULL);

    assert(bs_new->job == NULL);

    assert(bs_new->in_use == 0);

    assert(bs_new->io_limits_enabled == false);

    assert(bs_new->block_timer == NULL);

    bdrv_rebind(bs_new);

    bdrv_rebind(bs_old);

}

/*

 * Add new bs contents at the top of an image chain while the chain is

 * live, while keeping required fields on the top layer.

 *

 * This will modify the BlockDriverState fields, and swap contents

 * between bs_new and bs_top. Both bs_new and bs_top are modified.

 *

 * bs_new is required to be anonymous.

 *

 * This function does not create any image files.

 */

void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top)

{

    bdrv_swap(bs_new, bs_top);

    /* The contents of 'tmp' will become bs_top, as we are

     * swapping bs_new and bs_top contents. */

    bs_top->backing_hd = bs_new;

    bs_top->open_flags &= ~BDRV_O_NO_BACKING;

    pstrcpy(bs_top->backing_file, sizeof(bs_top->backing_file),

            bs_new->filename);

    pstrcpy(bs_top->backing_format, sizeof(bs_top->backing_format),

            bs_new->drv ? bs_new->drv->format_name : "");

}

void bdrv_delete(BlockDriverState *bs)

{

    assert(!bs->dev);

    assert(!bs->job);

    assert(!bs->in_use);

    /* remove from list, if necessary */

    bdrv_make_anon(bs);

    bdrv_close(bs);

    assert(bs != bs_snapshots);

    g_free(bs);

}

int bdrv_attach_dev(BlockDriverState *bs, void *dev)

/* TODO change to DeviceState *dev when all users are qdevified */

{

    if (bs->dev) {

        return -EBUSY;

    }

    bs->dev = dev;

    bdrv_iostatus_reset(bs);

    return 0;

}

/* TODO qdevified devices don't use this, remove when devices are qdevified */

void bdrv_attach_dev_nofail(BlockDriverState *bs, void *dev)

{

    if (bdrv_attach_dev(bs, dev) < 0) {

        abort();

    }

}

void bdrv_detach_dev(BlockDriverState *bs, void *dev)

/* TODO change to DeviceState *dev when all users are qdevified */

{

    assert(bs->dev == dev);

    bs->dev = NULL;

    bs->dev_ops = NULL;

    bs->dev_opaque = NULL;

    bs->buffer_alignment = 512;

}

/* TODO change to return DeviceState * when all users are qdevified */

void *bdrv_get_attached_dev(BlockDriverState *bs)

{

    return bs->dev;

}

void bdrv_set_dev_ops(BlockDriverState *bs, const BlockDevOps *ops,

                      void *opaque)

{

    bs->dev_ops = ops;

    bs->dev_opaque = opaque;

    if (bdrv_dev_has_removable_media(bs) && bs == bs_snapshots) {

        bs_snapshots = NULL;

    }

}