block.c 164.1 KB
Newer Older
B
bellard 已提交
1 2
/*
 * QEMU System Emulator block driver
3
 *
B
bellard 已提交
4
 * Copyright (c) 2003 Fabrice Bellard
5
 *
B
bellard 已提交
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
 * 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.
 */
24
#include "config-host.h"
P
pbrook 已提交
25
#include "qemu-common.h"
26
#include "trace.h"
27 28
#include "block/block_int.h"
#include "block/blockjob.h"
29
#include "qemu/module.h"
30
#include "qapi/qmp/qjson.h"
31
#include "sysemu/sysemu.h"
32
#include "qemu/notify.h"
33
#include "block/coroutine.h"
34
#include "block/qapi.h"
L
Luiz Capitulino 已提交
35
#include "qmp-commands.h"
36
#include "qemu/timer.h"
37
#include "qapi-event.h"
B
bellard 已提交
38

J
Juan Quintela 已提交
39
#ifdef CONFIG_BSD
B
bellard 已提交
40 41 42
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
B
Blue Swirl 已提交
43
#include <sys/queue.h>
44
#ifndef __DragonFly__
B
bellard 已提交
45 46
#include <sys/disk.h>
#endif
47
#endif
B
bellard 已提交
48

49 50 51 52
#ifdef _WIN32
#include <windows.h>
#endif

F
Fam Zheng 已提交
53 54 55 56 57
struct BdrvDirtyBitmap {
    HBitmap *bitmap;
    QLIST_ENTRY(BdrvDirtyBitmap) list;
};

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

60
static void bdrv_dev_change_media_cb(BlockDriverState *bs, bool load);
61 62
static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
        int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
63
        BlockDriverCompletionFunc *cb, void *opaque);
64 65
static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
        int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
66
        BlockDriverCompletionFunc *cb, void *opaque);
67 68 69 70 71 72
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);
73 74
static int coroutine_fn bdrv_co_do_preadv(BlockDriverState *bs,
    int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
75
    BdrvRequestFlags flags);
76 77
static int coroutine_fn bdrv_co_do_pwritev(BlockDriverState *bs,
    int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
78
    BdrvRequestFlags flags);
79 80 81 82
static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs,
                                               int64_t sector_num,
                                               QEMUIOVector *qiov,
                                               int nb_sectors,
P
Paolo Bonzini 已提交
83
                                               BdrvRequestFlags flags,
84 85
                                               BlockDriverCompletionFunc *cb,
                                               void *opaque,
86
                                               bool is_write);
87
static void coroutine_fn bdrv_co_do_rw(void *opaque);
K
Kevin Wolf 已提交
88
static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs,
89
    int64_t sector_num, int nb_sectors, BdrvRequestFlags flags);
B
bellard 已提交
90

91 92
static QTAILQ_HEAD(, BlockDriverState) bdrv_states =
    QTAILQ_HEAD_INITIALIZER(bdrv_states);
93

94 95 96
static QTAILQ_HEAD(, BlockDriverState) graph_bdrv_states =
    QTAILQ_HEAD_INITIALIZER(graph_bdrv_states);

97 98
static QLIST_HEAD(, BlockDriver) bdrv_drivers =
    QLIST_HEAD_INITIALIZER(bdrv_drivers);
B
bellard 已提交
99

100 101 102
/* If non-zero, use only whitelisted block drivers */
static int use_bdrv_whitelist;

103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122
#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

123
/* throttling disk I/O limits */
124 125
void bdrv_set_io_limits(BlockDriverState *bs,
                        ThrottleConfig *cfg)
Z
Zhi Yong Wu 已提交
126
{
127
    int i;
Z
Zhi Yong Wu 已提交
128

129
    throttle_config(&bs->throttle_state, cfg);
Z
Zhi Yong Wu 已提交
130

131 132
    for (i = 0; i < 2; i++) {
        qemu_co_enter_next(&bs->throttled_reqs[i]);
Z
Zhi Yong Wu 已提交
133
    }
134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151
}

/* this function drain all the throttled IOs */
static bool bdrv_start_throttled_reqs(BlockDriverState *bs)
{
    bool drained = false;
    bool enabled = bs->io_limits_enabled;
    int i;

    bs->io_limits_enabled = false;

    for (i = 0; i < 2; i++) {
        while (qemu_co_enter_next(&bs->throttled_reqs[i])) {
            drained = true;
        }
    }

    bs->io_limits_enabled = enabled;
Z
Zhi Yong Wu 已提交
152

153
    return drained;
Z
Zhi Yong Wu 已提交
154 155
}

156
void bdrv_io_limits_disable(BlockDriverState *bs)
157
{
158
    bs->io_limits_enabled = false;
159

160 161 162
    bdrv_start_throttled_reqs(bs);

    throttle_destroy(&bs->throttle_state);
163 164
}

165
static void bdrv_throttle_read_timer_cb(void *opaque)
166
{
167 168
    BlockDriverState *bs = opaque;
    qemu_co_enter_next(&bs->throttled_reqs[0]);
169 170
}

171
static void bdrv_throttle_write_timer_cb(void *opaque)
172
{
173 174
    BlockDriverState *bs = opaque;
    qemu_co_enter_next(&bs->throttled_reqs[1]);
175 176
}

177 178 179 180 181
/* should be called before bdrv_set_io_limits if a limit is set */
void bdrv_io_limits_enable(BlockDriverState *bs)
{
    assert(!bs->io_limits_enabled);
    throttle_init(&bs->throttle_state,
182
                  bdrv_get_aio_context(bs),
183 184 185 186 187 188 189 190 191 192 193 194
                  QEMU_CLOCK_VIRTUAL,
                  bdrv_throttle_read_timer_cb,
                  bdrv_throttle_write_timer_cb,
                  bs);
    bs->io_limits_enabled = true;
}

/* This function makes an IO wait if needed
 *
 * @nb_sectors: the number of sectors of the IO
 * @is_write:   is the IO a write
 */
Z
Zhi Yong Wu 已提交
195
static void bdrv_io_limits_intercept(BlockDriverState *bs,
196
                                     unsigned int bytes,
197
                                     bool is_write)
Z
Zhi Yong Wu 已提交
198
{
199 200
    /* does this io must wait */
    bool must_wait = throttle_schedule_timer(&bs->throttle_state, is_write);
Z
Zhi Yong Wu 已提交
201

202 203 204 205
    /* if must wait or any request of this type throttled queue the IO */
    if (must_wait ||
        !qemu_co_queue_empty(&bs->throttled_reqs[is_write])) {
        qemu_co_queue_wait(&bs->throttled_reqs[is_write]);
Z
Zhi Yong Wu 已提交
206 207
    }

208
    /* the IO will be executed, do the accounting */
209 210
    throttle_account(&bs->throttle_state, is_write, bytes);

Z
Zhi Yong Wu 已提交
211

212 213 214
    /* if the next request must wait -> do nothing */
    if (throttle_schedule_timer(&bs->throttle_state, is_write)) {
        return;
Z
Zhi Yong Wu 已提交
215 216
    }

217 218
    /* else queue next request for execution */
    qemu_co_queue_next(&bs->throttled_reqs[is_write]);
Z
Zhi Yong Wu 已提交
219 220
}

221 222 223 224 225 226 227 228 229 230
size_t bdrv_opt_mem_align(BlockDriverState *bs)
{
    if (!bs || !bs->drv) {
        /* 4k should be on the safe side */
        return 4096;
    }

    return bs->bl.opt_mem_alignment;
}

231 232 233
/* check if the path starts with "<protocol>:" */
static int path_has_protocol(const char *path)
{
234 235
    const char *p;

236 237 238 239 240
#ifdef _WIN32
    if (is_windows_drive(path) ||
        is_windows_drive_prefix(path)) {
        return 0;
    }
241 242 243
    p = path + strcspn(path, ":/\\");
#else
    p = path + strcspn(path, ":/");
244 245
#endif

246
    return *p == ':';
247 248
}

B
bellard 已提交
249
int path_is_absolute(const char *path)
250
{
B
bellard 已提交
251 252
#ifdef _WIN32
    /* specific case for names like: "\\.\d:" */
P
Paolo Bonzini 已提交
253
    if (is_windows_drive(path) || is_windows_drive_prefix(path)) {
B
bellard 已提交
254
        return 1;
P
Paolo Bonzini 已提交
255 256
    }
    return (*path == '/' || *path == '\\');
257
#else
P
Paolo Bonzini 已提交
258
    return (*path == '/');
259
#endif
260 261
}

B
bellard 已提交
262 263 264 265 266 267
/* 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)
268
{
B
bellard 已提交
269 270 271 272 273 274 275 276 277 278 279 280 281
    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;
282 283 284 285 286 287 288 289 290
        p1 = strrchr(base_path, '/');
#ifdef _WIN32
        {
            const char *p2;
            p2 = strrchr(base_path, '\\');
            if (!p1 || p2 > p1)
                p1 = p2;
        }
#endif
B
bellard 已提交
291 292 293 294 295 296 297 298 299 300 301 302
        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);
303 304 305
    }
}

306 307 308 309 310 311 312 313 314
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);
    }
}

315
void bdrv_register(BlockDriver *bdrv)
B
bellard 已提交
316
{
317 318
    /* Block drivers without coroutine functions need emulation */
    if (!bdrv->bdrv_co_readv) {
319 320 321
        bdrv->bdrv_co_readv = bdrv_co_readv_em;
        bdrv->bdrv_co_writev = bdrv_co_writev_em;

322 323 324
        /* 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.
         */
325 326 327 328 329
        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;
        }
B
bellard 已提交
330
    }
331

332
    QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list);
B
bellard 已提交
333
}
B
bellard 已提交
334 335

/* create a new block device (by default it is empty) */
K
Kevin Wolf 已提交
336
BlockDriverState *bdrv_new(const char *device_name, Error **errp)
B
bellard 已提交
337
{
338
    BlockDriverState *bs;
339
    int i;
B
bellard 已提交
340

341 342 343 344 345 346 347 348 349 350 351
    if (bdrv_find(device_name)) {
        error_setg(errp, "Device with id '%s' already exists",
                   device_name);
        return NULL;
    }
    if (bdrv_find_node(device_name)) {
        error_setg(errp, "Device with node-name '%s' already exists",
                   device_name);
        return NULL;
    }

352
    bs = g_malloc0(sizeof(BlockDriverState));
F
Fam Zheng 已提交
353
    QLIST_INIT(&bs->dirty_bitmaps);
B
bellard 已提交
354
    pstrcpy(bs->device_name, sizeof(bs->device_name), device_name);
B
bellard 已提交
355
    if (device_name[0] != '\0') {
356
        QTAILQ_INSERT_TAIL(&bdrv_states, bs, device_list);
B
bellard 已提交
357
    }
358 359 360
    for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
        QLIST_INIT(&bs->op_blockers[i]);
    }
361
    bdrv_iostatus_disable(bs);
P
Paolo Bonzini 已提交
362
    notifier_list_init(&bs->close_notifiers);
363
    notifier_with_return_list_init(&bs->before_write_notifiers);
364 365
    qemu_co_queue_init(&bs->throttled_reqs[0]);
    qemu_co_queue_init(&bs->throttled_reqs[1]);
366
    bs->refcnt = 1;
367
    bs->aio_context = qemu_get_aio_context();
P
Paolo Bonzini 已提交
368

B
bellard 已提交
369 370 371
    return bs;
}

P
Paolo Bonzini 已提交
372 373 374 375 376
void bdrv_add_close_notifier(BlockDriverState *bs, Notifier *notify)
{
    notifier_list_add(&bs->close_notifiers, notify);
}

B
bellard 已提交
377 378 379
BlockDriver *bdrv_find_format(const char *format_name)
{
    BlockDriver *drv1;
380 381
    QLIST_FOREACH(drv1, &bdrv_drivers, list) {
        if (!strcmp(drv1->format_name, format_name)) {
B
bellard 已提交
382
            return drv1;
383
        }
B
bellard 已提交
384 385 386 387
    }
    return NULL;
}

388
static int bdrv_is_whitelisted(BlockDriver *drv, bool read_only)
389
{
390 391 392 393 394
    static const char *whitelist_rw[] = {
        CONFIG_BDRV_RW_WHITELIST
    };
    static const char *whitelist_ro[] = {
        CONFIG_BDRV_RO_WHITELIST
395 396 397
    };
    const char **p;

398
    if (!whitelist_rw[0] && !whitelist_ro[0]) {
399
        return 1;               /* no whitelist, anything goes */
400
    }
401

402
    for (p = whitelist_rw; *p; p++) {
403 404 405 406
        if (!strcmp(drv->format_name, *p)) {
            return 1;
        }
    }
407 408 409 410 411 412 413
    if (read_only) {
        for (p = whitelist_ro; *p; p++) {
            if (!strcmp(drv->format_name, *p)) {
                return 1;
            }
        }
    }
414 415 416
    return 0;
}

417 418
BlockDriver *bdrv_find_whitelisted_format(const char *format_name,
                                          bool read_only)
419 420
{
    BlockDriver *drv = bdrv_find_format(format_name);
421
    return drv && bdrv_is_whitelisted(drv, read_only) ? drv : NULL;
422 423
}

424 425 426
typedef struct CreateCo {
    BlockDriver *drv;
    char *filename;
427
    QemuOpts *opts;
428
    int ret;
429
    Error *err;
430 431 432 433
} CreateCo;

static void coroutine_fn bdrv_create_co_entry(void *opaque)
{
434 435 436
    Error *local_err = NULL;
    int ret;

437 438 439
    CreateCo *cco = opaque;
    assert(cco->drv);

C
Chunyan Liu 已提交
440
    ret = cco->drv->bdrv_create(cco->filename, cco->opts, &local_err);
441
    if (local_err) {
442 443 444
        error_propagate(&cco->err, local_err);
    }
    cco->ret = ret;
445 446
}

447
int bdrv_create(BlockDriver *drv, const char* filename,
448
                QemuOpts *opts, Error **errp)
B
bellard 已提交
449
{
450 451 452 453 454 455
    int ret;

    Coroutine *co;
    CreateCo cco = {
        .drv = drv,
        .filename = g_strdup(filename),
456
        .opts = opts,
457
        .ret = NOT_DONE,
458
        .err = NULL,
459 460
    };

C
Chunyan Liu 已提交
461
    if (!drv->bdrv_create) {
462
        error_setg(errp, "Driver '%s' does not support image creation", drv->format_name);
463 464
        ret = -ENOTSUP;
        goto out;
465 466 467 468 469 470 471 472 473
    }

    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) {
474
            aio_poll(qemu_get_aio_context(), true);
475 476 477 478
        }
    }

    ret = cco.ret;
479
    if (ret < 0) {
480
        if (cco.err) {
481 482 483 484 485
            error_propagate(errp, cco.err);
        } else {
            error_setg_errno(errp, -ret, "Could not create image");
        }
    }
486

487 488
out:
    g_free(cco.filename);
489
    return ret;
B
bellard 已提交
490 491
}

C
Chunyan Liu 已提交
492
int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp)
493 494
{
    BlockDriver *drv;
495 496
    Error *local_err = NULL;
    int ret;
497

498
    drv = bdrv_find_protocol(filename, true);
499
    if (drv == NULL) {
500
        error_setg(errp, "Could not find protocol for file '%s'", filename);
501
        return -ENOENT;
502 503
    }

C
Chunyan Liu 已提交
504
    ret = bdrv_create(drv, filename, opts, &local_err);
505
    if (local_err) {
506 507 508
        error_propagate(errp, local_err);
    }
    return ret;
509 510
}

511
void bdrv_refresh_limits(BlockDriverState *bs, Error **errp)
512 513
{
    BlockDriver *drv = bs->drv;
514
    Error *local_err = NULL;
515 516 517

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

K
Kevin Wolf 已提交
518
    if (!drv) {
519
        return;
K
Kevin Wolf 已提交
520 521 522 523
    }

    /* Take some limits from the children as a default */
    if (bs->file) {
524 525 526 527 528
        bdrv_refresh_limits(bs->file, &local_err);
        if (local_err) {
            error_propagate(errp, local_err);
            return;
        }
K
Kevin Wolf 已提交
529
        bs->bl.opt_transfer_length = bs->file->bl.opt_transfer_length;
530 531 532
        bs->bl.opt_mem_alignment = bs->file->bl.opt_mem_alignment;
    } else {
        bs->bl.opt_mem_alignment = 512;
K
Kevin Wolf 已提交
533 534 535
    }

    if (bs->backing_hd) {
536 537 538 539 540
        bdrv_refresh_limits(bs->backing_hd, &local_err);
        if (local_err) {
            error_propagate(errp, local_err);
            return;
        }
K
Kevin Wolf 已提交
541 542 543
        bs->bl.opt_transfer_length =
            MAX(bs->bl.opt_transfer_length,
                bs->backing_hd->bl.opt_transfer_length);
544 545 546
        bs->bl.opt_mem_alignment =
            MAX(bs->bl.opt_mem_alignment,
                bs->backing_hd->bl.opt_mem_alignment);
K
Kevin Wolf 已提交
547 548 549 550
    }

    /* Then let the driver override it */
    if (drv->bdrv_refresh_limits) {
551
        drv->bdrv_refresh_limits(bs, errp);
552 553 554
    }
}

555 556 557 558 559
/*
 * Create a uniquely-named empty temporary file.
 * Return 0 upon success, otherwise a negative errno value.
 */
int get_tmp_filename(char *filename, int size)
B
bellard 已提交
560
{
561
#ifdef _WIN32
562
    char temp_dir[MAX_PATH];
563 564 565 566 567 568
    /* 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());
B
bellard 已提交
569
#else
B
bellard 已提交
570
    int fd;
571
    const char *tmpdir;
A
aurel32 已提交
572
    tmpdir = getenv("TMPDIR");
573 574 575
    if (!tmpdir) {
        tmpdir = "/var/tmp";
    }
576 577 578
    if (snprintf(filename, size, "%s/vl.XXXXXX", tmpdir) >= size) {
        return -EOVERFLOW;
    }
B
bellard 已提交
579
    fd = mkstemp(filename);
580 581 582 583 584
    if (fd < 0) {
        return -errno;
    }
    if (close(fd) != 0) {
        unlink(filename);
585 586 587
        return -errno;
    }
    return 0;
B
bellard 已提交
588
#endif
589
}
B
bellard 已提交
590

591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612
/*
 * 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;
}

613 614
BlockDriver *bdrv_find_protocol(const char *filename,
                                bool allow_protocol_prefix)
B
bellard 已提交
615 616 617
{
    BlockDriver *drv1;
    char protocol[128];
618
    int len;
B
bellard 已提交
619
    const char *p;
B
bellard 已提交
620

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

623 624 625 626 627 628 629 630 631 632 633 634
    /*
     * 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;
    }

635
    if (!path_has_protocol(filename) || !allow_protocol_prefix) {
636
        return bdrv_find_format("file");
637
    }
638

639 640
    p = strchr(filename, ':');
    assert(p != NULL);
641 642 643 644 645
    len = p - filename;
    if (len > sizeof(protocol) - 1)
        len = sizeof(protocol) - 1;
    memcpy(protocol, filename, len);
    protocol[len] = '\0';
646
    QLIST_FOREACH(drv1, &bdrv_drivers, list) {
647
        if (drv1->protocol_name &&
648
            !strcmp(drv1->protocol_name, protocol)) {
B
bellard 已提交
649
            return drv1;
650
        }
B
bellard 已提交
651 652 653 654
    }
    return NULL;
}

655
static int find_image_format(BlockDriverState *bs, const char *filename,
656
                             BlockDriver **pdrv, Error **errp)
657
{
658
    int score, score_max;
659 660
    BlockDriver *drv1, *drv;
    uint8_t buf[2048];
661
    int ret = 0;
662

663
    /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
664
    if (bs->sg || !bdrv_is_inserted(bs) || bdrv_getlength(bs) == 0) {
665 666
        drv = bdrv_find_format("raw");
        if (!drv) {
667
            error_setg(errp, "Could not find raw image format");
668 669 670 671
            ret = -ENOENT;
        }
        *pdrv = drv;
        return ret;
672
    }
673

B
bellard 已提交
674 675
    ret = bdrv_pread(bs, 0, buf, sizeof(buf));
    if (ret < 0) {
676 677
        error_setg_errno(errp, -ret, "Could not read image for determining its "
                         "format");
678 679
        *pdrv = NULL;
        return ret;
B
bellard 已提交
680 681
    }

B
bellard 已提交
682
    score_max = 0;
683
    drv = NULL;
684
    QLIST_FOREACH(drv1, &bdrv_drivers, list) {
B
bellard 已提交
685 686 687 688 689 690
        if (drv1->bdrv_probe) {
            score = drv1->bdrv_probe(buf, ret, filename);
            if (score > score_max) {
                score_max = score;
                drv = drv1;
            }
B
bellard 已提交
691
        }
B
bellard 已提交
692
    }
693
    if (!drv) {
694 695
        error_setg(errp, "Could not determine image format: No compatible "
                   "driver found");
696 697 698 699
        ret = -ENOENT;
    }
    *pdrv = drv;
    return ret;
B
bellard 已提交
700 701
}

702 703
/**
 * Set the current 'total_sectors' value
M
Markus Armbruster 已提交
704
 * Return 0 on success, -errno on error.
705 706 707 708 709
 */
static int refresh_total_sectors(BlockDriverState *bs, int64_t hint)
{
    BlockDriver *drv = bs->drv;

710 711 712 713
    /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
    if (bs->sg)
        return 0;

714 715 716 717 718 719
    /* 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;
        }
F
Fam Zheng 已提交
720
        hint = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE);
721 722 723 724 725 726
    }

    bs->total_sectors = hint;
    return 0;
}

P
Paolo Bonzini 已提交
727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746
/**
 * Set open flags for a given discard mode
 *
 * Return 0 on success, -1 if the discard mode was invalid.
 */
int bdrv_parse_discard_flags(const char *mode, int *flags)
{
    *flags &= ~BDRV_O_UNMAP;

    if (!strcmp(mode, "off") || !strcmp(mode, "ignore")) {
        /* do nothing */
    } else if (!strcmp(mode, "on") || !strcmp(mode, "unmap")) {
        *flags |= BDRV_O_UNMAP;
    } else {
        return -1;
    }

    return 0;
}

747 748 749 750 751 752 753 754 755 756 757
/**
 * 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;
758 759
    } else if (!strcmp(mode, "directsync")) {
        *flags |= BDRV_O_NOCACHE;
760 761 762 763 764 765 766 767 768 769 770 771 772 773
    } 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;
}

774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789
/**
 * 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--;
}

790 791 792 793 794 795 796 797 798 799
/*
 * Returns the flags that a temporary snapshot should get, based on the
 * originally requested flags (the originally requested image will have flags
 * like a backing file)
 */
static int bdrv_temp_snapshot_flags(int flags)
{
    return (flags & ~BDRV_O_SNAPSHOT) | BDRV_O_TEMPORARY;
}

800 801 802 803 804 805 806 807 808 809 810 811 812 813
/*
 * Returns the flags that bs->file should get, based on the given flags for
 * the parent BDS
 */
static int bdrv_inherited_flags(int flags)
{
    /* Enable protocol handling, disable format probing for bs->file */
    flags |= BDRV_O_PROTOCOL;

    /* Our block drivers take care to send flushes and respect unmap policy,
     * so we can enable both unconditionally on lower layers. */
    flags |= BDRV_O_CACHE_WB | BDRV_O_UNMAP;

    /* Clear flags that only apply to the top layer */
814
    flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_COPY_ON_READ);
815 816 817 818

    return flags;
}

K
Kevin Wolf 已提交
819 820 821 822 823 824 825 826 827 828
/*
 * Returns the flags that bs->backing_hd should get, based on the given flags
 * for the parent BDS
 */
static int bdrv_backing_flags(int flags)
{
    /* backing files always opened read-only */
    flags &= ~(BDRV_O_RDWR | BDRV_O_COPY_ON_READ);

    /* snapshot=on is handled on the top layer */
829
    flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_TEMPORARY);
K
Kevin Wolf 已提交
830 831 832 833

    return flags;
}

K
Kevin Wolf 已提交
834 835 836 837 838 839 840 841
static int bdrv_open_flags(BlockDriverState *bs, int flags)
{
    int open_flags = flags | BDRV_O_CACHE_WB;

    /*
     * Clear flags that are internal to the block layer before opening the
     * image.
     */
842
    open_flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_PROTOCOL);
K
Kevin Wolf 已提交
843 844 845 846

    /*
     * Snapshots should be writable.
     */
847
    if (flags & BDRV_O_TEMPORARY) {
K
Kevin Wolf 已提交
848 849 850 851 852 853
        open_flags |= BDRV_O_RDWR;
    }

    return open_flags;
}

854 855 856
static void bdrv_assign_node_name(BlockDriverState *bs,
                                  const char *node_name,
                                  Error **errp)
857 858
{
    if (!node_name) {
859
        return;
860 861 862 863 864
    }

    /* empty string node name is invalid */
    if (node_name[0] == '\0') {
        error_setg(errp, "Empty node name");
865
        return;
866 867
    }

868 869 870 871
    /* takes care of avoiding namespaces collisions */
    if (bdrv_find(node_name)) {
        error_setg(errp, "node-name=%s is conflicting with a device id",
                   node_name);
872
        return;
873 874
    }

875 876 877
    /* takes care of avoiding duplicates node names */
    if (bdrv_find_node(node_name)) {
        error_setg(errp, "Duplicate node name");
878
        return;
879 880 881 882 883 884 885
    }

    /* copy node name into the bs and insert it into the graph list */
    pstrcpy(bs->node_name, sizeof(bs->node_name), node_name);
    QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs, node_list);
}

886 887
/*
 * Common part for opening disk images and files
888 889
 *
 * Removes all processed options from *options.
890
 */
891
static int bdrv_open_common(BlockDriverState *bs, BlockDriverState *file,
892
    QDict *options, int flags, BlockDriver *drv, Error **errp)
893 894
{
    int ret, open_flags;
K
Kevin Wolf 已提交
895
    const char *filename;
896
    const char *node_name = NULL;
897
    Error *local_err = NULL;
898 899

    assert(drv != NULL);
900
    assert(bs->file == NULL);
901
    assert(options != NULL && bs->options != options);
902

903 904 905 906 907 908
    if (file != NULL) {
        filename = file->filename;
    } else {
        filename = qdict_get_try_str(options, "filename");
    }

909 910 911 912 913 914
    if (drv->bdrv_needs_filename && !filename) {
        error_setg(errp, "The '%s' block driver requires a file name",
                   drv->format_name);
        return -EINVAL;
    }

915
    trace_bdrv_open_common(bs, filename ?: "", flags, drv->format_name);
S
Stefan Hajnoczi 已提交
916

917
    node_name = qdict_get_try_str(options, "node-name");
918
    bdrv_assign_node_name(bs, node_name, &local_err);
919
    if (local_err) {
920 921
        error_propagate(errp, local_err);
        return -EINVAL;
922 923 924
    }
    qdict_del(options, "node-name");

925 926 927 928 929 930 931 932
    /* bdrv_open() with directly using a protocol as drv. This layer is already
     * opened, so assign it to bs (while file becomes a closed BlockDriverState)
     * and return immediately. */
    if (file != NULL && drv->bdrv_file_open) {
        bdrv_swap(file, bs);
        return 0;
    }

933
    bs->open_flags = flags;
934
    bs->guest_block_size = 512;
935
    bs->request_alignment = 512;
A
Asias He 已提交
936
    bs->zero_beyond_eof = true;
937 938
    open_flags = bdrv_open_flags(bs, flags);
    bs->read_only = !(open_flags & BDRV_O_RDWR);
939
    bs->growable = !!(flags & BDRV_O_PROTOCOL);
940 941

    if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv, bs->read_only)) {
942 943 944 945 946
        error_setg(errp,
                   !bs->read_only && bdrv_is_whitelisted(drv, true)
                        ? "Driver '%s' can only be used for read-only devices"
                        : "Driver '%s' is not whitelisted",
                   drv->format_name);
947 948
        return -ENOTSUP;
    }
949

950
    assert(bs->copy_on_read == 0); /* bdrv_new() and bdrv_close() make it so */
951 952 953 954 955 956 957
    if (flags & BDRV_O_COPY_ON_READ) {
        if (!bs->read_only) {
            bdrv_enable_copy_on_read(bs);
        } else {
            error_setg(errp, "Can't use copy-on-read on read-only device");
            return -EINVAL;
        }
958 959
    }

960 961 962 963 964
    if (filename != NULL) {
        pstrcpy(bs->filename, sizeof(bs->filename), filename);
    } else {
        bs->filename[0] = '\0';
    }
965 966

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

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

971 972
    /* Open the image, either directly or using a protocol */
    if (drv->bdrv_file_open) {
973
        assert(file == NULL);
974
        assert(!drv->bdrv_needs_filename || filename != NULL);
975
        ret = drv->bdrv_file_open(bs, options, open_flags, &local_err);
976
    } else {
977
        if (file == NULL) {
978 979
            error_setg(errp, "Can't use '%s' as a block driver for the "
                       "protocol level", drv->format_name);
980 981 982
            ret = -EINVAL;
            goto free_and_fail;
        }
983
        bs->file = file;
984
        ret = drv->bdrv_open(bs, options, open_flags, &local_err);
985 986
    }

987
    if (ret < 0) {
988
        if (local_err) {
989
            error_propagate(errp, local_err);
990 991
        } else if (bs->filename[0]) {
            error_setg_errno(errp, -ret, "Could not open '%s'", bs->filename);
992 993 994
        } else {
            error_setg_errno(errp, -ret, "Could not open image");
        }
995 996 997
        goto free_and_fail;
    }

998 999
    ret = refresh_total_sectors(bs, bs->total_sectors);
    if (ret < 0) {
1000
        error_setg_errno(errp, -ret, "Could not refresh total sector count");
1001
        goto free_and_fail;
1002
    }
1003

1004 1005 1006 1007 1008 1009 1010
    bdrv_refresh_limits(bs, &local_err);
    if (local_err) {
        error_propagate(errp, local_err);
        ret = -EINVAL;
        goto free_and_fail;
    }

1011
    assert(bdrv_opt_mem_align(bs) != 0);
1012
    assert((bs->request_alignment != 0) || bs->sg);
1013 1014 1015
    return 0;

free_and_fail:
1016
    bs->file = NULL;
1017
    g_free(bs->opaque);
1018 1019 1020 1021 1022
    bs->opaque = NULL;
    bs->drv = NULL;
    return ret;
}

1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049
static QDict *parse_json_filename(const char *filename, Error **errp)
{
    QObject *options_obj;
    QDict *options;
    int ret;

    ret = strstart(filename, "json:", &filename);
    assert(ret);

    options_obj = qobject_from_json(filename);
    if (!options_obj) {
        error_setg(errp, "Could not parse the JSON options");
        return NULL;
    }

    if (qobject_type(options_obj) != QTYPE_QDICT) {
        qobject_decref(options_obj);
        error_setg(errp, "Invalid JSON object given");
        return NULL;
    }

    options = qobject_to_qdict(options_obj);
    qdict_flatten(options);

    return options;
}

K
Kevin Wolf 已提交
1050
/*
K
Kevin Wolf 已提交
1051 1052
 * Fills in default options for opening images and converts the legacy
 * filename/flags pair to option QDict entries.
K
Kevin Wolf 已提交
1053
 */
1054
static int bdrv_fill_options(QDict **options, const char **pfilename, int flags,
1055
                             BlockDriver *drv, Error **errp)
B
bellard 已提交
1056
{
1057
    const char *filename = *pfilename;
1058
    const char *drvname;
1059
    bool protocol = flags & BDRV_O_PROTOCOL;
1060
    bool parse_filename = false;
1061
    Error *local_err = NULL;
B
bellard 已提交
1062

1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077
    /* Parse json: pseudo-protocol */
    if (filename && g_str_has_prefix(filename, "json:")) {
        QDict *json_options = parse_json_filename(filename, &local_err);
        if (local_err) {
            error_propagate(errp, local_err);
            return -EINVAL;
        }

        /* Options given in the filename have lower priority than options
         * specified directly */
        qdict_join(*options, json_options, false);
        QDECREF(json_options);
        *pfilename = filename = NULL;
    }

K
Kevin Wolf 已提交
1078
    /* Fetch the file name from the options QDict if necessary */
1079
    if (protocol && filename) {
K
Kevin Wolf 已提交
1080 1081 1082 1083 1084 1085 1086 1087
        if (!qdict_haskey(*options, "filename")) {
            qdict_put(*options, "filename", qstring_from_str(filename));
            parse_filename = true;
        } else {
            error_setg(errp, "Can't specify 'file' and 'filename' options at "
                             "the same time");
            return -EINVAL;
        }
K
Kevin Wolf 已提交
1088 1089
    }

1090
    /* Find the right block driver */
K
Kevin Wolf 已提交
1091
    filename = qdict_get_try_str(*options, "filename");
1092
    drvname = qdict_get_try_str(*options, "driver");
K
Kevin Wolf 已提交
1093

1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113
    if (drv) {
        if (drvname) {
            error_setg(errp, "Driver specified twice");
            return -EINVAL;
        }
        drvname = drv->format_name;
        qdict_put(*options, "driver", qstring_from_str(drvname));
    } else {
        if (!drvname && protocol) {
            if (filename) {
                drv = bdrv_find_protocol(filename, parse_filename);
                if (!drv) {
                    error_setg(errp, "Unknown protocol");
                    return -EINVAL;
                }

                drvname = drv->format_name;
                qdict_put(*options, "driver", qstring_from_str(drvname));
            } else {
                error_setg(errp, "Must specify either driver or file");
K
Kevin Wolf 已提交
1114 1115
                return -EINVAL;
            }
1116 1117 1118 1119 1120 1121
        } else if (drvname) {
            drv = bdrv_find_format(drvname);
            if (!drv) {
                error_setg(errp, "Unknown driver '%s'", drvname);
                return -ENOENT;
            }
1122
        }
1123 1124
    }

1125
    assert(drv || !protocol);
1126

K
Kevin Wolf 已提交
1127
    /* Driver-specific filename parsing */
1128
    if (drv && drv->bdrv_parse_filename && parse_filename) {
1129
        drv->bdrv_parse_filename(filename, *options, &local_err);
1130
        if (local_err) {
1131
            error_propagate(errp, local_err);
K
Kevin Wolf 已提交
1132
            return -EINVAL;
1133
        }
1134 1135 1136 1137

        if (!drv->bdrv_needs_filename) {
            qdict_del(*options, "filename");
        }
1138 1139
    }

K
Kevin Wolf 已提交
1140 1141 1142
    return 0;
}

F
Fam Zheng 已提交
1143 1144 1145
void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd)
{

1146 1147 1148 1149 1150 1151 1152 1153 1154
    if (bs->backing_hd) {
        assert(bs->backing_blocker);
        bdrv_op_unblock_all(bs->backing_hd, bs->backing_blocker);
    } else if (backing_hd) {
        error_setg(&bs->backing_blocker,
                   "device is used as backing hd of '%s'",
                   bs->device_name);
    }

F
Fam Zheng 已提交
1155 1156
    bs->backing_hd = backing_hd;
    if (!backing_hd) {
1157 1158
        error_free(bs->backing_blocker);
        bs->backing_blocker = NULL;
F
Fam Zheng 已提交
1159 1160 1161 1162 1163 1164
        goto out;
    }
    bs->open_flags &= ~BDRV_O_NO_BACKING;
    pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_hd->filename);
    pstrcpy(bs->backing_format, sizeof(bs->backing_format),
            backing_hd->drv ? backing_hd->drv->format_name : "");
1165 1166 1167 1168 1169

    bdrv_op_block_all(bs->backing_hd, bs->backing_blocker);
    /* Otherwise we won't be able to commit due to check in bdrv_commit */
    bdrv_op_unblock(bs->backing_hd, BLOCK_OP_TYPE_COMMIT,
                    bs->backing_blocker);
F
Fam Zheng 已提交
1170
out:
1171
    bdrv_refresh_limits(bs, NULL);
F
Fam Zheng 已提交
1172 1173
}

1174 1175 1176 1177 1178 1179 1180 1181
/*
 * Opens the backing file for a BlockDriverState if not yet open
 *
 * options is a QDict of options to pass to the block drivers, or NULL for an
 * empty set of options. The reference to the QDict is transferred to this
 * function (even on failure), so if the caller intends to reuse the dictionary,
 * it needs to use QINCREF() before calling bdrv_file_open.
 */
1182
int bdrv_open_backing_file(BlockDriverState *bs, QDict *options, Error **errp)
P
Paolo Bonzini 已提交
1183
{
1184
    char *backing_filename = g_malloc0(PATH_MAX);
K
Kevin Wolf 已提交
1185
    int ret = 0;
P
Paolo Bonzini 已提交
1186
    BlockDriver *back_drv = NULL;
F
Fam Zheng 已提交
1187
    BlockDriverState *backing_hd;
1188
    Error *local_err = NULL;
P
Paolo Bonzini 已提交
1189 1190

    if (bs->backing_hd != NULL) {
1191
        QDECREF(options);
1192
        goto free_exit;
P
Paolo Bonzini 已提交
1193 1194
    }

1195 1196 1197 1198 1199
    /* NULL means an empty set of options */
    if (options == NULL) {
        options = qdict_new();
    }

P
Paolo Bonzini 已提交
1200
    bs->open_flags &= ~BDRV_O_NO_BACKING;
1201 1202 1203
    if (qdict_haskey(options, "file.filename")) {
        backing_filename[0] = '\0';
    } else if (bs->backing_file[0] == '\0' && qdict_size(options) == 0) {
1204
        QDECREF(options);
1205
        goto free_exit;
F
Fam Zheng 已提交
1206
    } else {
1207
        bdrv_get_full_backing_filename(bs, backing_filename, PATH_MAX);
P
Paolo Bonzini 已提交
1208 1209
    }

1210 1211 1212 1213 1214 1215 1216
    if (!bs->drv || !bs->drv->supports_backing) {
        ret = -EINVAL;
        error_setg(errp, "Driver doesn't support backing files");
        QDECREF(options);
        goto free_exit;
    }

F
Fam Zheng 已提交
1217 1218
    backing_hd = bdrv_new("", errp);

P
Paolo Bonzini 已提交
1219 1220 1221 1222
    if (bs->backing_format[0] != '\0') {
        back_drv = bdrv_find_format(bs->backing_format);
    }

1223
    assert(bs->backing_hd == NULL);
F
Fam Zheng 已提交
1224
    ret = bdrv_open(&backing_hd,
1225
                    *backing_filename ? backing_filename : NULL, NULL, options,
K
Kevin Wolf 已提交
1226
                    bdrv_backing_flags(bs->open_flags), back_drv, &local_err);
P
Paolo Bonzini 已提交
1227
    if (ret < 0) {
F
Fam Zheng 已提交
1228 1229
        bdrv_unref(backing_hd);
        backing_hd = NULL;
P
Paolo Bonzini 已提交
1230
        bs->open_flags |= BDRV_O_NO_BACKING;
1231 1232 1233
        error_setg(errp, "Could not open backing file: %s",
                   error_get_pretty(local_err));
        error_free(local_err);
1234
        goto free_exit;
P
Paolo Bonzini 已提交
1235
    }
F
Fam Zheng 已提交
1236
    bdrv_set_backing_hd(bs, backing_hd);
P
Peter Feiner 已提交
1237

1238 1239 1240
free_exit:
    g_free(backing_filename);
    return ret;
P
Paolo Bonzini 已提交
1241 1242
}

M
Max Reitz 已提交
1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255
/*
 * Opens a disk image whose options are given as BlockdevRef in another block
 * device's options.
 *
 * If allow_none is true, no image will be opened if filename is false and no
 * BlockdevRef is given. *pbs will remain unchanged and 0 will be returned.
 *
 * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
 * itself, all options starting with "${bdref_key}." are considered part of the
 * BlockdevRef.
 *
 * The BlockdevRef will be removed from the options QDict.
1256 1257
 *
 * To conform with the behavior of bdrv_open(), *pbs has to be NULL.
M
Max Reitz 已提交
1258 1259 1260
 */
int bdrv_open_image(BlockDriverState **pbs, const char *filename,
                    QDict *options, const char *bdref_key, int flags,
1261
                    bool allow_none, Error **errp)
M
Max Reitz 已提交
1262 1263 1264 1265 1266 1267
{
    QDict *image_options;
    int ret;
    char *bdref_key_dot;
    const char *reference;

1268 1269 1270
    assert(pbs);
    assert(*pbs == NULL);

M
Max Reitz 已提交
1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283
    bdref_key_dot = g_strdup_printf("%s.", bdref_key);
    qdict_extract_subqdict(options, &image_options, bdref_key_dot);
    g_free(bdref_key_dot);

    reference = qdict_get_try_str(options, bdref_key);
    if (!filename && !reference && !qdict_size(image_options)) {
        if (allow_none) {
            ret = 0;
        } else {
            error_setg(errp, "A block device must be specified for \"%s\"",
                       bdref_key);
            ret = -EINVAL;
        }
1284
        QDECREF(image_options);
M
Max Reitz 已提交
1285 1286 1287
        goto done;
    }

1288
    ret = bdrv_open(pbs, filename, reference, image_options, flags, NULL, errp);
M
Max Reitz 已提交
1289 1290 1291 1292 1293 1294

done:
    qdict_del(options, bdref_key);
    return ret;
}

1295
int bdrv_append_temp_snapshot(BlockDriverState *bs, int flags, Error **errp)
1296 1297
{
    /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
1298
    char *tmp_filename = g_malloc0(PATH_MAX + 1);
1299 1300
    int64_t total_size;
    BlockDriver *bdrv_qcow2;
1301
    QemuOpts *opts = NULL;
1302 1303 1304 1305 1306 1307 1308 1309 1310
    QDict *snapshot_options;
    BlockDriverState *bs_snapshot;
    Error *local_err;
    int ret;

    /* if snapshot, we create a temporary backing file and open it
       instead of opening 'filename' directly */

    /* Get the required size from the image */
1311 1312
    total_size = bdrv_getlength(bs);
    if (total_size < 0) {
1313
        ret = total_size;
1314
        error_setg_errno(errp, -total_size, "Could not get image size");
1315
        goto out;
1316 1317
    }
    total_size &= BDRV_SECTOR_MASK;
1318 1319

    /* Create the temporary image */
1320
    ret = get_tmp_filename(tmp_filename, PATH_MAX + 1);
1321 1322
    if (ret < 0) {
        error_setg_errno(errp, -ret, "Could not get temporary filename");
1323
        goto out;
1324 1325 1326
    }

    bdrv_qcow2 = bdrv_find_format("qcow2");
C
Chunyan Liu 已提交
1327 1328
    opts = qemu_opts_create(bdrv_qcow2->create_opts, NULL, 0,
                            &error_abort);
1329
    qemu_opt_set_number(opts, BLOCK_OPT_SIZE, total_size);
C
Chunyan Liu 已提交
1330
    ret = bdrv_create(bdrv_qcow2, tmp_filename, opts, &local_err);
1331
    qemu_opts_del(opts);
1332 1333 1334 1335 1336
    if (ret < 0) {
        error_setg_errno(errp, -ret, "Could not create temporary overlay "
                         "'%s': %s", tmp_filename,
                         error_get_pretty(local_err));
        error_free(local_err);
1337
        goto out;
1338 1339 1340 1341 1342 1343 1344 1345 1346
    }

    /* Prepare a new options QDict for the temporary file */
    snapshot_options = qdict_new();
    qdict_put(snapshot_options, "file.driver",
              qstring_from_str("file"));
    qdict_put(snapshot_options, "file.filename",
              qstring_from_str(tmp_filename));

K
Kevin Wolf 已提交
1347
    bs_snapshot = bdrv_new("", &error_abort);
1348 1349

    ret = bdrv_open(&bs_snapshot, NULL, NULL, snapshot_options,
1350
                    flags, bdrv_qcow2, &local_err);
1351 1352
    if (ret < 0) {
        error_propagate(errp, local_err);
1353
        goto out;
1354 1355 1356
    }

    bdrv_append(bs_snapshot, bs);
1357 1358 1359

out:
    g_free(tmp_filename);
1360
    return ret;
1361 1362
}

K
Kevin Wolf 已提交
1363 1364
/*
 * Opens a disk image (raw, qcow2, vmdk, ...)
1365 1366 1367 1368 1369
 *
 * options is a QDict of options to pass to the block drivers, or NULL for an
 * empty set of options. The reference to the QDict belongs to the block layer
 * after the call (even on failure), so if the caller intends to reuse the
 * dictionary, it needs to use QINCREF() before calling bdrv_open.
1370 1371 1372
 *
 * If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
 * If it is not NULL, the referenced BDS will be reused.
1373 1374 1375 1376
 *
 * The reference parameter may be used to specify an existing block device which
 * should be opened. If specified, neither options nor a filename may be given,
 * nor can an existing BDS be reused (that is, *pbs has to be NULL).
K
Kevin Wolf 已提交
1377
 */
1378 1379 1380
int bdrv_open(BlockDriverState **pbs, const char *filename,
              const char *reference, QDict *options, int flags,
              BlockDriver *drv, Error **errp)
B
bellard 已提交
1381
{
K
Kevin Wolf 已提交
1382
    int ret;
1383
    BlockDriverState *file = NULL, *bs;
1384
    const char *drvname;
1385
    Error *local_err = NULL;
1386
    int snapshot_flags = 0;
B
bellard 已提交
1387

1388 1389
    assert(pbs);

1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414
    if (reference) {
        bool options_non_empty = options ? qdict_size(options) : false;
        QDECREF(options);

        if (*pbs) {
            error_setg(errp, "Cannot reuse an existing BDS when referencing "
                       "another block device");
            return -EINVAL;
        }

        if (filename || options_non_empty) {
            error_setg(errp, "Cannot reference an existing block device with "
                       "additional options or a new filename");
            return -EINVAL;
        }

        bs = bdrv_lookup_bs(reference, reference, errp);
        if (!bs) {
            return -ENODEV;
        }
        bdrv_ref(bs);
        *pbs = bs;
        return 0;
    }

1415 1416 1417
    if (*pbs) {
        bs = *pbs;
    } else {
K
Kevin Wolf 已提交
1418
        bs = bdrv_new("", &error_abort);
1419 1420
    }

1421 1422 1423 1424 1425
    /* NULL means an empty set of options */
    if (options == NULL) {
        options = qdict_new();
    }

1426
    ret = bdrv_fill_options(&options, &filename, flags, drv, &local_err);
1427 1428 1429 1430
    if (local_err) {
        goto fail;
    }

1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450
    /* Find the right image format driver */
    drv = NULL;
    drvname = qdict_get_try_str(options, "driver");
    if (drvname) {
        drv = bdrv_find_format(drvname);
        qdict_del(options, "driver");
        if (!drv) {
            error_setg(errp, "Unknown driver: '%s'", drvname);
            ret = -EINVAL;
            goto fail;
        }
    }

    assert(drvname || !(flags & BDRV_O_PROTOCOL));
    if (drv && !drv->bdrv_file_open) {
        /* If the user explicitly wants a format driver here, we'll need to add
         * another layer for the protocol in bs->file */
        flags &= ~BDRV_O_PROTOCOL;
    }

1451
    bs->options = options;
1452
    options = qdict_clone_shallow(options);
1453

1454
    /* Open image file without format layer */
1455 1456 1457 1458 1459 1460 1461 1462
    if ((flags & BDRV_O_PROTOCOL) == 0) {
        if (flags & BDRV_O_RDWR) {
            flags |= BDRV_O_ALLOW_RDWR;
        }
        if (flags & BDRV_O_SNAPSHOT) {
            snapshot_flags = bdrv_temp_snapshot_flags(flags);
            flags = bdrv_backing_flags(flags);
        }
1463

1464 1465 1466 1467 1468 1469 1470
        assert(file == NULL);
        ret = bdrv_open_image(&file, filename, options, "file",
                              bdrv_inherited_flags(flags),
                              true, &local_err);
        if (ret < 0) {
            goto fail;
        }
1471 1472
    }

1473 1474
    /* Image format probing */
    if (!drv && file) {
1475 1476
        ret = find_image_format(file, filename, &drv, &local_err);
        if (ret < 0) {
1477
            goto fail;
1478
        }
1479
    } else if (!drv) {
1480 1481
        error_setg(errp, "Must specify either driver or file");
        ret = -EINVAL;
1482
        goto fail;
B
bellard 已提交
1483
    }
K
Kevin Wolf 已提交
1484 1485

    /* Open the image */
1486
    ret = bdrv_open_common(bs, file, options, flags, drv, &local_err);
K
Kevin Wolf 已提交
1487
    if (ret < 0) {
1488
        goto fail;
1489 1490
    }

1491
    if (file && (bs->file != file)) {
F
Fam Zheng 已提交
1492
        bdrv_unref(file);
1493 1494 1495
        file = NULL;
    }

K
Kevin Wolf 已提交
1496
    /* If there is a backing file, use it */
P
Paolo Bonzini 已提交
1497
    if ((flags & BDRV_O_NO_BACKING) == 0) {
1498 1499
        QDict *backing_options;

1500
        qdict_extract_subqdict(options, &backing_options, "backing.");
1501
        ret = bdrv_open_backing_file(bs, backing_options, &local_err);
K
Kevin Wolf 已提交
1502
        if (ret < 0) {
1503
            goto close_and_fail;
K
Kevin Wolf 已提交
1504 1505 1506
        }
    }

1507 1508
    /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
     * temporary snapshot afterwards. */
1509
    if (snapshot_flags) {
1510
        ret = bdrv_append_temp_snapshot(bs, snapshot_flags, &local_err);
1511 1512 1513 1514 1515
        if (local_err) {
            goto close_and_fail;
        }
    }

1516
    /* Check if any unknown options were used */
1517
    if (options && (qdict_size(options) != 0)) {
1518
        const QDictEntry *entry = qdict_first(options);
1519 1520 1521 1522 1523 1524 1525 1526
        if (flags & BDRV_O_PROTOCOL) {
            error_setg(errp, "Block protocol '%s' doesn't support the option "
                       "'%s'", drv->format_name, entry->key);
        } else {
            error_setg(errp, "Block format '%s' used by device '%s' doesn't "
                       "support the option '%s'", drv->format_name,
                       bs->device_name, entry->key);
        }
1527 1528 1529 1530 1531

        ret = -EINVAL;
        goto close_and_fail;
    }

K
Kevin Wolf 已提交
1532
    if (!bdrv_key_required(bs)) {
1533
        bdrv_dev_change_media_cb(bs, true);
1534 1535 1536 1537 1538 1539 1540
    } else if (!runstate_check(RUN_STATE_PRELAUNCH)
               && !runstate_check(RUN_STATE_INMIGRATE)
               && !runstate_check(RUN_STATE_PAUSED)) { /* HACK */
        error_setg(errp,
                   "Guest must be stopped for opening of encrypted image");
        ret = -EBUSY;
        goto close_and_fail;
K
Kevin Wolf 已提交
1541 1542
    }

1543
    QDECREF(options);
1544
    *pbs = bs;
K
Kevin Wolf 已提交
1545 1546
    return 0;

1547
fail:
1548
    if (file != NULL) {
F
Fam Zheng 已提交
1549
        bdrv_unref(file);
1550
    }
1551
    QDECREF(bs->options);
1552
    QDECREF(options);
1553
    bs->options = NULL;
1554 1555 1556 1557 1558 1559
    if (!*pbs) {
        /* If *pbs is NULL, a new BDS has been created in this function and
           needs to be freed now. Otherwise, it does not need to be closed,
           since it has not really been opened yet. */
        bdrv_unref(bs);
    }
1560
    if (local_err) {
1561 1562
        error_propagate(errp, local_err);
    }
1563
    return ret;
1564

1565
close_and_fail:
1566 1567 1568 1569 1570 1571
    /* See fail path, but now the BDS has to be always closed */
    if (*pbs) {
        bdrv_close(bs);
    } else {
        bdrv_unref(bs);
    }
1572
    QDECREF(options);
1573
    if (local_err) {
1574 1575
        error_propagate(errp, local_err);
    }
K
Kevin Wolf 已提交
1576 1577 1578
    return ret;
}

1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613
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);
    }

1614 1615 1616
    /* bdrv_open() masks this flag out */
    flags &= ~BDRV_O_PROTOCOL;

1617
    if (bs->file) {
1618
        bdrv_reopen_queue(bs_queue, bs->file, bdrv_inherited_flags(flags));
1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749
    }

    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 {
1750 1751
                error_setg(errp, "failed while preparing to reopen image '%s'",
                           reopen_state->bs->filename);
1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793
            }
            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);
1794

1795
    bdrv_refresh_limits(reopen_state->bs, NULL);
1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815
}

/*
 * 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);
    }
}


B
bellard 已提交
1816 1817
void bdrv_close(BlockDriverState *bs)
{
1818 1819 1820
    if (bs->job) {
        block_job_cancel_sync(bs->job);
    }
1821 1822 1823
    bdrv_drain_all(); /* complete I/O */
    bdrv_flush(bs);
    bdrv_drain_all(); /* in case flush left pending I/O */
P
Paolo Bonzini 已提交
1824
    notifier_list_notify(&bs->close_notifiers, bs);
K
Kevin Wolf 已提交
1825

1826
    if (bs->drv) {
1827
        if (bs->backing_hd) {
1828 1829 1830
            BlockDriverState *backing_hd = bs->backing_hd;
            bdrv_set_backing_hd(bs, NULL);
            bdrv_unref(backing_hd);
1831
        }
B
bellard 已提交
1832
        bs->drv->bdrv_close(bs);
1833
        g_free(bs->opaque);
B
bellard 已提交
1834 1835
        bs->opaque = NULL;
        bs->drv = NULL;
1836
        bs->copy_on_read = 0;
1837 1838
        bs->backing_file[0] = '\0';
        bs->backing_format[0] = '\0';
1839 1840 1841 1842 1843
        bs->total_sectors = 0;
        bs->encrypted = 0;
        bs->valid_key = 0;
        bs->sg = 0;
        bs->growable = 0;
A
Asias He 已提交
1844
        bs->zero_beyond_eof = false;
1845 1846
        QDECREF(bs->options);
        bs->options = NULL;
B
bellard 已提交
1847

1848
        if (bs->file != NULL) {
F
Fam Zheng 已提交
1849
            bdrv_unref(bs->file);
1850
            bs->file = NULL;
1851
        }
B
bellard 已提交
1852
    }
Z
Zhi Yong Wu 已提交
1853

P
Pavel Hrdina 已提交
1854 1855
    bdrv_dev_change_media_cb(bs, false);

Z
Zhi Yong Wu 已提交
1856 1857 1858 1859
    /*throttling disk I/O limits*/
    if (bs->io_limits_enabled) {
        bdrv_io_limits_disable(bs);
    }
B
bellard 已提交
1860 1861
}

1862 1863 1864 1865
void bdrv_close_all(void)
{
    BlockDriverState *bs;

1866
    QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
1867 1868 1869
        AioContext *aio_context = bdrv_get_aio_context(bs);

        aio_context_acquire(aio_context);
1870
        bdrv_close(bs);
1871
        aio_context_release(aio_context);
1872 1873 1874
    }
}

1875 1876 1877 1878 1879 1880
/* Check if any requests are in-flight (including throttled requests) */
static bool bdrv_requests_pending(BlockDriverState *bs)
{
    if (!QLIST_EMPTY(&bs->tracked_requests)) {
        return true;
    }
1881 1882 1883 1884
    if (!qemu_co_queue_empty(&bs->throttled_reqs[0])) {
        return true;
    }
    if (!qemu_co_queue_empty(&bs->throttled_reqs[1])) {
1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895
        return true;
    }
    if (bs->file && bdrv_requests_pending(bs->file)) {
        return true;
    }
    if (bs->backing_hd && bdrv_requests_pending(bs->backing_hd)) {
        return true;
    }
    return false;
}

1896 1897 1898 1899 1900
/*
 * 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.
1901 1902 1903 1904 1905 1906
 *
 * 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.
1907 1908 1909
 */
void bdrv_drain_all(void)
{
1910 1911
    /* Always run first iteration so any pending completion BHs run */
    bool busy = true;
1912 1913
    BlockDriverState *bs;

1914
    while (busy) {
1915 1916
        busy = false;

1917
        QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
1918 1919 1920 1921
            AioContext *aio_context = bdrv_get_aio_context(bs);
            bool bs_busy;

            aio_context_acquire(aio_context);
1922
            bdrv_flush_io_queue(bs);
1923
            bdrv_start_throttled_reqs(bs);
1924 1925 1926
            bs_busy = bdrv_requests_pending(bs);
            bs_busy |= aio_poll(aio_context, bs_busy);
            aio_context_release(aio_context);
1927

1928 1929
            busy |= bs_busy;
        }
1930 1931 1932
    }
}

1933 1934
/* make a BlockDriverState anonymous by removing from bdrv_state and
 * graph_bdrv_state list.
1935 1936 1937 1938
   Also, NULL terminate the device_name to prevent double remove */
void bdrv_make_anon(BlockDriverState *bs)
{
    if (bs->device_name[0] != '\0') {
1939
        QTAILQ_REMOVE(&bdrv_states, bs, device_list);
1940 1941
    }
    bs->device_name[0] = '\0';
1942 1943 1944 1945
    if (bs->node_name[0] != '\0') {
        QTAILQ_REMOVE(&graph_bdrv_states, bs, node_list);
    }
    bs->node_name[0] = '\0';
1946 1947
}

P
Paolo Bonzini 已提交
1948 1949 1950 1951 1952 1953 1954
static void bdrv_rebind(BlockDriverState *bs)
{
    if (bs->drv && bs->drv->bdrv_rebind) {
        bs->drv->bdrv_rebind(bs);
    }
}

1955 1956
static void bdrv_move_feature_fields(BlockDriverState *bs_dest,
                                     BlockDriverState *bs_src)
1957
{
1958
    /* move some fields that need to stay attached to the device */
1959 1960

    /* dev info */
1961 1962 1963
    bs_dest->dev_ops            = bs_src->dev_ops;
    bs_dest->dev_opaque         = bs_src->dev_opaque;
    bs_dest->dev                = bs_src->dev;
1964
    bs_dest->guest_block_size   = bs_src->guest_block_size;
1965
    bs_dest->copy_on_read       = bs_src->copy_on_read;
1966

1967
    bs_dest->enable_write_cache = bs_src->enable_write_cache;
1968

1969 1970 1971 1972 1973 1974
    /* i/o throttled req */
    memcpy(&bs_dest->throttle_state,
           &bs_src->throttle_state,
           sizeof(ThrottleState));
    bs_dest->throttled_reqs[0]  = bs_src->throttled_reqs[0];
    bs_dest->throttled_reqs[1]  = bs_src->throttled_reqs[1];
1975
    bs_dest->io_limits_enabled  = bs_src->io_limits_enabled;
1976 1977

    /* r/w error */
1978 1979
    bs_dest->on_read_error      = bs_src->on_read_error;
    bs_dest->on_write_error     = bs_src->on_write_error;
1980 1981

    /* i/o status */
1982 1983
    bs_dest->iostatus_enabled   = bs_src->iostatus_enabled;
    bs_dest->iostatus           = bs_src->iostatus;
1984

1985
    /* dirty bitmap */
F
Fam Zheng 已提交
1986
    bs_dest->dirty_bitmaps      = bs_src->dirty_bitmaps;
1987

1988 1989 1990
    /* reference count */
    bs_dest->refcnt             = bs_src->refcnt;

1991
    /* job */
1992
    bs_dest->job                = bs_src->job;
1993

1994
    /* keep the same entry in bdrv_states */
1995 1996
    pstrcpy(bs_dest->device_name, sizeof(bs_dest->device_name),
            bs_src->device_name);
1997
    bs_dest->device_list = bs_src->device_list;
1998 1999
    memcpy(bs_dest->op_blockers, bs_src->op_blockers,
           sizeof(bs_dest->op_blockers));
2000
}
2001

2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016
/*
 * 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;
J
Jeff Cody 已提交
2017

2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028
    /* The code needs to swap the node_name but simply swapping node_list won't
     * work so first remove the nodes from the graph list, do the swap then
     * insert them back if needed.
     */
    if (bs_new->node_name[0] != '\0') {
        QTAILQ_REMOVE(&graph_bdrv_states, bs_new, node_list);
    }
    if (bs_old->node_name[0] != '\0') {
        QTAILQ_REMOVE(&graph_bdrv_states, bs_old, node_list);
    }

2029 2030
    /* bs_new must be anonymous and shouldn't have anything fancy enabled */
    assert(bs_new->device_name[0] == '\0');
F
Fam Zheng 已提交
2031
    assert(QLIST_EMPTY(&bs_new->dirty_bitmaps));
2032 2033 2034
    assert(bs_new->job == NULL);
    assert(bs_new->dev == NULL);
    assert(bs_new->io_limits_enabled == false);
2035
    assert(!throttle_have_timer(&bs_new->throttle_state));
2036

2037 2038 2039
    tmp = *bs_new;
    *bs_new = *bs_old;
    *bs_old = tmp;
2040

2041 2042 2043 2044
    /* 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);
2045

2046 2047 2048 2049 2050 2051 2052
    /* 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->io_limits_enabled == false);
2053
    assert(!throttle_have_timer(&bs_new->throttle_state));
P
Paolo Bonzini 已提交
2054

2055 2056 2057 2058 2059 2060 2061 2062
    /* insert the nodes back into the graph node list if needed */
    if (bs_new->node_name[0] != '\0') {
        QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs_new, node_list);
    }
    if (bs_old->node_name[0] != '\0') {
        QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs_old, node_list);
    }

P
Paolo Bonzini 已提交
2063
    bdrv_rebind(bs_new);
2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083
    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. */
F
Fam Zheng 已提交
2084
    bdrv_set_backing_hd(bs_top, bs_new);
2085 2086
}

F
Fam Zheng 已提交
2087
static void bdrv_delete(BlockDriverState *bs)
B
bellard 已提交
2088
{
2089
    assert(!bs->dev);
2090
    assert(!bs->job);
2091
    assert(bdrv_op_blocker_is_empty(bs));
F
Fam Zheng 已提交
2092
    assert(!bs->refcnt);
F
Fam Zheng 已提交
2093
    assert(QLIST_EMPTY(&bs->dirty_bitmaps));
2094

2095 2096
    bdrv_close(bs);

2097
    /* remove from list, if necessary */
2098
    bdrv_make_anon(bs);
2099

2100
    g_free(bs);
B
bellard 已提交
2101 2102
}

2103 2104
int bdrv_attach_dev(BlockDriverState *bs, void *dev)
/* TODO change to DeviceState *dev when all users are qdevified */
2105
{
2106
    if (bs->dev) {
2107 2108
        return -EBUSY;
    }
2109
    bs->dev = dev;
2110
    bdrv_iostatus_reset(bs);
2111 2112 2113
    return 0;
}

2114 2115
/* TODO qdevified devices don't use this, remove when devices are qdevified */
void bdrv_attach_dev_nofail(BlockDriverState *bs, void *dev)
2116
{
2117 2118 2119 2120 2121 2122 2123 2124 2125 2126
    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;
2127 2128
    bs->dev_ops = NULL;
    bs->dev_opaque = NULL;
2129
    bs->guest_block_size = 512;
2130 2131
}

2132 2133
/* TODO change to return DeviceState * when all users are qdevified */
void *bdrv_get_attached_dev(BlockDriverState *bs)
2134
{
2135
    return bs->dev;
2136 2137
}

2138 2139 2140 2141 2142 2143 2144
void bdrv_set_dev_ops(BlockDriverState *bs, const BlockDevOps *ops,
                      void *opaque)
{
    bs->dev_ops = ops;
    bs->dev_opaque = opaque;
}

2145
static void bdrv_dev_change_media_cb(BlockDriverState *bs, bool load)
2146
{
2147
    if (bs->dev_ops && bs->dev_ops->change_media_cb) {
2148
        bool tray_was_closed = !bdrv_dev_is_tray_open(bs);
2149
        bs->dev_ops->change_media_cb(bs->dev_opaque, load);
2150 2151
        if (tray_was_closed) {
            /* tray open */
2152 2153
            qapi_event_send_device_tray_moved(bdrv_get_device_name(bs),
                                              true, &error_abort);
2154 2155 2156
        }
        if (load) {
            /* tray close */
2157 2158
            qapi_event_send_device_tray_moved(bdrv_get_device_name(bs),
                                              false, &error_abort);
2159
        }
2160 2161 2162
    }
}

2163 2164 2165 2166 2167
bool bdrv_dev_has_removable_media(BlockDriverState *bs)
{
    return !bs->dev || (bs->dev_ops && bs->dev_ops->change_media_cb);
}

P
Paolo Bonzini 已提交
2168 2169 2170 2171 2172 2173 2174
void bdrv_dev_eject_request(BlockDriverState *bs, bool force)
{
    if (bs->dev_ops && bs->dev_ops->eject_request_cb) {
        bs->dev_ops->eject_request_cb(bs->dev_opaque, force);
    }
}

2175 2176 2177 2178 2179 2180 2181 2182
bool bdrv_dev_is_tray_open(BlockDriverState *bs)
{
    if (bs->dev_ops && bs->dev_ops->is_tray_open) {
        return bs->dev_ops->is_tray_open(bs->dev_opaque);
    }
    return false;
}

2183 2184 2185 2186
static void bdrv_dev_resize_cb(BlockDriverState *bs)
{
    if (bs->dev_ops && bs->dev_ops->resize_cb) {
        bs->dev_ops->resize_cb(bs->dev_opaque);
2187 2188 2189
    }
}

2190 2191 2192 2193 2194 2195 2196 2197
bool bdrv_dev_is_medium_locked(BlockDriverState *bs)
{
    if (bs->dev_ops && bs->dev_ops->is_medium_locked) {
        return bs->dev_ops->is_medium_locked(bs->dev_opaque);
    }
    return false;
}

A
aliguori 已提交
2198 2199 2200
/*
 * Run consistency checks on an image
 *
2201
 * Returns 0 if the check could be completed (it doesn't mean that the image is
2202
 * free of errors) or -errno when an internal error occurred. The results of the
2203
 * check are stored in res.
A
aliguori 已提交
2204
 */
2205
int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix)
A
aliguori 已提交
2206 2207 2208 2209 2210
{
    if (bs->drv->bdrv_check == NULL) {
        return -ENOTSUP;
    }

2211
    memset(res, 0, sizeof(*res));
2212
    return bs->drv->bdrv_check(bs, res, fix);
A
aliguori 已提交
2213 2214
}

2215 2216
#define COMMIT_BUF_SECTORS 2048

2217 2218 2219
/* commit COW file into the raw image */
int bdrv_commit(BlockDriverState *bs)
{
B
bellard 已提交
2220
    BlockDriver *drv = bs->drv;
2221
    int64_t sector, total_sectors, length, backing_length;
2222
    int n, ro, open_flags;
2223
    int ret = 0;
2224
    uint8_t *buf = NULL;
2225
    char filename[PATH_MAX];
2226

B
bellard 已提交
2227 2228
    if (!drv)
        return -ENOMEDIUM;
2229 2230 2231
    
    if (!bs->backing_hd) {
        return -ENOTSUP;
2232 2233
    }

2234 2235
    if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_COMMIT, NULL) ||
        bdrv_op_is_blocked(bs->backing_hd, BLOCK_OP_TYPE_COMMIT, NULL)) {
2236 2237 2238
        return -EBUSY;
    }

2239
    ro = bs->backing_hd->read_only;
2240 2241
    /* Use pstrcpy (not strncpy): filename must be NUL-terminated. */
    pstrcpy(filename, sizeof(filename), bs->backing_hd->filename);
2242 2243 2244
    open_flags =  bs->backing_hd->open_flags;

    if (ro) {
2245 2246
        if (bdrv_reopen(bs->backing_hd, open_flags | BDRV_O_RDWR, NULL)) {
            return -EACCES;
2247
        }
B
bellard 已提交
2248
    }
2249

2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272
    length = bdrv_getlength(bs);
    if (length < 0) {
        ret = length;
        goto ro_cleanup;
    }

    backing_length = bdrv_getlength(bs->backing_hd);
    if (backing_length < 0) {
        ret = backing_length;
        goto ro_cleanup;
    }

    /* If our top snapshot is larger than the backing file image,
     * grow the backing file image if possible.  If not possible,
     * we must return an error */
    if (length > backing_length) {
        ret = bdrv_truncate(bs->backing_hd, length);
        if (ret < 0) {
            goto ro_cleanup;
        }
    }

    total_sectors = length >> BDRV_SECTOR_BITS;
2273
    buf = g_malloc(COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE);
2274 2275

    for (sector = 0; sector < total_sectors; sector += n) {
2276 2277 2278 2279 2280
        ret = bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n);
        if (ret < 0) {
            goto ro_cleanup;
        }
        if (ret) {
K
Kevin Wolf 已提交
2281 2282
            ret = bdrv_read(bs, sector, buf, n);
            if (ret < 0) {
2283 2284 2285
                goto ro_cleanup;
            }

K
Kevin Wolf 已提交
2286 2287
            ret = bdrv_write(bs->backing_hd, sector, buf, n);
            if (ret < 0) {
2288 2289
                goto ro_cleanup;
            }
B
bellard 已提交
2290
        }
2291
    }
2292

2293 2294
    if (drv->bdrv_make_empty) {
        ret = drv->bdrv_make_empty(bs);
K
Kevin Wolf 已提交
2295 2296 2297
        if (ret < 0) {
            goto ro_cleanup;
        }
2298 2299
        bdrv_flush(bs);
    }
2300

2301 2302 2303 2304
    /*
     * Make sure all data we wrote to the backing device is actually
     * stable on disk.
     */
K
Kevin Wolf 已提交
2305
    if (bs->backing_hd) {
2306
        bdrv_flush(bs->backing_hd);
K
Kevin Wolf 已提交
2307
    }
2308

K
Kevin Wolf 已提交
2309
    ret = 0;
2310
ro_cleanup:
2311
    g_free(buf);
2312 2313

    if (ro) {
2314 2315
        /* ignoring error return here */
        bdrv_reopen(bs->backing_hd, open_flags & ~BDRV_O_RDWR, NULL);
2316 2317
    }

2318
    return ret;
2319 2320
}

2321
int bdrv_commit_all(void)
2322 2323 2324
{
    BlockDriverState *bs;

2325
    QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
2326 2327 2328
        AioContext *aio_context = bdrv_get_aio_context(bs);

        aio_context_acquire(aio_context);
2329 2330 2331
        if (bs->drv && bs->backing_hd) {
            int ret = bdrv_commit(bs);
            if (ret < 0) {
2332
                aio_context_release(aio_context);
2333 2334
                return ret;
            }
2335
        }
2336
        aio_context_release(aio_context);
2337
    }
2338
    return 0;
2339 2340
}

S
Stefan Hajnoczi 已提交
2341 2342 2343 2344 2345 2346 2347
/**
 * Remove an active request from the tracked requests list
 *
 * This function should be called when a tracked request is completing.
 */
static void tracked_request_end(BdrvTrackedRequest *req)
{
2348 2349 2350 2351
    if (req->serialising) {
        req->bs->serialising_in_flight--;
    }

S
Stefan Hajnoczi 已提交
2352
    QLIST_REMOVE(req, list);
2353
    qemu_co_queue_restart_all(&req->wait_queue);
S
Stefan Hajnoczi 已提交
2354 2355 2356 2357 2358 2359 2360
}

/**
 * Add an active request to the tracked requests list
 */
static void tracked_request_begin(BdrvTrackedRequest *req,
                                  BlockDriverState *bs,
2361 2362
                                  int64_t offset,
                                  unsigned int bytes, bool is_write)
S
Stefan Hajnoczi 已提交
2363 2364 2365
{
    *req = (BdrvTrackedRequest){
        .bs = bs,
2366 2367 2368 2369 2370
        .offset         = offset,
        .bytes          = bytes,
        .is_write       = is_write,
        .co             = qemu_coroutine_self(),
        .serialising    = false,
2371 2372
        .overlap_offset = offset,
        .overlap_bytes  = bytes,
S
Stefan Hajnoczi 已提交
2373 2374
    };

2375 2376
    qemu_co_queue_init(&req->wait_queue);

S
Stefan Hajnoczi 已提交
2377 2378 2379
    QLIST_INSERT_HEAD(&bs->tracked_requests, req, list);
}

2380
static void mark_request_serialising(BdrvTrackedRequest *req, uint64_t align)
2381
{
2382
    int64_t overlap_offset = req->offset & ~(align - 1);
2383 2384
    unsigned int overlap_bytes = ROUND_UP(req->offset + req->bytes, align)
                               - overlap_offset;
2385

2386 2387 2388 2389
    if (!req->serialising) {
        req->bs->serialising_in_flight++;
        req->serialising = true;
    }
2390 2391 2392

    req->overlap_offset = MIN(req->overlap_offset, overlap_offset);
    req->overlap_bytes = MAX(req->overlap_bytes, overlap_bytes);
2393 2394
}

S
Stefan Hajnoczi 已提交
2395 2396 2397
/**
 * Round a region to cluster boundaries
 */
2398 2399 2400 2401
void bdrv_round_to_clusters(BlockDriverState *bs,
                            int64_t sector_num, int nb_sectors,
                            int64_t *cluster_sector_num,
                            int *cluster_nb_sectors)
S
Stefan Hajnoczi 已提交
2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415
{
    BlockDriverInfo bdi;

    if (bdrv_get_info(bs, &bdi) < 0 || bdi.cluster_size == 0) {
        *cluster_sector_num = sector_num;
        *cluster_nb_sectors = nb_sectors;
    } else {
        int64_t c = bdi.cluster_size / BDRV_SECTOR_SIZE;
        *cluster_sector_num = QEMU_ALIGN_DOWN(sector_num, c);
        *cluster_nb_sectors = QEMU_ALIGN_UP(sector_num - *cluster_sector_num +
                                            nb_sectors, c);
    }
}

2416
static int bdrv_get_cluster_size(BlockDriverState *bs)
2417 2418
{
    BlockDriverInfo bdi;
2419
    int ret;
2420

2421 2422 2423
    ret = bdrv_get_info(bs, &bdi);
    if (ret < 0 || bdi.cluster_size == 0) {
        return bs->request_alignment;
2424
    } else {
2425
        return bdi.cluster_size;
2426 2427 2428
    }
}

2429
static bool tracked_request_overlaps(BdrvTrackedRequest *req,
2430 2431
                                     int64_t offset, unsigned int bytes)
{
S
Stefan Hajnoczi 已提交
2432
    /*        aaaa   bbbb */
2433
    if (offset >= req->overlap_offset + req->overlap_bytes) {
S
Stefan Hajnoczi 已提交
2434 2435 2436
        return false;
    }
    /* bbbb   aaaa        */
2437
    if (req->overlap_offset >= offset + bytes) {
S
Stefan Hajnoczi 已提交
2438 2439 2440
        return false;
    }
    return true;
2441 2442
}

2443
static bool coroutine_fn wait_serialising_requests(BdrvTrackedRequest *self)
2444
{
2445
    BlockDriverState *bs = self->bs;
2446 2447
    BdrvTrackedRequest *req;
    bool retry;
2448
    bool waited = false;
2449

2450
    if (!bs->serialising_in_flight) {
2451
        return false;
2452 2453
    }

2454 2455 2456
    do {
        retry = false;
        QLIST_FOREACH(req, &bs->tracked_requests, list) {
2457
            if (req == self || (!req->serialising && !self->serialising)) {
2458 2459
                continue;
            }
2460 2461 2462
            if (tracked_request_overlaps(req, self->overlap_offset,
                                         self->overlap_bytes))
            {
2463 2464 2465 2466 2467 2468
                /* Hitting this means there was a reentrant request, for
                 * example, a block driver issuing nested requests.  This must
                 * never happen since it means deadlock.
                 */
                assert(qemu_coroutine_self() != req->co);

2469 2470 2471 2472 2473 2474 2475 2476
                /* If the request is already (indirectly) waiting for us, or
                 * will wait for us as soon as it wakes up, then just go on
                 * (instead of producing a deadlock in the former case). */
                if (!req->waiting_for) {
                    self->waiting_for = req;
                    qemu_co_queue_wait(&req->wait_queue);
                    self->waiting_for = NULL;
                    retry = true;
2477
                    waited = true;
2478 2479
                    break;
                }
2480 2481 2482
            }
        }
    } while (retry);
2483 2484

    return waited;
2485 2486
}

K
Kevin Wolf 已提交
2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498
/*
 * Return values:
 * 0        - success
 * -EINVAL  - backing format specified, but no file
 * -ENOSPC  - can't update the backing file because no space is left in the
 *            image file header
 * -ENOTSUP - format driver doesn't support changing the backing file
 */
int bdrv_change_backing_file(BlockDriverState *bs,
    const char *backing_file, const char *backing_fmt)
{
    BlockDriver *drv = bs->drv;
2499
    int ret;
K
Kevin Wolf 已提交
2500

2501 2502 2503 2504 2505
    /* Backing file format doesn't make sense without a backing file */
    if (backing_fmt && !backing_file) {
        return -EINVAL;
    }

K
Kevin Wolf 已提交
2506
    if (drv->bdrv_change_backing_file != NULL) {
2507
        ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
K
Kevin Wolf 已提交
2508
    } else {
2509
        ret = -ENOTSUP;
K
Kevin Wolf 已提交
2510
    }
2511 2512 2513 2514 2515 2516

    if (ret == 0) {
        pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
        pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
    }
    return ret;
K
Kevin Wolf 已提交
2517 2518
}

2519 2520 2521 2522 2523 2524 2525
/*
 * Finds the image layer in the chain that has 'bs' as its backing file.
 *
 * active is the current topmost image.
 *
 * Returns NULL if bs is not found in active's image chain,
 * or if active == bs.
2526 2527
 *
 * Returns the bottommost base image if bs == NULL.
2528 2529 2530 2531
 */
BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
                                    BlockDriverState *bs)
{
2532 2533
    while (active && bs != active->backing_hd) {
        active = active->backing_hd;
2534 2535
    }

2536 2537
    return active;
}
2538

2539 2540 2541 2542
/* Given a BDS, searches for the base layer. */
BlockDriverState *bdrv_find_base(BlockDriverState *bs)
{
    return bdrv_find_overlay(bs, NULL);
2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572
}

typedef struct BlkIntermediateStates {
    BlockDriverState *bs;
    QSIMPLEQ_ENTRY(BlkIntermediateStates) entry;
} BlkIntermediateStates;


/*
 * Drops images above 'base' up to and including 'top', and sets the image
 * above 'top' to have base as its backing file.
 *
 * Requires that the overlay to 'top' is opened r/w, so that the backing file
 * information in 'bs' can be properly updated.
 *
 * E.g., this will convert the following chain:
 * bottom <- base <- intermediate <- top <- active
 *
 * to
 *
 * bottom <- base <- active
 *
 * It is allowed for bottom==base, in which case it converts:
 *
 * base <- intermediate <- top <- active
 *
 * to
 *
 * base <- active
 *
2573 2574 2575
 * If backing_file_str is non-NULL, it will be used when modifying top's
 * overlay image metadata.
 *
2576 2577 2578 2579 2580
 * Error conditions:
 *  if active == top, that is considered an error
 *
 */
int bdrv_drop_intermediate(BlockDriverState *active, BlockDriverState *top,
2581
                           BlockDriverState *base, const char *backing_file_str)
2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632
{
    BlockDriverState *intermediate;
    BlockDriverState *base_bs = NULL;
    BlockDriverState *new_top_bs = NULL;
    BlkIntermediateStates *intermediate_state, *next;
    int ret = -EIO;

    QSIMPLEQ_HEAD(states_to_delete, BlkIntermediateStates) states_to_delete;
    QSIMPLEQ_INIT(&states_to_delete);

    if (!top->drv || !base->drv) {
        goto exit;
    }

    new_top_bs = bdrv_find_overlay(active, top);

    if (new_top_bs == NULL) {
        /* we could not find the image above 'top', this is an error */
        goto exit;
    }

    /* special case of new_top_bs->backing_hd already pointing to base - nothing
     * to do, no intermediate images */
    if (new_top_bs->backing_hd == base) {
        ret = 0;
        goto exit;
    }

    intermediate = top;

    /* now we will go down through the list, and add each BDS we find
     * into our deletion queue, until we hit the 'base'
     */
    while (intermediate) {
        intermediate_state = g_malloc0(sizeof(BlkIntermediateStates));
        intermediate_state->bs = intermediate;
        QSIMPLEQ_INSERT_TAIL(&states_to_delete, intermediate_state, entry);

        if (intermediate->backing_hd == base) {
            base_bs = intermediate->backing_hd;
            break;
        }
        intermediate = intermediate->backing_hd;
    }
    if (base_bs == NULL) {
        /* something went wrong, we did not end at the base. safely
         * unravel everything, and exit with error */
        goto exit;
    }

    /* success - we can delete the intermediate states, and link top->base */
2633 2634
    backing_file_str = backing_file_str ? backing_file_str : base_bs->filename;
    ret = bdrv_change_backing_file(new_top_bs, backing_file_str,
2635 2636 2637 2638
                                   base_bs->drv ? base_bs->drv->format_name : "");
    if (ret) {
        goto exit;
    }
2639
    bdrv_set_backing_hd(new_top_bs, base_bs);
2640 2641 2642

    QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) {
        /* so that bdrv_close() does not recursively close the chain */
2643
        bdrv_set_backing_hd(intermediate_state->bs, NULL);
F
Fam Zheng 已提交
2644
        bdrv_unref(intermediate_state->bs);
2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655
    }
    ret = 0;

exit:
    QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) {
        g_free(intermediate_state);
    }
    return ret;
}


2656 2657 2658 2659 2660
static int bdrv_check_byte_request(BlockDriverState *bs, int64_t offset,
                                   size_t size)
{
    int64_t len;

2661 2662 2663 2664
    if (size > INT_MAX) {
        return -EIO;
    }

2665 2666 2667 2668 2669 2670 2671 2672
    if (!bdrv_is_inserted(bs))
        return -ENOMEDIUM;

    if (bs->growable)
        return 0;

    len = bdrv_getlength(bs);

K
Kevin Wolf 已提交
2673 2674 2675 2676
    if (offset < 0)
        return -EIO;

    if ((offset > len) || (len - offset < size))
2677 2678 2679 2680 2681 2682 2683 2684
        return -EIO;

    return 0;
}

static int bdrv_check_request(BlockDriverState *bs, int64_t sector_num,
                              int nb_sectors)
{
2685
    if (nb_sectors < 0 || nb_sectors > INT_MAX / BDRV_SECTOR_SIZE) {
2686 2687 2688
        return -EIO;
    }

2689 2690
    return bdrv_check_byte_request(bs, sector_num * BDRV_SECTOR_SIZE,
                                   nb_sectors * BDRV_SECTOR_SIZE);
2691 2692
}

2693 2694
typedef struct RwCo {
    BlockDriverState *bs;
2695
    int64_t offset;
2696 2697 2698
    QEMUIOVector *qiov;
    bool is_write;
    int ret;
P
Peter Lieven 已提交
2699
    BdrvRequestFlags flags;
2700 2701 2702
} RwCo;

static void coroutine_fn bdrv_rw_co_entry(void *opaque)
B
bellard 已提交
2703
{
2704
    RwCo *rwco = opaque;
B
bellard 已提交
2705

2706
    if (!rwco->is_write) {
2707 2708
        rwco->ret = bdrv_co_do_preadv(rwco->bs, rwco->offset,
                                      rwco->qiov->size, rwco->qiov,
P
Peter Lieven 已提交
2709
                                      rwco->flags);
2710 2711 2712 2713
    } else {
        rwco->ret = bdrv_co_do_pwritev(rwco->bs, rwco->offset,
                                       rwco->qiov->size, rwco->qiov,
                                       rwco->flags);
2714 2715
    }
}
2716

2717
/*
2718
 * Process a vectored synchronous request using coroutines
2719
 */
2720 2721 2722
static int bdrv_prwv_co(BlockDriverState *bs, int64_t offset,
                        QEMUIOVector *qiov, bool is_write,
                        BdrvRequestFlags flags)
2723 2724 2725 2726
{
    Coroutine *co;
    RwCo rwco = {
        .bs = bs,
2727
        .offset = offset,
2728
        .qiov = qiov,
2729 2730
        .is_write = is_write,
        .ret = NOT_DONE,
P
Peter Lieven 已提交
2731
        .flags = flags,
2732
    };
2733

2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744
    /**
     * In sync call context, when the vcpu is blocked, this throttling timer
     * will not fire; so the I/O throttling function has to be disabled here
     * if it has been enabled.
     */
    if (bs->io_limits_enabled) {
        fprintf(stderr, "Disabling I/O throttling on '%s' due "
                        "to synchronous I/O.\n", bdrv_get_device_name(bs));
        bdrv_io_limits_disable(bs);
    }

2745 2746 2747 2748
    if (qemu_in_coroutine()) {
        /* Fast-path if already in coroutine context */
        bdrv_rw_co_entry(&rwco);
    } else {
2749 2750
        AioContext *aio_context = bdrv_get_aio_context(bs);

2751 2752 2753
        co = qemu_coroutine_create(bdrv_rw_co_entry);
        qemu_coroutine_enter(co, &rwco);
        while (rwco.ret == NOT_DONE) {
2754
            aio_poll(aio_context, true);
2755 2756 2757 2758
        }
    }
    return rwco.ret;
}
B
bellard 已提交
2759

2760 2761 2762 2763
/*
 * Process a synchronous request using coroutines
 */
static int bdrv_rw_co(BlockDriverState *bs, int64_t sector_num, uint8_t *buf,
P
Peter Lieven 已提交
2764
                      int nb_sectors, bool is_write, BdrvRequestFlags flags)
2765 2766 2767 2768 2769 2770 2771
{
    QEMUIOVector qiov;
    struct iovec iov = {
        .iov_base = (void *)buf,
        .iov_len = nb_sectors * BDRV_SECTOR_SIZE,
    };

2772 2773 2774 2775
    if (nb_sectors < 0 || nb_sectors > INT_MAX / BDRV_SECTOR_SIZE) {
        return -EINVAL;
    }

2776
    qemu_iovec_init_external(&qiov, &iov, 1);
2777 2778
    return bdrv_prwv_co(bs, sector_num << BDRV_SECTOR_BITS,
                        &qiov, is_write, flags);
2779 2780
}

2781 2782 2783 2784
/* return < 0 if error. See bdrv_write() for the return codes */
int bdrv_read(BlockDriverState *bs, int64_t sector_num,
              uint8_t *buf, int nb_sectors)
{
P
Peter Lieven 已提交
2785
    return bdrv_rw_co(bs, sector_num, buf, nb_sectors, false, 0);
B
bellard 已提交
2786 2787
}

2788 2789 2790 2791 2792 2793 2794 2795 2796
/* Just like bdrv_read(), but with I/O throttling temporarily disabled */
int bdrv_read_unthrottled(BlockDriverState *bs, int64_t sector_num,
                          uint8_t *buf, int nb_sectors)
{
    bool enabled;
    int ret;

    enabled = bs->io_limits_enabled;
    bs->io_limits_enabled = false;
2797
    ret = bdrv_read(bs, sector_num, buf, nb_sectors);
2798 2799 2800 2801
    bs->io_limits_enabled = enabled;
    return ret;
}

2802
/* Return < 0 if error. Important errors are:
B
bellard 已提交
2803 2804 2805 2806 2807
  -EIO         generic I/O error (may happen for all errors)
  -ENOMEDIUM   No media inserted.
  -EINVAL      Invalid sector number or nb_sectors
  -EACCES      Trying to write a read-only device
*/
2808
int bdrv_write(BlockDriverState *bs, int64_t sector_num,
B
bellard 已提交
2809 2810
               const uint8_t *buf, int nb_sectors)
{
P
Peter Lieven 已提交
2811
    return bdrv_rw_co(bs, sector_num, (uint8_t *)buf, nb_sectors, true, 0);
B
bellard 已提交
2812 2813
}

2814 2815
int bdrv_write_zeroes(BlockDriverState *bs, int64_t sector_num,
                      int nb_sectors, BdrvRequestFlags flags)
P
Peter Lieven 已提交
2816 2817
{
    return bdrv_rw_co(bs, sector_num, NULL, nb_sectors, true,
2818
                      BDRV_REQ_ZERO_WRITE | flags);
2819 2820
}

P
Peter Lieven 已提交
2821 2822 2823 2824 2825 2826 2827 2828 2829 2830
/*
 * Completely zero out a block device with the help of bdrv_write_zeroes.
 * The operation is sped up by checking the block status and only writing
 * zeroes to the device if they currently do not return zeroes. Optional
 * flags are passed through to bdrv_write_zeroes (e.g. BDRV_REQ_MAY_UNMAP).
 *
 * Returns < 0 on error, 0 on success. For error codes see bdrv_write().
 */
int bdrv_make_zero(BlockDriverState *bs, BdrvRequestFlags flags)
{
2831
    int64_t target_sectors, ret, nb_sectors, sector_num = 0;
P
Peter Lieven 已提交
2832 2833
    int n;

2834 2835 2836
    target_sectors = bdrv_nb_sectors(bs);
    if (target_sectors < 0) {
        return target_sectors;
2837 2838
    }

P
Peter Lieven 已提交
2839
    for (;;) {
2840
        nb_sectors = target_sectors - sector_num;
P
Peter Lieven 已提交
2841 2842 2843 2844 2845 2846 2847
        if (nb_sectors <= 0) {
            return 0;
        }
        if (nb_sectors > INT_MAX) {
            nb_sectors = INT_MAX;
        }
        ret = bdrv_get_block_status(bs, sector_num, nb_sectors, &n);
2848 2849 2850 2851 2852
        if (ret < 0) {
            error_report("error getting block status at sector %" PRId64 ": %s",
                         sector_num, strerror(-ret));
            return ret;
        }
P
Peter Lieven 已提交
2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866
        if (ret & BDRV_BLOCK_ZERO) {
            sector_num += n;
            continue;
        }
        ret = bdrv_write_zeroes(bs, sector_num, n, flags);
        if (ret < 0) {
            error_report("error writing zeroes at sector %" PRId64 ": %s",
                         sector_num, strerror(-ret));
            return ret;
        }
        sector_num += n;
    }
}

2867
int bdrv_pread(BlockDriverState *bs, int64_t offset, void *buf, int bytes)
B
bellard 已提交
2868
{
2869 2870 2871 2872 2873
    QEMUIOVector qiov;
    struct iovec iov = {
        .iov_base = (void *)buf,
        .iov_len = bytes,
    };
2874
    int ret;
B
bellard 已提交
2875

2876 2877
    if (bytes < 0) {
        return -EINVAL;
B
bellard 已提交
2878 2879
    }

2880 2881 2882 2883
    qemu_iovec_init_external(&qiov, &iov, 1);
    ret = bdrv_prwv_co(bs, offset, &qiov, false, 0);
    if (ret < 0) {
        return ret;
B
bellard 已提交
2884
    }
2885 2886

    return bytes;
B
bellard 已提交
2887 2888
}

2889
int bdrv_pwritev(BlockDriverState *bs, int64_t offset, QEMUIOVector *qiov)
B
bellard 已提交
2890
{
2891
    int ret;
B
bellard 已提交
2892

2893 2894 2895
    ret = bdrv_prwv_co(bs, offset, qiov, true, 0);
    if (ret < 0) {
        return ret;
B
bellard 已提交
2896 2897
    }

2898 2899 2900 2901
    return qiov->size;
}

int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
2902
                const void *buf, int bytes)
2903 2904 2905 2906
{
    QEMUIOVector qiov;
    struct iovec iov = {
        .iov_base   = (void *) buf,
2907
        .iov_len    = bytes,
2908 2909
    };

2910 2911 2912 2913
    if (bytes < 0) {
        return -EINVAL;
    }

2914 2915
    qemu_iovec_init_external(&qiov, &iov, 1);
    return bdrv_pwritev(bs, offset, &qiov);
B
bellard 已提交
2916 2917
}

K
Kevin Wolf 已提交
2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933
/*
 * Writes to the file and ensures that no writes are reordered across this
 * request (acts as a barrier)
 *
 * Returns 0 on success, -errno in error cases.
 */
int bdrv_pwrite_sync(BlockDriverState *bs, int64_t offset,
    const void *buf, int count)
{
    int ret;

    ret = bdrv_pwrite(bs, offset, buf, count);
    if (ret < 0) {
        return ret;
    }

2934 2935
    /* No flush needed for cache modes that already do it */
    if (bs->enable_write_cache) {
K
Kevin Wolf 已提交
2936 2937 2938 2939 2940 2941
        bdrv_flush(bs);
    }

    return 0;
}

2942
static int coroutine_fn bdrv_co_do_copy_on_readv(BlockDriverState *bs,
S
Stefan Hajnoczi 已提交
2943 2944 2945 2946 2947 2948 2949 2950 2951
        int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
{
    /* Perform I/O through a temporary buffer so that users who scribble over
     * their read buffer while the operation is in progress do not end up
     * modifying the image file.  This is critical for zero-copy guest I/O
     * where anything might happen inside guest memory.
     */
    void *bounce_buffer;

2952
    BlockDriver *drv = bs->drv;
S
Stefan Hajnoczi 已提交
2953 2954 2955 2956 2957 2958 2959 2960 2961 2962
    struct iovec iov;
    QEMUIOVector bounce_qiov;
    int64_t cluster_sector_num;
    int cluster_nb_sectors;
    size_t skip_bytes;
    int ret;

    /* Cover entire cluster so no additional backing file I/O is required when
     * allocating cluster in the image file.
     */
2963 2964
    bdrv_round_to_clusters(bs, sector_num, nb_sectors,
                           &cluster_sector_num, &cluster_nb_sectors);
S
Stefan Hajnoczi 已提交
2965

2966 2967
    trace_bdrv_co_do_copy_on_readv(bs, sector_num, nb_sectors,
                                   cluster_sector_num, cluster_nb_sectors);
S
Stefan Hajnoczi 已提交
2968 2969 2970 2971 2972

    iov.iov_len = cluster_nb_sectors * BDRV_SECTOR_SIZE;
    iov.iov_base = bounce_buffer = qemu_blockalign(bs, iov.iov_len);
    qemu_iovec_init_external(&bounce_qiov, &iov, 1);

2973 2974
    ret = drv->bdrv_co_readv(bs, cluster_sector_num, cluster_nb_sectors,
                             &bounce_qiov);
S
Stefan Hajnoczi 已提交
2975 2976 2977 2978
    if (ret < 0) {
        goto err;
    }

2979 2980
    if (drv->bdrv_co_write_zeroes &&
        buffer_is_zero(bounce_buffer, iov.iov_len)) {
K
Kevin Wolf 已提交
2981
        ret = bdrv_co_do_write_zeroes(bs, cluster_sector_num,
2982
                                      cluster_nb_sectors, 0);
2983
    } else {
2984 2985 2986
        /* This does not change the data on the disk, it is not necessary
         * to flush even in cache=writethrough mode.
         */
2987
        ret = drv->bdrv_co_writev(bs, cluster_sector_num, cluster_nb_sectors,
S
Stefan Hajnoczi 已提交
2988
                                  &bounce_qiov);
2989 2990
    }

S
Stefan Hajnoczi 已提交
2991 2992 2993 2994 2995 2996 2997 2998 2999
    if (ret < 0) {
        /* It might be okay to ignore write errors for guest requests.  If this
         * is a deliberate copy-on-read then we don't want to ignore the error.
         * Simply report it in all cases.
         */
        goto err;
    }

    skip_bytes = (sector_num - cluster_sector_num) * BDRV_SECTOR_SIZE;
3000 3001
    qemu_iovec_from_buf(qiov, 0, bounce_buffer + skip_bytes,
                        nb_sectors * BDRV_SECTOR_SIZE);
S
Stefan Hajnoczi 已提交
3002 3003 3004 3005 3006 3007

err:
    qemu_vfree(bounce_buffer);
    return ret;
}

3008
/*
3009 3010 3011
 * Forwards an already correctly aligned request to the BlockDriver. This
 * handles copy on read and zeroing after EOF; any other features must be
 * implemented by the caller.
3012
 */
3013
static int coroutine_fn bdrv_aligned_preadv(BlockDriverState *bs,
3014
    BdrvTrackedRequest *req, int64_t offset, unsigned int bytes,
3015
    int64_t align, QEMUIOVector *qiov, int flags)
K
Kevin Wolf 已提交
3016 3017
{
    BlockDriver *drv = bs->drv;
S
Stefan Hajnoczi 已提交
3018
    int ret;
K
Kevin Wolf 已提交
3019

3020 3021
    int64_t sector_num = offset >> BDRV_SECTOR_BITS;
    unsigned int nb_sectors = bytes >> BDRV_SECTOR_BITS;
K
Kevin Wolf 已提交
3022

3023 3024
    assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0);
    assert((bytes & (BDRV_SECTOR_SIZE - 1)) == 0);
3025
    assert(!qiov || bytes == qiov->size);
3026 3027

    /* Handle Copy on Read and associated serialisation */
3028
    if (flags & BDRV_REQ_COPY_ON_READ) {
3029 3030 3031 3032 3033 3034
        /* If we touch the same cluster it counts as an overlap.  This
         * guarantees that allocating writes will be serialized and not race
         * with each other for the same cluster.  For example, in copy-on-read
         * it ensures that the CoR read and write operations are atomic and
         * guest writes cannot interleave between them. */
        mark_request_serialising(req, bdrv_get_cluster_size(bs));
3035 3036
    }

3037
    wait_serialising_requests(req);
3038

3039
    if (flags & BDRV_REQ_COPY_ON_READ) {
S
Stefan Hajnoczi 已提交
3040 3041
        int pnum;

3042
        ret = bdrv_is_allocated(bs, sector_num, nb_sectors, &pnum);
S
Stefan Hajnoczi 已提交
3043 3044 3045 3046 3047
        if (ret < 0) {
            goto out;
        }

        if (!ret || pnum != nb_sectors) {
3048
            ret = bdrv_co_do_copy_on_readv(bs, sector_num, nb_sectors, qiov);
S
Stefan Hajnoczi 已提交
3049 3050 3051 3052
            goto out;
        }
    }

3053
    /* Forward the request to the BlockDriver */
3054 3055 3056 3057
    if (!(bs->zero_beyond_eof && bs->growable)) {
        ret = drv->bdrv_co_readv(bs, sector_num, nb_sectors, qiov);
    } else {
        /* Read zeros after EOF of growable BDSes */
3058
        int64_t total_sectors, max_nb_sectors;
3059

3060 3061 3062
        total_sectors = bdrv_nb_sectors(bs);
        if (total_sectors < 0) {
            ret = total_sectors;
3063 3064 3065
            goto out;
        }

3066 3067
        max_nb_sectors = ROUND_UP(MAX(0, total_sectors - sector_num),
                                  align >> BDRV_SECTOR_BITS);
3068
        if (max_nb_sectors > 0) {
3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082
            QEMUIOVector local_qiov;
            size_t local_sectors;

            max_nb_sectors = MIN(max_nb_sectors, SIZE_MAX / BDRV_SECTOR_BITS);
            local_sectors = MIN(max_nb_sectors, nb_sectors);

            qemu_iovec_init(&local_qiov, qiov->niov);
            qemu_iovec_concat(&local_qiov, qiov, 0,
                              local_sectors * BDRV_SECTOR_SIZE);

            ret = drv->bdrv_co_readv(bs, sector_num, local_sectors,
                                     &local_qiov);

            qemu_iovec_destroy(&local_qiov);
3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094
        } else {
            ret = 0;
        }

        /* Reading beyond end of file is supposed to produce zeroes */
        if (ret == 0 && total_sectors < sector_num + nb_sectors) {
            uint64_t offset = MAX(0, total_sectors - sector_num);
            uint64_t bytes = (sector_num + nb_sectors - offset) *
                              BDRV_SECTOR_SIZE;
            qemu_iovec_memset(qiov, offset * BDRV_SECTOR_SIZE, 0, bytes);
        }
    }
S
Stefan Hajnoczi 已提交
3095 3096

out:
S
Stefan Hajnoczi 已提交
3097
    return ret;
K
Kevin Wolf 已提交
3098 3099
}

3100 3101 3102
/*
 * Handle a read request in coroutine context
 */
3103 3104
static int coroutine_fn bdrv_co_do_preadv(BlockDriverState *bs,
    int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
3105 3106 3107
    BdrvRequestFlags flags)
{
    BlockDriver *drv = bs->drv;
3108 3109
    BdrvTrackedRequest req;

3110 3111 3112 3113 3114 3115
    /* TODO Lift BDRV_SECTOR_SIZE restriction in BlockDriver interface */
    uint64_t align = MAX(BDRV_SECTOR_SIZE, bs->request_alignment);
    uint8_t *head_buf = NULL;
    uint8_t *tail_buf = NULL;
    QEMUIOVector local_qiov;
    bool use_local_qiov = false;
3116 3117 3118 3119 3120
    int ret;

    if (!drv) {
        return -ENOMEDIUM;
    }
3121
    if (bdrv_check_byte_request(bs, offset, bytes)) {
3122 3123 3124 3125 3126 3127 3128 3129 3130
        return -EIO;
    }

    if (bs->copy_on_read) {
        flags |= BDRV_REQ_COPY_ON_READ;
    }

    /* throttling disk I/O */
    if (bs->io_limits_enabled) {
3131
        bdrv_io_limits_intercept(bs, bytes, false);
3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158
    }

    /* Align read if necessary by padding qiov */
    if (offset & (align - 1)) {
        head_buf = qemu_blockalign(bs, align);
        qemu_iovec_init(&local_qiov, qiov->niov + 2);
        qemu_iovec_add(&local_qiov, head_buf, offset & (align - 1));
        qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
        use_local_qiov = true;

        bytes += offset & (align - 1);
        offset = offset & ~(align - 1);
    }

    if ((offset + bytes) & (align - 1)) {
        if (!use_local_qiov) {
            qemu_iovec_init(&local_qiov, qiov->niov + 1);
            qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
            use_local_qiov = true;
        }
        tail_buf = qemu_blockalign(bs, align);
        qemu_iovec_add(&local_qiov, tail_buf,
                       align - ((offset + bytes) & (align - 1)));

        bytes = ROUND_UP(bytes, align);
    }

3159
    tracked_request_begin(&req, bs, offset, bytes, false);
3160
    ret = bdrv_aligned_preadv(bs, &req, offset, bytes, align,
3161 3162
                              use_local_qiov ? &local_qiov : qiov,
                              flags);
3163
    tracked_request_end(&req);
3164 3165 3166 3167 3168

    if (use_local_qiov) {
        qemu_iovec_destroy(&local_qiov);
        qemu_vfree(head_buf);
        qemu_vfree(tail_buf);
3169 3170 3171 3172 3173
    }

    return ret;
}

3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185
static int coroutine_fn bdrv_co_do_readv(BlockDriverState *bs,
    int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
    BdrvRequestFlags flags)
{
    if (nb_sectors < 0 || nb_sectors > (UINT_MAX >> BDRV_SECTOR_BITS)) {
        return -EINVAL;
    }

    return bdrv_co_do_preadv(bs, sector_num << BDRV_SECTOR_BITS,
                             nb_sectors << BDRV_SECTOR_BITS, qiov, flags);
}

3186
int coroutine_fn bdrv_co_readv(BlockDriverState *bs, int64_t sector_num,
K
Kevin Wolf 已提交
3187 3188
    int nb_sectors, QEMUIOVector *qiov)
{
3189
    trace_bdrv_co_readv(bs, sector_num, nb_sectors);
K
Kevin Wolf 已提交
3190

3191 3192 3193 3194 3195 3196 3197 3198 3199 3200
    return bdrv_co_do_readv(bs, sector_num, nb_sectors, qiov, 0);
}

int coroutine_fn bdrv_co_copy_on_readv(BlockDriverState *bs,
    int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
{
    trace_bdrv_co_copy_on_readv(bs, sector_num, nb_sectors);

    return bdrv_co_do_readv(bs, sector_num, nb_sectors, qiov,
                            BDRV_REQ_COPY_ON_READ);
3201 3202
}

3203 3204 3205 3206 3207
/* if no limit is specified in the BlockLimits use a default
 * of 32768 512-byte sectors (16 MiB) per request.
 */
#define MAX_WRITE_ZEROES_DEFAULT 32768

3208
static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs,
3209
    int64_t sector_num, int nb_sectors, BdrvRequestFlags flags)
3210 3211 3212
{
    BlockDriver *drv = bs->drv;
    QEMUIOVector qiov;
3213 3214
    struct iovec iov = {0};
    int ret = 0;
3215

3216 3217
    int max_write_zeroes = bs->bl.max_write_zeroes ?
                           bs->bl.max_write_zeroes : MAX_WRITE_ZEROES_DEFAULT;
K
Kevin Wolf 已提交
3218

3219 3220 3221
    while (nb_sectors > 0 && !ret) {
        int num = nb_sectors;

3222 3223 3224 3225 3226 3227 3228
        /* Align request.  Block drivers can expect the "bulk" of the request
         * to be aligned.
         */
        if (bs->bl.write_zeroes_alignment
            && num > bs->bl.write_zeroes_alignment) {
            if (sector_num % bs->bl.write_zeroes_alignment != 0) {
                /* Make a small request up to the first aligned sector.  */
3229
                num = bs->bl.write_zeroes_alignment;
3230 3231 3232 3233 3234 3235
                num -= sector_num % bs->bl.write_zeroes_alignment;
            } else if ((sector_num + num) % bs->bl.write_zeroes_alignment != 0) {
                /* Shorten the request to the last aligned sector.  num cannot
                 * underflow because num > bs->bl.write_zeroes_alignment.
                 */
                num -= (sector_num + num) % bs->bl.write_zeroes_alignment;
3236
            }
K
Kevin Wolf 已提交
3237
        }
3238

3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253
        /* limit request size */
        if (num > max_write_zeroes) {
            num = max_write_zeroes;
        }

        ret = -ENOTSUP;
        /* First try the efficient write zeroes operation */
        if (drv->bdrv_co_write_zeroes) {
            ret = drv->bdrv_co_write_zeroes(bs, sector_num, num, flags);
        }

        if (ret == -ENOTSUP) {
            /* Fall back to bounce buffer if write zeroes is unsupported */
            iov.iov_len = num * BDRV_SECTOR_SIZE;
            if (iov.iov_base == NULL) {
3254 3255
                iov.iov_base = qemu_blockalign(bs, num * BDRV_SECTOR_SIZE);
                memset(iov.iov_base, 0, num * BDRV_SECTOR_SIZE);
3256 3257
            }
            qemu_iovec_init_external(&qiov, &iov, 1);
3258

3259
            ret = drv->bdrv_co_writev(bs, sector_num, num, &qiov);
3260 3261 3262 3263 3264 3265 3266 3267

            /* Keep bounce buffer around if it is big enough for all
             * all future requests.
             */
            if (num < max_write_zeroes) {
                qemu_vfree(iov.iov_base);
                iov.iov_base = NULL;
            }
3268 3269 3270 3271 3272
        }

        sector_num += num;
        nb_sectors -= num;
    }
3273 3274 3275 3276 3277

    qemu_vfree(iov.iov_base);
    return ret;
}

3278
/*
3279
 * Forwards an already correctly aligned write request to the BlockDriver.
3280
 */
3281
static int coroutine_fn bdrv_aligned_pwritev(BlockDriverState *bs,
3282 3283
    BdrvTrackedRequest *req, int64_t offset, unsigned int bytes,
    QEMUIOVector *qiov, int flags)
3284 3285
{
    BlockDriver *drv = bs->drv;
3286
    bool waited;
3287
    int ret;
K
Kevin Wolf 已提交
3288

3289 3290
    int64_t sector_num = offset >> BDRV_SECTOR_BITS;
    unsigned int nb_sectors = bytes >> BDRV_SECTOR_BITS;
3291

3292 3293
    assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0);
    assert((bytes & (BDRV_SECTOR_SIZE - 1)) == 0);
3294
    assert(!qiov || bytes == qiov->size);
3295

3296 3297
    waited = wait_serialising_requests(req);
    assert(!waited || !req->serialising);
3298 3299
    assert(req->overlap_offset <= offset);
    assert(offset + bytes <= req->overlap_offset + req->overlap_bytes);
3300

3301
    ret = notifier_with_return_list_notify(&bs->before_write_notifiers, req);
3302

3303 3304 3305 3306 3307 3308 3309 3310 3311
    if (!ret && bs->detect_zeroes != BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF &&
        !(flags & BDRV_REQ_ZERO_WRITE) && drv->bdrv_co_write_zeroes &&
        qemu_iovec_is_zero(qiov)) {
        flags |= BDRV_REQ_ZERO_WRITE;
        if (bs->detect_zeroes == BLOCKDEV_DETECT_ZEROES_OPTIONS_UNMAP) {
            flags |= BDRV_REQ_MAY_UNMAP;
        }
    }

3312 3313 3314
    if (ret < 0) {
        /* Do nothing, write notifier decided to fail this request */
    } else if (flags & BDRV_REQ_ZERO_WRITE) {
3315
        BLKDBG_EVENT(bs, BLKDBG_PWRITEV_ZERO);
3316
        ret = bdrv_co_do_write_zeroes(bs, sector_num, nb_sectors, flags);
3317
    } else {
3318
        BLKDBG_EVENT(bs, BLKDBG_PWRITEV);
3319 3320
        ret = drv->bdrv_co_writev(bs, sector_num, nb_sectors, qiov);
    }
3321
    BLKDBG_EVENT(bs, BLKDBG_PWRITEV_DONE);
3322

3323 3324 3325 3326
    if (ret == 0 && !bs->enable_write_cache) {
        ret = bdrv_co_flush(bs);
    }

F
Fam Zheng 已提交
3327
    bdrv_set_dirty(bs, sector_num, nb_sectors);
K
Kevin Wolf 已提交
3328 3329 3330 3331

    if (bs->wr_highest_sector < sector_num + nb_sectors - 1) {
        bs->wr_highest_sector = sector_num + nb_sectors - 1;
    }
3332 3333 3334
    if (bs->growable && ret >= 0) {
        bs->total_sectors = MAX(bs->total_sectors, sector_num + nb_sectors);
    }
K
Kevin Wolf 已提交
3335

3336
    return ret;
K
Kevin Wolf 已提交
3337 3338
}

3339 3340 3341
/*
 * Handle a write request in coroutine context
 */
3342 3343
static int coroutine_fn bdrv_co_do_pwritev(BlockDriverState *bs,
    int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
3344 3345
    BdrvRequestFlags flags)
{
3346
    BdrvTrackedRequest req;
3347 3348 3349 3350 3351 3352
    /* TODO Lift BDRV_SECTOR_SIZE restriction in BlockDriver interface */
    uint64_t align = MAX(BDRV_SECTOR_SIZE, bs->request_alignment);
    uint8_t *head_buf = NULL;
    uint8_t *tail_buf = NULL;
    QEMUIOVector local_qiov;
    bool use_local_qiov = false;
3353 3354 3355 3356 3357 3358 3359 3360
    int ret;

    if (!bs->drv) {
        return -ENOMEDIUM;
    }
    if (bs->read_only) {
        return -EACCES;
    }
3361
    if (bdrv_check_byte_request(bs, offset, bytes)) {
3362 3363 3364 3365 3366
        return -EIO;
    }

    /* throttling disk I/O */
    if (bs->io_limits_enabled) {
3367
        bdrv_io_limits_intercept(bs, bytes, true);
3368 3369
    }

3370 3371 3372 3373 3374
    /*
     * Align write if necessary by performing a read-modify-write cycle.
     * Pad qiov with the read parts and be sure to have a tracked request not
     * only for bdrv_aligned_pwritev, but also for the reads of the RMW cycle.
     */
3375
    tracked_request_begin(&req, bs, offset, bytes, true);
3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390

    if (offset & (align - 1)) {
        QEMUIOVector head_qiov;
        struct iovec head_iov;

        mark_request_serialising(&req, align);
        wait_serialising_requests(&req);

        head_buf = qemu_blockalign(bs, align);
        head_iov = (struct iovec) {
            .iov_base   = head_buf,
            .iov_len    = align,
        };
        qemu_iovec_init_external(&head_qiov, &head_iov, 1);

3391
        BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_HEAD);
3392 3393 3394 3395 3396
        ret = bdrv_aligned_preadv(bs, &req, offset & ~(align - 1), align,
                                  align, &head_qiov, 0);
        if (ret < 0) {
            goto fail;
        }
3397
        BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_AFTER_HEAD);
3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411

        qemu_iovec_init(&local_qiov, qiov->niov + 2);
        qemu_iovec_add(&local_qiov, head_buf, offset & (align - 1));
        qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
        use_local_qiov = true;

        bytes += offset & (align - 1);
        offset = offset & ~(align - 1);
    }

    if ((offset + bytes) & (align - 1)) {
        QEMUIOVector tail_qiov;
        struct iovec tail_iov;
        size_t tail_bytes;
3412
        bool waited;
3413 3414

        mark_request_serialising(&req, align);
3415 3416
        waited = wait_serialising_requests(&req);
        assert(!waited || !use_local_qiov);
3417 3418 3419 3420 3421 3422 3423 3424

        tail_buf = qemu_blockalign(bs, align);
        tail_iov = (struct iovec) {
            .iov_base   = tail_buf,
            .iov_len    = align,
        };
        qemu_iovec_init_external(&tail_qiov, &tail_iov, 1);

3425
        BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_TAIL);
3426 3427 3428 3429 3430
        ret = bdrv_aligned_preadv(bs, &req, (offset + bytes) & ~(align - 1), align,
                                  align, &tail_qiov, 0);
        if (ret < 0) {
            goto fail;
        }
3431
        BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_AFTER_TAIL);
3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449

        if (!use_local_qiov) {
            qemu_iovec_init(&local_qiov, qiov->niov + 1);
            qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
            use_local_qiov = true;
        }

        tail_bytes = (offset + bytes) & (align - 1);
        qemu_iovec_add(&local_qiov, tail_buf + tail_bytes, align - tail_bytes);

        bytes = ROUND_UP(bytes, align);
    }

    ret = bdrv_aligned_pwritev(bs, &req, offset, bytes,
                               use_local_qiov ? &local_qiov : qiov,
                               flags);

fail:
3450
    tracked_request_end(&req);
3451

3452 3453 3454
    if (use_local_qiov) {
        qemu_iovec_destroy(&local_qiov);
    }
3455 3456
    qemu_vfree(head_buf);
    qemu_vfree(tail_buf);
3457

3458 3459 3460
    return ret;
}

3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472
static int coroutine_fn bdrv_co_do_writev(BlockDriverState *bs,
    int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
    BdrvRequestFlags flags)
{
    if (nb_sectors < 0 || nb_sectors > (INT_MAX >> BDRV_SECTOR_BITS)) {
        return -EINVAL;
    }

    return bdrv_co_do_pwritev(bs, sector_num << BDRV_SECTOR_BITS,
                              nb_sectors << BDRV_SECTOR_BITS, qiov, flags);
}

3473 3474 3475 3476 3477
int coroutine_fn bdrv_co_writev(BlockDriverState *bs, int64_t sector_num,
    int nb_sectors, QEMUIOVector *qiov)
{
    trace_bdrv_co_writev(bs, sector_num, nb_sectors);

3478 3479 3480 3481
    return bdrv_co_do_writev(bs, sector_num, nb_sectors, qiov, 0);
}

int coroutine_fn bdrv_co_write_zeroes(BlockDriverState *bs,
3482 3483
                                      int64_t sector_num, int nb_sectors,
                                      BdrvRequestFlags flags)
3484
{
3485
    trace_bdrv_co_write_zeroes(bs, sector_num, nb_sectors, flags);
3486

3487 3488 3489 3490
    if (!(bs->open_flags & BDRV_O_UNMAP)) {
        flags &= ~BDRV_REQ_MAY_UNMAP;
    }

3491
    return bdrv_co_do_writev(bs, sector_num, nb_sectors, NULL,
3492
                             BDRV_REQ_ZERO_WRITE | flags);
3493 3494
}

B
bellard 已提交
3495 3496 3497 3498 3499 3500
/**
 * Truncate file to 'offset' bytes (needed only for file protocols)
 */
int bdrv_truncate(BlockDriverState *bs, int64_t offset)
{
    BlockDriver *drv = bs->drv;
3501
    int ret;
B
bellard 已提交
3502
    if (!drv)
B
bellard 已提交
3503
        return -ENOMEDIUM;
B
bellard 已提交
3504 3505
    if (!drv->bdrv_truncate)
        return -ENOTSUP;
3506 3507
    if (bs->read_only)
        return -EACCES;
3508

3509 3510 3511
    ret = drv->bdrv_truncate(bs, offset);
    if (ret == 0) {
        ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
3512
        bdrv_dev_resize_cb(bs);
3513 3514
    }
    return ret;
B
bellard 已提交
3515 3516
}

3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535
/**
 * Length of a allocated file in bytes. Sparse files are counted by actual
 * allocated space. Return < 0 if error or unknown.
 */
int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)
{
    BlockDriver *drv = bs->drv;
    if (!drv) {
        return -ENOMEDIUM;
    }
    if (drv->bdrv_get_allocated_file_size) {
        return drv->bdrv_get_allocated_file_size(bs);
    }
    if (bs->file) {
        return bdrv_get_allocated_file_size(bs->file);
    }
    return -ENOTSUP;
}

B
bellard 已提交
3536
/**
M
Markus Armbruster 已提交
3537
 * Return number of sectors on success, -errno on error.
B
bellard 已提交
3538
 */
M
Markus Armbruster 已提交
3539
int64_t bdrv_nb_sectors(BlockDriverState *bs)
B
bellard 已提交
3540 3541
{
    BlockDriver *drv = bs->drv;
M
Markus Armbruster 已提交
3542

B
bellard 已提交
3543
    if (!drv)
B
bellard 已提交
3544
        return -ENOMEDIUM;
3545

3546 3547 3548 3549
    if (drv->has_variable_length) {
        int ret = refresh_total_sectors(bs, bs->total_sectors);
        if (ret < 0) {
            return ret;
3550
        }
B
bellard 已提交
3551
    }
M
Markus Armbruster 已提交
3552 3553 3554 3555 3556 3557 3558 3559 3560 3561 3562 3563
    return bs->total_sectors;
}

/**
 * Return length in bytes on success, -errno on error.
 * The length is always a multiple of BDRV_SECTOR_SIZE.
 */
int64_t bdrv_getlength(BlockDriverState *bs)
{
    int64_t ret = bdrv_nb_sectors(bs);

    return ret < 0 ? ret : ret * BDRV_SECTOR_SIZE;
B
bellard 已提交
3564 3565
}

B
bellard 已提交
3566
/* return 0 as number of sectors if no device present or error */
3567
void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
B
bellard 已提交
3568
{
M
Markus Armbruster 已提交
3569 3570 3571
    int64_t nb_sectors = bdrv_nb_sectors(bs);

    *nb_sectors_ptr = nb_sectors < 0 ? 0 : nb_sectors;
B
bellard 已提交
3572
}
B
bellard 已提交
3573

3574 3575
void bdrv_set_on_error(BlockDriverState *bs, BlockdevOnError on_read_error,
                       BlockdevOnError on_write_error)
3576 3577 3578 3579 3580
{
    bs->on_read_error = on_read_error;
    bs->on_write_error = on_write_error;
}

3581
BlockdevOnError bdrv_get_on_error(BlockDriverState *bs, bool is_read)
3582 3583 3584 3585
{
    return is_read ? bs->on_read_error : bs->on_write_error;
}

3586 3587 3588 3589 3590 3591
BlockErrorAction bdrv_get_error_action(BlockDriverState *bs, bool is_read, int error)
{
    BlockdevOnError on_err = is_read ? bs->on_read_error : bs->on_write_error;

    switch (on_err) {
    case BLOCKDEV_ON_ERROR_ENOSPC:
W
Wenchao Xia 已提交
3592 3593
        return (error == ENOSPC) ?
               BLOCK_ERROR_ACTION_STOP : BLOCK_ERROR_ACTION_REPORT;
3594
    case BLOCKDEV_ON_ERROR_STOP:
W
Wenchao Xia 已提交
3595
        return BLOCK_ERROR_ACTION_STOP;
3596
    case BLOCKDEV_ON_ERROR_REPORT:
W
Wenchao Xia 已提交
3597
        return BLOCK_ERROR_ACTION_REPORT;
3598
    case BLOCKDEV_ON_ERROR_IGNORE:
W
Wenchao Xia 已提交
3599
        return BLOCK_ERROR_ACTION_IGNORE;
3600 3601 3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612
    default:
        abort();
    }
}

/* This is done by device models because, while the block layer knows
 * about the error, it does not know whether an operation comes from
 * the device or the block layer (from a job, for example).
 */
void bdrv_error_action(BlockDriverState *bs, BlockErrorAction action,
                       bool is_read, int error)
{
    assert(error >= 0);
3613

W
Wenchao Xia 已提交
3614
    if (action == BLOCK_ERROR_ACTION_STOP) {
3615 3616 3617 3618
        /* First set the iostatus, so that "info block" returns an iostatus
         * that matches the events raised so far (an additional error iostatus
         * is fine, but not a lost one).
         */
3619
        bdrv_iostatus_set_err(bs, error);
3620 3621 3622 3623 3624 3625 3626 3627 3628 3629

        /* Then raise the request to stop the VM and the event.
         * qemu_system_vmstop_request_prepare has two effects.  First,
         * it ensures that the STOP event always comes after the
         * BLOCK_IO_ERROR event.  Second, it ensures that even if management
         * can observe the STOP event and do a "cont" before the STOP
         * event is issued, the VM will not stop.  In this case, vm_start()
         * also ensures that the STOP/RESUME pair of events is emitted.
         */
        qemu_system_vmstop_request_prepare();
3630 3631 3632 3633
        qapi_event_send_block_io_error(bdrv_get_device_name(bs),
                                       is_read ? IO_OPERATION_TYPE_READ :
                                       IO_OPERATION_TYPE_WRITE,
                                       action, &error_abort);
3634 3635
        qemu_system_vmstop_request(RUN_STATE_IO_ERROR);
    } else {
3636 3637 3638 3639
        qapi_event_send_block_io_error(bdrv_get_device_name(bs),
                                       is_read ? IO_OPERATION_TYPE_READ :
                                       IO_OPERATION_TYPE_WRITE,
                                       action, &error_abort);
3640 3641 3642
    }
}

B
bellard 已提交
3643 3644 3645 3646 3647
int bdrv_is_read_only(BlockDriverState *bs)
{
    return bs->read_only;
}

3648 3649 3650 3651 3652
int bdrv_is_sg(BlockDriverState *bs)
{
    return bs->sg;
}

3653 3654 3655 3656 3657
int bdrv_enable_write_cache(BlockDriverState *bs)
{
    return bs->enable_write_cache;
}

3658 3659 3660
void bdrv_set_enable_write_cache(BlockDriverState *bs, bool wce)
{
    bs->enable_write_cache = wce;
3661 3662 3663 3664 3665 3666 3667

    /* so a reopen() will preserve wce */
    if (wce) {
        bs->open_flags |= BDRV_O_CACHE_WB;
    } else {
        bs->open_flags &= ~BDRV_O_CACHE_WB;
    }
3668 3669
}

B
bellard 已提交
3670 3671 3672 3673 3674 3675 3676
int bdrv_is_encrypted(BlockDriverState *bs)
{
    if (bs->backing_hd && bs->backing_hd->encrypted)
        return 1;
    return bs->encrypted;
}

3677 3678 3679 3680 3681 3682 3683 3684 3685
int bdrv_key_required(BlockDriverState *bs)
{
    BlockDriverState *backing_hd = bs->backing_hd;

    if (backing_hd && backing_hd->encrypted && !backing_hd->valid_key)
        return 1;
    return (bs->encrypted && !bs->valid_key);
}

B
bellard 已提交
3686 3687 3688 3689 3690 3691 3692 3693 3694 3695
int bdrv_set_key(BlockDriverState *bs, const char *key)
{
    int ret;
    if (bs->backing_hd && bs->backing_hd->encrypted) {
        ret = bdrv_set_key(bs->backing_hd, key);
        if (ret < 0)
            return ret;
        if (!bs->encrypted)
            return 0;
    }
3696 3697 3698 3699 3700
    if (!bs->encrypted) {
        return -EINVAL;
    } else if (!bs->drv || !bs->drv->bdrv_set_key) {
        return -ENOMEDIUM;
    }
3701
    ret = bs->drv->bdrv_set_key(bs, key);
3702 3703 3704 3705 3706
    if (ret < 0) {
        bs->valid_key = 0;
    } else if (!bs->valid_key) {
        bs->valid_key = 1;
        /* call the change callback now, we skipped it on open */
3707
        bdrv_dev_change_media_cb(bs, true);
3708
    }
3709
    return ret;
B
bellard 已提交
3710 3711
}

3712
const char *bdrv_get_format_name(BlockDriverState *bs)
B
bellard 已提交
3713
{
3714
    return bs->drv ? bs->drv->format_name : NULL;
B
bellard 已提交
3715 3716
}

3717
void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
B
bellard 已提交
3718 3719 3720
                         void *opaque)
{
    BlockDriver *drv;
3721 3722
    int count = 0;
    const char **formats = NULL;
B
bellard 已提交
3723

3724
    QLIST_FOREACH(drv, &bdrv_drivers, list) {
3725 3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737
        if (drv->format_name) {
            bool found = false;
            int i = count;
            while (formats && i && !found) {
                found = !strcmp(formats[--i], drv->format_name);
            }

            if (!found) {
                formats = g_realloc(formats, (count + 1) * sizeof(char *));
                formats[count++] = drv->format_name;
                it(opaque, drv->format_name);
            }
        }
B
bellard 已提交
3738
    }
3739
    g_free(formats);
B
bellard 已提交
3740 3741
}

3742
/* This function is to find block backend bs */
B
bellard 已提交
3743 3744 3745 3746
BlockDriverState *bdrv_find(const char *name)
{
    BlockDriverState *bs;

3747
    QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
3748
        if (!strcmp(name, bs->device_name)) {
B
bellard 已提交
3749
            return bs;
3750
        }
B
bellard 已提交
3751 3752 3753 3754
    }
    return NULL;
}

3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767 3768 3769
/* This function is to find a node in the bs graph */
BlockDriverState *bdrv_find_node(const char *node_name)
{
    BlockDriverState *bs;

    assert(node_name);

    QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
        if (!strcmp(node_name, bs->node_name)) {
            return bs;
        }
    }
    return NULL;
}

3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782 3783 3784 3785 3786
/* Put this QMP function here so it can access the static graph_bdrv_states. */
BlockDeviceInfoList *bdrv_named_nodes_list(void)
{
    BlockDeviceInfoList *list, *entry;
    BlockDriverState *bs;

    list = NULL;
    QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
        entry = g_malloc0(sizeof(*entry));
        entry->value = bdrv_block_device_info(bs);
        entry->next = list;
        list = entry;
    }

    return list;
}

3787 3788 3789 3790 3791 3792 3793 3794 3795
BlockDriverState *bdrv_lookup_bs(const char *device,
                                 const char *node_name,
                                 Error **errp)
{
    BlockDriverState *bs = NULL;

    if (device) {
        bs = bdrv_find(device);

3796 3797
        if (bs) {
            return bs;
3798 3799 3800
        }
    }

3801 3802
    if (node_name) {
        bs = bdrv_find_node(node_name);
3803

3804 3805 3806
        if (bs) {
            return bs;
        }
3807 3808
    }

3809 3810 3811 3812
    error_setg(errp, "Cannot find device=%s nor node_name=%s",
                     device ? device : "",
                     node_name ? node_name : "");
    return NULL;
3813 3814
}

3815 3816 3817 3818 3819 3820 3821 3822 3823 3824 3825
/* If 'base' is in the same chain as 'top', return true. Otherwise,
 * return false.  If either argument is NULL, return false. */
bool bdrv_chain_contains(BlockDriverState *top, BlockDriverState *base)
{
    while (top && top != base) {
        top = top->backing_hd;
    }

    return top != NULL;
}

M
Markus Armbruster 已提交
3826 3827 3828 3829 3830
BlockDriverState *bdrv_next(BlockDriverState *bs)
{
    if (!bs) {
        return QTAILQ_FIRST(&bdrv_states);
    }
3831
    return QTAILQ_NEXT(bs, device_list);
M
Markus Armbruster 已提交
3832 3833
}

3834
void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs), void *opaque)
B
bellard 已提交
3835 3836 3837
{
    BlockDriverState *bs;

3838
    QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
3839
        it(opaque, bs);
B
bellard 已提交
3840 3841 3842
    }
}

B
bellard 已提交
3843 3844 3845 3846 3847
const char *bdrv_get_device_name(BlockDriverState *bs)
{
    return bs->device_name;
}

M
Markus Armbruster 已提交
3848 3849 3850 3851 3852
int bdrv_get_flags(BlockDriverState *bs)
{
    return bs->open_flags;
}

3853
int bdrv_flush_all(void)
A
aliguori 已提交
3854 3855
{
    BlockDriverState *bs;
3856
    int result = 0;
A
aliguori 已提交
3857

3858
    QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
3859 3860 3861 3862 3863
        AioContext *aio_context = bdrv_get_aio_context(bs);
        int ret;

        aio_context_acquire(aio_context);
        ret = bdrv_flush(bs);
3864 3865 3866
        if (ret < 0 && !result) {
            result = ret;
        }
3867
        aio_context_release(aio_context);
3868
    }
3869 3870

    return result;
A
aliguori 已提交
3871 3872
}

3873 3874 3875 3876 3877
int bdrv_has_zero_init_1(BlockDriverState *bs)
{
    return 1;
}

K
Kevin Wolf 已提交
3878 3879 3880 3881
int bdrv_has_zero_init(BlockDriverState *bs)
{
    assert(bs->drv);

3882 3883 3884 3885 3886
    /* If BS is a copy on write image, it is initialized to
       the contents of the base image, which may not be zeroes.  */
    if (bs->backing_hd) {
        return 0;
    }
K
Kevin Wolf 已提交
3887 3888
    if (bs->drv->bdrv_has_zero_init) {
        return bs->drv->bdrv_has_zero_init(bs);
K
Kevin Wolf 已提交
3889 3890
    }

3891 3892
    /* safe default */
    return 0;
K
Kevin Wolf 已提交
3893 3894
}

3895 3896 3897 3898 3899 3900 3901 3902 3903 3904 3905 3906 3907 3908 3909 3910 3911 3912 3913 3914 3915 3916 3917 3918 3919 3920 3921 3922 3923 3924
bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs)
{
    BlockDriverInfo bdi;

    if (bs->backing_hd) {
        return false;
    }

    if (bdrv_get_info(bs, &bdi) == 0) {
        return bdi.unallocated_blocks_are_zero;
    }

    return false;
}

bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs)
{
    BlockDriverInfo bdi;

    if (bs->backing_hd || !(bs->open_flags & BDRV_O_UNMAP)) {
        return false;
    }

    if (bdrv_get_info(bs, &bdi) == 0) {
        return bdi.can_write_zeroes_with_unmap;
    }

    return false;
}

3925
typedef struct BdrvCoGetBlockStatusData {
3926
    BlockDriverState *bs;
3927
    BlockDriverState *base;
3928 3929 3930
    int64_t sector_num;
    int nb_sectors;
    int *pnum;
3931
    int64_t ret;
3932
    bool done;
3933
} BdrvCoGetBlockStatusData;
3934

3935 3936 3937 3938 3939
/*
 * Returns true iff the specified sector is present in the disk image. Drivers
 * not implementing the functionality are assumed to not support backing files,
 * hence all their sectors are reported as allocated.
 *
3940 3941 3942
 * If 'sector_num' is beyond the end of the disk image the return value is 0
 * and 'pnum' is set to 0.
 *
3943 3944 3945 3946
 * 'pnum' is set to the number of sectors (including and immediately following
 * the specified sector) that are known to be in the same
 * allocated/unallocated state.
 *
3947 3948
 * 'nb_sectors' is the max value 'pnum' should be set to.  If nb_sectors goes
 * beyond the end of the disk image it will be clamped.
3949
 */
3950 3951 3952
static int64_t coroutine_fn bdrv_co_get_block_status(BlockDriverState *bs,
                                                     int64_t sector_num,
                                                     int nb_sectors, int *pnum)
3953
{
3954
    int64_t total_sectors;
3955
    int64_t n;
3956
    int64_t ret, ret2;
3957

3958 3959 3960
    total_sectors = bdrv_nb_sectors(bs);
    if (total_sectors < 0) {
        return total_sectors;
3961 3962
    }

3963
    if (sector_num >= total_sectors) {
3964 3965 3966 3967
        *pnum = 0;
        return 0;
    }

3968
    n = total_sectors - sector_num;
3969 3970 3971 3972
    if (n < nb_sectors) {
        nb_sectors = n;
    }

3973
    if (!bs->drv->bdrv_co_get_block_status) {
3974
        *pnum = nb_sectors;
3975
        ret = BDRV_BLOCK_DATA | BDRV_BLOCK_ALLOCATED;
3976 3977 3978 3979
        if (bs->drv->protocol_name) {
            ret |= BDRV_BLOCK_OFFSET_VALID | (sector_num * BDRV_SECTOR_SIZE);
        }
        return ret;
3980
    }
3981

3982 3983
    ret = bs->drv->bdrv_co_get_block_status(bs, sector_num, nb_sectors, pnum);
    if (ret < 0) {
3984
        *pnum = 0;
3985 3986 3987
        return ret;
    }

3988 3989 3990 3991 3992 3993
    if (ret & BDRV_BLOCK_RAW) {
        assert(ret & BDRV_BLOCK_OFFSET_VALID);
        return bdrv_get_block_status(bs->file, ret >> BDRV_SECTOR_BITS,
                                     *pnum, pnum);
    }

3994 3995 3996 3997
    if (ret & (BDRV_BLOCK_DATA | BDRV_BLOCK_ZERO)) {
        ret |= BDRV_BLOCK_ALLOCATED;
    }

3998 3999
    if (!(ret & BDRV_BLOCK_DATA) && !(ret & BDRV_BLOCK_ZERO)) {
        if (bdrv_unallocated_blocks_are_zero(bs)) {
4000
            ret |= BDRV_BLOCK_ZERO;
4001
        } else if (bs->backing_hd) {
4002
            BlockDriverState *bs2 = bs->backing_hd;
4003 4004
            int64_t nb_sectors2 = bdrv_nb_sectors(bs2);
            if (nb_sectors2 >= 0 && sector_num >= nb_sectors2) {
4005 4006 4007
                ret |= BDRV_BLOCK_ZERO;
            }
        }
4008
    }
4009 4010 4011 4012 4013 4014 4015 4016 4017 4018 4019 4020 4021 4022

    if (bs->file &&
        (ret & BDRV_BLOCK_DATA) && !(ret & BDRV_BLOCK_ZERO) &&
        (ret & BDRV_BLOCK_OFFSET_VALID)) {
        ret2 = bdrv_co_get_block_status(bs->file, ret >> BDRV_SECTOR_BITS,
                                        *pnum, pnum);
        if (ret2 >= 0) {
            /* Ignore errors.  This is just providing extra information, it
             * is useful but not necessary.
             */
            ret |= (ret2 & BDRV_BLOCK_ZERO);
        }
    }

4023
    return ret;
4024 4025
}

4026 4027
/* Coroutine wrapper for bdrv_get_block_status() */
static void coroutine_fn bdrv_get_block_status_co_entry(void *opaque)
4028
{
4029
    BdrvCoGetBlockStatusData *data = opaque;
4030 4031
    BlockDriverState *bs = data->bs;

4032 4033
    data->ret = bdrv_co_get_block_status(bs, data->sector_num, data->nb_sectors,
                                         data->pnum);
4034 4035 4036 4037
    data->done = true;
}

/*
4038
 * Synchronous wrapper around bdrv_co_get_block_status().
4039
 *
4040
 * See bdrv_co_get_block_status() for details.
4041
 */
4042 4043
int64_t bdrv_get_block_status(BlockDriverState *bs, int64_t sector_num,
                              int nb_sectors, int *pnum)
4044
{
4045
    Coroutine *co;
4046
    BdrvCoGetBlockStatusData data = {
4047 4048 4049 4050 4051 4052 4053
        .bs = bs,
        .sector_num = sector_num,
        .nb_sectors = nb_sectors,
        .pnum = pnum,
        .done = false,
    };

4054 4055
    if (qemu_in_coroutine()) {
        /* Fast-path if already in coroutine context */
4056
        bdrv_get_block_status_co_entry(&data);
4057
    } else {
4058 4059
        AioContext *aio_context = bdrv_get_aio_context(bs);

4060
        co = qemu_coroutine_create(bdrv_get_block_status_co_entry);
4061 4062
        qemu_coroutine_enter(co, &data);
        while (!data.done) {
4063
            aio_poll(aio_context, true);
4064
        }
4065 4066
    }
    return data.ret;
4067 4068
}

4069 4070 4071
int coroutine_fn bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num,
                                   int nb_sectors, int *pnum)
{
4072 4073 4074 4075
    int64_t ret = bdrv_get_block_status(bs, sector_num, nb_sectors, pnum);
    if (ret < 0) {
        return ret;
    }
4076
    return !!(ret & BDRV_BLOCK_ALLOCATED);
4077 4078
}

4079 4080 4081 4082 4083 4084 4085 4086 4087 4088 4089 4090
/*
 * Given an image chain: ... -> [BASE] -> [INTER1] -> [INTER2] -> [TOP]
 *
 * Return true if the given sector is allocated in any image between
 * BASE and TOP (inclusive).  BASE can be NULL to check if the given
 * sector is allocated in any image of the chain.  Return false otherwise.
 *
 * 'pnum' is set to the number of sectors (including and immediately following
 *  the specified sector) that are known to be in the same
 *  allocated/unallocated state.
 *
 */
4091 4092 4093 4094
int bdrv_is_allocated_above(BlockDriverState *top,
                            BlockDriverState *base,
                            int64_t sector_num,
                            int nb_sectors, int *pnum)
4095 4096 4097 4098 4099 4100 4101
{
    BlockDriverState *intermediate;
    int ret, n = nb_sectors;

    intermediate = top;
    while (intermediate && intermediate != base) {
        int pnum_inter;
4102 4103
        ret = bdrv_is_allocated(intermediate, sector_num, nb_sectors,
                                &pnum_inter);
4104 4105 4106 4107 4108 4109 4110 4111 4112 4113 4114 4115 4116
        if (ret < 0) {
            return ret;
        } else if (ret) {
            *pnum = pnum_inter;
            return 1;
        }

        /*
         * [sector_num, nb_sectors] is unallocated on top but intermediate
         * might have
         *
         * [sector_num+x, nr_sectors] allocated.
         */
4117 4118 4119
        if (n > pnum_inter &&
            (intermediate == top ||
             sector_num + pnum_inter < intermediate->total_sectors)) {
4120 4121 4122 4123 4124 4125 4126 4127 4128 4129
            n = pnum_inter;
        }

        intermediate = intermediate->backing_hd;
    }

    *pnum = n;
    return 0;
}

4130 4131 4132 4133 4134 4135 4136 4137 4138 4139
const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
{
    if (bs->backing_hd && bs->backing_hd->encrypted)
        return bs->backing_file;
    else if (bs->encrypted)
        return bs->filename;
    else
        return NULL;
}

4140
void bdrv_get_backing_filename(BlockDriverState *bs,
B
bellard 已提交
4141 4142
                               char *filename, int filename_size)
{
K
Kevin Wolf 已提交
4143
    pstrcpy(filename, filename_size, bs->backing_file);
B
bellard 已提交
4144 4145
}

4146
int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
B
bellard 已提交
4147 4148 4149 4150
                          const uint8_t *buf, int nb_sectors)
{
    BlockDriver *drv = bs->drv;
    if (!drv)
B
bellard 已提交
4151
        return -ENOMEDIUM;
B
bellard 已提交
4152 4153
    if (!drv->bdrv_write_compressed)
        return -ENOTSUP;
K
Kevin Wolf 已提交
4154 4155
    if (bdrv_check_request(bs, sector_num, nb_sectors))
        return -EIO;
4156

F
Fam Zheng 已提交
4157
    assert(QLIST_EMPTY(&bs->dirty_bitmaps));
4158

B
bellard 已提交
4159 4160
    return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);
}
4161

B
bellard 已提交
4162 4163 4164 4165
int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
{
    BlockDriver *drv = bs->drv;
    if (!drv)
B
bellard 已提交
4166
        return -ENOMEDIUM;
B
bellard 已提交
4167 4168 4169 4170 4171 4172
    if (!drv->bdrv_get_info)
        return -ENOTSUP;
    memset(bdi, 0, sizeof(*bdi));
    return drv->bdrv_get_info(bs, bdi);
}

M
Max Reitz 已提交
4173 4174 4175 4176 4177 4178 4179 4180 4181
ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs)
{
    BlockDriver *drv = bs->drv;
    if (drv && drv->bdrv_get_specific_info) {
        return drv->bdrv_get_specific_info(bs);
    }
    return NULL;
}

4182 4183
int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
                      int64_t pos, int size)
4184 4185 4186 4187 4188 4189 4190 4191 4192 4193 4194 4195
{
    QEMUIOVector qiov;
    struct iovec iov = {
        .iov_base   = (void *) buf,
        .iov_len    = size,
    };

    qemu_iovec_init_external(&qiov, &iov, 1);
    return bdrv_writev_vmstate(bs, &qiov, pos);
}

int bdrv_writev_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos)
4196 4197
{
    BlockDriver *drv = bs->drv;
4198 4199

    if (!drv) {
4200
        return -ENOMEDIUM;
4201 4202 4203 4204 4205 4206
    } else if (drv->bdrv_save_vmstate) {
        return drv->bdrv_save_vmstate(bs, qiov, pos);
    } else if (bs->file) {
        return bdrv_writev_vmstate(bs->file, qiov, pos);
    }

4207
    return -ENOTSUP;
4208 4209
}

4210 4211
int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
                      int64_t pos, int size)
4212 4213 4214 4215
{
    BlockDriver *drv = bs->drv;
    if (!drv)
        return -ENOMEDIUM;
4216 4217 4218 4219 4220
    if (drv->bdrv_load_vmstate)
        return drv->bdrv_load_vmstate(bs, buf, pos, size);
    if (bs->file)
        return bdrv_load_vmstate(bs->file, buf, pos, size);
    return -ENOTSUP;
4221 4222
}

K
Kevin Wolf 已提交
4223 4224
void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event)
{
4225
    if (!bs || !bs->drv || !bs->drv->bdrv_debug_event) {
K
Kevin Wolf 已提交
4226 4227 4228
        return;
    }

4229
    bs->drv->bdrv_debug_event(bs, event);
K
Kevin Wolf 已提交
4230 4231 4232 4233 4234 4235 4236 4237 4238 4239 4240 4241 4242 4243 4244 4245
}

int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
                          const char *tag)
{
    while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) {
        bs = bs->file;
    }

    if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) {
        return bs->drv->bdrv_debug_breakpoint(bs, event, tag);
    }

    return -ENOTSUP;
}

F
Fam Zheng 已提交
4246 4247 4248 4249 4250 4251 4252 4253 4254 4255 4256 4257 4258
int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag)
{
    while (bs && bs->drv && !bs->drv->bdrv_debug_remove_breakpoint) {
        bs = bs->file;
    }

    if (bs && bs->drv && bs->drv->bdrv_debug_remove_breakpoint) {
        return bs->drv->bdrv_debug_remove_breakpoint(bs, tag);
    }

    return -ENOTSUP;
}

K
Kevin Wolf 已提交
4259 4260
int bdrv_debug_resume(BlockDriverState *bs, const char *tag)
{
4261
    while (bs && (!bs->drv || !bs->drv->bdrv_debug_resume)) {
K
Kevin Wolf 已提交
4262 4263
        bs = bs->file;
    }
K
Kevin Wolf 已提交
4264

K
Kevin Wolf 已提交
4265 4266 4267 4268 4269 4270 4271 4272 4273 4274 4275 4276 4277 4278 4279 4280 4281 4282
    if (bs && bs->drv && bs->drv->bdrv_debug_resume) {
        return bs->drv->bdrv_debug_resume(bs, tag);
    }

    return -ENOTSUP;
}

bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag)
{
    while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) {
        bs = bs->file;
    }

    if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) {
        return bs->drv->bdrv_debug_is_suspended(bs, tag);
    }

    return false;
K
Kevin Wolf 已提交
4283 4284
}

4285 4286 4287 4288 4289
int bdrv_is_snapshot(BlockDriverState *bs)
{
    return !!(bs->open_flags & BDRV_O_SNAPSHOT);
}

4290 4291 4292 4293
/* backing_file can either be relative, or absolute, or a protocol.  If it is
 * relative, it must be relative to the chain.  So, passing in bs->filename
 * from a BDS as backing_file should not be done, as that may be relative to
 * the CWD rather than the chain. */
4294 4295 4296
BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
        const char *backing_file)
{
4297 4298 4299 4300 4301 4302 4303 4304
    char *filename_full = NULL;
    char *backing_file_full = NULL;
    char *filename_tmp = NULL;
    int is_protocol = 0;
    BlockDriverState *curr_bs = NULL;
    BlockDriverState *retval = NULL;

    if (!bs || !bs->drv || !backing_file) {
4305 4306 4307
        return NULL;
    }

4308 4309 4310 4311 4312 4313 4314 4315 4316 4317 4318 4319 4320 4321 4322
    filename_full     = g_malloc(PATH_MAX);
    backing_file_full = g_malloc(PATH_MAX);
    filename_tmp      = g_malloc(PATH_MAX);

    is_protocol = path_has_protocol(backing_file);

    for (curr_bs = bs; curr_bs->backing_hd; curr_bs = curr_bs->backing_hd) {

        /* If either of the filename paths is actually a protocol, then
         * compare unmodified paths; otherwise make paths relative */
        if (is_protocol || path_has_protocol(curr_bs->backing_file)) {
            if (strcmp(backing_file, curr_bs->backing_file) == 0) {
                retval = curr_bs->backing_hd;
                break;
            }
4323
        } else {
4324 4325 4326 4327 4328 4329 4330 4331 4332 4333 4334 4335 4336 4337 4338 4339 4340 4341 4342 4343 4344 4345 4346
            /* If not an absolute filename path, make it relative to the current
             * image's filename path */
            path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
                         backing_file);

            /* We are going to compare absolute pathnames */
            if (!realpath(filename_tmp, filename_full)) {
                continue;
            }

            /* We need to make sure the backing filename we are comparing against
             * is relative to the current image filename (or absolute) */
            path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
                         curr_bs->backing_file);

            if (!realpath(filename_tmp, backing_file_full)) {
                continue;
            }

            if (strcmp(backing_file_full, filename_full) == 0) {
                retval = curr_bs->backing_hd;
                break;
            }
4347 4348 4349
        }
    }

4350 4351 4352 4353
    g_free(filename_full);
    g_free(backing_file_full);
    g_free(filename_tmp);
    return retval;
4354 4355
}

4356 4357 4358 4359 4360 4361 4362 4363 4364 4365 4366 4367 4368
int bdrv_get_backing_file_depth(BlockDriverState *bs)
{
    if (!bs->drv) {
        return 0;
    }

    if (!bs->backing_hd) {
        return 0;
    }

    return 1 + bdrv_get_backing_file_depth(bs->backing_hd);
}

B
bellard 已提交
4369
/**************************************************************/
B
bellard 已提交
4370
/* async I/Os */
B
bellard 已提交
4371

4372
BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
4373
                                 QEMUIOVector *qiov, int nb_sectors,
4374
                                 BlockDriverCompletionFunc *cb, void *opaque)
B
bellard 已提交
4375
{
4376 4377
    trace_bdrv_aio_readv(bs, sector_num, nb_sectors, opaque);

P
Paolo Bonzini 已提交
4378
    return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors, 0,
4379
                                 cb, opaque, false);
B
bellard 已提交
4380 4381
}

4382 4383 4384
BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
                                  QEMUIOVector *qiov, int nb_sectors,
                                  BlockDriverCompletionFunc *cb, void *opaque)
B
bellard 已提交
4385
{
4386 4387
    trace_bdrv_aio_writev(bs, sector_num, nb_sectors, opaque);

P
Paolo Bonzini 已提交
4388
    return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors, 0,
4389
                                 cb, opaque, true);
B
bellard 已提交
4390 4391
}

P
Paolo Bonzini 已提交
4392 4393 4394 4395 4396 4397 4398 4399 4400 4401 4402
BlockDriverAIOCB *bdrv_aio_write_zeroes(BlockDriverState *bs,
        int64_t sector_num, int nb_sectors, BdrvRequestFlags flags,
        BlockDriverCompletionFunc *cb, void *opaque)
{
    trace_bdrv_aio_write_zeroes(bs, sector_num, nb_sectors, flags, opaque);

    return bdrv_co_aio_rw_vector(bs, sector_num, NULL, nb_sectors,
                                 BDRV_REQ_ZERO_WRITE | flags,
                                 cb, opaque, true);
}

K
Kevin Wolf 已提交
4403 4404 4405 4406 4407 4408 4409 4410 4411 4412 4413 4414 4415 4416 4417 4418 4419 4420

typedef struct MultiwriteCB {
    int error;
    int num_requests;
    int num_callbacks;
    struct {
        BlockDriverCompletionFunc *cb;
        void *opaque;
        QEMUIOVector *free_qiov;
    } callbacks[];
} MultiwriteCB;

static void multiwrite_user_cb(MultiwriteCB *mcb)
{
    int i;

    for (i = 0; i < mcb->num_callbacks; i++) {
        mcb->callbacks[i].cb(mcb->callbacks[i].opaque, mcb->error);
4421 4422 4423
        if (mcb->callbacks[i].free_qiov) {
            qemu_iovec_destroy(mcb->callbacks[i].free_qiov);
        }
4424
        g_free(mcb->callbacks[i].free_qiov);
K
Kevin Wolf 已提交
4425 4426 4427 4428 4429 4430 4431
    }
}

static void multiwrite_cb(void *opaque, int ret)
{
    MultiwriteCB *mcb = opaque;

4432 4433
    trace_multiwrite_cb(mcb, ret);

4434
    if (ret < 0 && !mcb->error) {
K
Kevin Wolf 已提交
4435 4436 4437 4438 4439
        mcb->error = ret;
    }

    mcb->num_requests--;
    if (mcb->num_requests == 0) {
4440
        multiwrite_user_cb(mcb);
4441
        g_free(mcb);
K
Kevin Wolf 已提交
4442 4443 4444 4445 4446
    }
}

static int multiwrite_req_compare(const void *a, const void *b)
{
4447 4448 4449 4450 4451 4452 4453 4454 4455 4456 4457 4458 4459
    const BlockRequest *req1 = a, *req2 = b;

    /*
     * Note that we can't simply subtract req2->sector from req1->sector
     * here as that could overflow the return value.
     */
    if (req1->sector > req2->sector) {
        return 1;
    } else if (req1->sector < req2->sector) {
        return -1;
    } else {
        return 0;
    }
K
Kevin Wolf 已提交
4460 4461 4462 4463 4464 4465 4466 4467 4468 4469 4470 4471 4472 4473 4474 4475 4476 4477 4478 4479 4480
}

/*
 * Takes a bunch of requests and tries to merge them. Returns the number of
 * requests that remain after merging.
 */
static int multiwrite_merge(BlockDriverState *bs, BlockRequest *reqs,
    int num_reqs, MultiwriteCB *mcb)
{
    int i, outidx;

    // Sort requests by start sector
    qsort(reqs, num_reqs, sizeof(*reqs), &multiwrite_req_compare);

    // Check if adjacent requests touch the same clusters. If so, combine them,
    // filling up gaps with zero sectors.
    outidx = 0;
    for (i = 1; i < num_reqs; i++) {
        int merge = 0;
        int64_t oldreq_last = reqs[outidx].sector + reqs[outidx].nb_sectors;

4481
        // Handle exactly sequential writes and overlapping writes.
K
Kevin Wolf 已提交
4482 4483 4484 4485
        if (reqs[i].sector <= oldreq_last) {
            merge = 1;
        }

4486 4487 4488 4489
        if (reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1 > IOV_MAX) {
            merge = 0;
        }

K
Kevin Wolf 已提交
4490 4491
        if (merge) {
            size_t size;
4492
            QEMUIOVector *qiov = g_malloc0(sizeof(*qiov));
K
Kevin Wolf 已提交
4493 4494 4495 4496 4497 4498
            qemu_iovec_init(qiov,
                reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1);

            // Add the first request to the merged one. If the requests are
            // overlapping, drop the last sectors of the first request.
            size = (reqs[i].sector - reqs[outidx].sector) << 9;
4499
            qemu_iovec_concat(qiov, reqs[outidx].qiov, 0, size);
K
Kevin Wolf 已提交
4500

4501 4502
            // We should need to add any zeros between the two requests
            assert (reqs[i].sector <= oldreq_last);
K
Kevin Wolf 已提交
4503 4504

            // Add the second request
4505
            qemu_iovec_concat(qiov, reqs[i].qiov, 0, reqs[i].qiov->size);
K
Kevin Wolf 已提交
4506

4507
            reqs[outidx].nb_sectors = qiov->size >> 9;
K
Kevin Wolf 已提交
4508 4509 4510 4511 4512 4513 4514 4515 4516 4517 4518 4519 4520 4521 4522 4523 4524 4525 4526 4527 4528 4529 4530 4531 4532 4533 4534 4535 4536 4537 4538 4539 4540
            reqs[outidx].qiov = qiov;

            mcb->callbacks[i].free_qiov = reqs[outidx].qiov;
        } else {
            outidx++;
            reqs[outidx].sector     = reqs[i].sector;
            reqs[outidx].nb_sectors = reqs[i].nb_sectors;
            reqs[outidx].qiov       = reqs[i].qiov;
        }
    }

    return outidx + 1;
}

/*
 * Submit multiple AIO write requests at once.
 *
 * On success, the function returns 0 and all requests in the reqs array have
 * been submitted. In error case this function returns -1, and any of the
 * requests may or may not be submitted yet. In particular, this means that the
 * callback will be called for some of the requests, for others it won't. The
 * caller must check the error field of the BlockRequest to wait for the right
 * callbacks (if error != 0, no callback will be called).
 *
 * The implementation may modify the contents of the reqs array, e.g. to merge
 * requests. However, the fields opaque and error are left unmodified as they
 * are used to signal failure for a single request to the caller.
 */
int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs, int num_reqs)
{
    MultiwriteCB *mcb;
    int i;

4541 4542 4543 4544 4545 4546 4547 4548
    /* don't submit writes if we don't have a medium */
    if (bs->drv == NULL) {
        for (i = 0; i < num_reqs; i++) {
            reqs[i].error = -ENOMEDIUM;
        }
        return -1;
    }

K
Kevin Wolf 已提交
4549 4550 4551 4552 4553
    if (num_reqs == 0) {
        return 0;
    }

    // Create MultiwriteCB structure
4554
    mcb = g_malloc0(sizeof(*mcb) + num_reqs * sizeof(*mcb->callbacks));
K
Kevin Wolf 已提交
4555 4556 4557 4558 4559 4560 4561 4562 4563 4564 4565
    mcb->num_requests = 0;
    mcb->num_callbacks = num_reqs;

    for (i = 0; i < num_reqs; i++) {
        mcb->callbacks[i].cb = reqs[i].cb;
        mcb->callbacks[i].opaque = reqs[i].opaque;
    }

    // Check for mergable requests
    num_reqs = multiwrite_merge(bs, reqs, num_reqs, mcb);

4566 4567
    trace_bdrv_aio_multiwrite(mcb, mcb->num_callbacks, num_reqs);

4568 4569
    /* Run the aio requests. */
    mcb->num_requests = num_reqs;
K
Kevin Wolf 已提交
4570
    for (i = 0; i < num_reqs; i++) {
P
Paolo Bonzini 已提交
4571 4572 4573 4574
        bdrv_co_aio_rw_vector(bs, reqs[i].sector, reqs[i].qiov,
                              reqs[i].nb_sectors, reqs[i].flags,
                              multiwrite_cb, mcb,
                              true);
K
Kevin Wolf 已提交
4575 4576 4577 4578 4579
    }

    return 0;
}

B
bellard 已提交
4580 4581
void bdrv_aio_cancel(BlockDriverAIOCB *acb)
{
S
Stefan Hajnoczi 已提交
4582
    acb->aiocb_info->cancel(acb);
B
bellard 已提交
4583 4584 4585 4586 4587
}

/**************************************************************/
/* async block device emulation */

4588 4589 4590 4591 4592 4593 4594 4595 4596 4597 4598 4599
typedef struct BlockDriverAIOCBSync {
    BlockDriverAIOCB common;
    QEMUBH *bh;
    int ret;
    /* vector translation state */
    QEMUIOVector *qiov;
    uint8_t *bounce;
    int is_write;
} BlockDriverAIOCBSync;

static void bdrv_aio_cancel_em(BlockDriverAIOCB *blockacb)
{
4600 4601
    BlockDriverAIOCBSync *acb =
        container_of(blockacb, BlockDriverAIOCBSync, common);
4602
    qemu_bh_delete(acb->bh);
A
Avi Kivity 已提交
4603
    acb->bh = NULL;
4604 4605 4606
    qemu_aio_release(acb);
}

S
Stefan Hajnoczi 已提交
4607
static const AIOCBInfo bdrv_em_aiocb_info = {
4608 4609 4610 4611
    .aiocb_size         = sizeof(BlockDriverAIOCBSync),
    .cancel             = bdrv_aio_cancel_em,
};

4612
static void bdrv_aio_bh_cb(void *opaque)
B
bellard 已提交
4613
{
4614
    BlockDriverAIOCBSync *acb = opaque;
4615 4616

    if (!acb->is_write)
4617
        qemu_iovec_from_buf(acb->qiov, 0, acb->bounce, acb->qiov->size);
4618
    qemu_vfree(acb->bounce);
4619
    acb->common.cb(acb->common.opaque, acb->ret);
4620
    qemu_bh_delete(acb->bh);
A
Avi Kivity 已提交
4621
    acb->bh = NULL;
4622
    qemu_aio_release(acb);
B
bellard 已提交
4623
}
4624

4625 4626 4627 4628 4629 4630 4631 4632
static BlockDriverAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs,
                                            int64_t sector_num,
                                            QEMUIOVector *qiov,
                                            int nb_sectors,
                                            BlockDriverCompletionFunc *cb,
                                            void *opaque,
                                            int is_write)

B
bellard 已提交
4633
{
4634 4635
    BlockDriverAIOCBSync *acb;

S
Stefan Hajnoczi 已提交
4636
    acb = qemu_aio_get(&bdrv_em_aiocb_info, bs, cb, opaque);
4637 4638
    acb->is_write = is_write;
    acb->qiov = qiov;
4639
    acb->bounce = qemu_blockalign(bs, qiov->size);
4640
    acb->bh = aio_bh_new(bdrv_get_aio_context(bs), bdrv_aio_bh_cb, acb);
4641 4642

    if (is_write) {
4643
        qemu_iovec_to_buf(acb->qiov, 0, acb->bounce, qiov->size);
4644
        acb->ret = bs->drv->bdrv_write(bs, sector_num, acb->bounce, nb_sectors);
4645
    } else {
4646
        acb->ret = bs->drv->bdrv_read(bs, sector_num, acb->bounce, nb_sectors);
4647 4648
    }

4649
    qemu_bh_schedule(acb->bh);
4650

4651
    return &acb->common;
4652 4653
}

4654 4655
static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
        int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
4656
        BlockDriverCompletionFunc *cb, void *opaque)
4657
{
4658 4659
    return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 0);
}
B
bellard 已提交
4660

4661 4662 4663 4664 4665
static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
        int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
        BlockDriverCompletionFunc *cb, void *opaque)
{
    return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 1);
4666 4667
}

4668 4669 4670 4671 4672

typedef struct BlockDriverAIOCBCoroutine {
    BlockDriverAIOCB common;
    BlockRequest req;
    bool is_write;
K
Kevin Wolf 已提交
4673
    bool *done;
4674 4675 4676 4677 4678
    QEMUBH* bh;
} BlockDriverAIOCBCoroutine;

static void bdrv_aio_co_cancel_em(BlockDriverAIOCB *blockacb)
{
4679
    AioContext *aio_context = bdrv_get_aio_context(blockacb->bs);
K
Kevin Wolf 已提交
4680 4681 4682 4683 4684 4685
    BlockDriverAIOCBCoroutine *acb =
        container_of(blockacb, BlockDriverAIOCBCoroutine, common);
    bool done = false;

    acb->done = &done;
    while (!done) {
4686
        aio_poll(aio_context, true);
K
Kevin Wolf 已提交
4687
    }
4688 4689
}

S
Stefan Hajnoczi 已提交
4690
static const AIOCBInfo bdrv_em_co_aiocb_info = {
4691 4692 4693 4694
    .aiocb_size         = sizeof(BlockDriverAIOCBCoroutine),
    .cancel             = bdrv_aio_co_cancel_em,
};

P
Paolo Bonzini 已提交
4695
static void bdrv_co_em_bh(void *opaque)
4696 4697 4698 4699
{
    BlockDriverAIOCBCoroutine *acb = opaque;

    acb->common.cb(acb->common.opaque, acb->req.error);
K
Kevin Wolf 已提交
4700 4701 4702 4703 4704

    if (acb->done) {
        *acb->done = true;
    }

4705 4706 4707 4708
    qemu_bh_delete(acb->bh);
    qemu_aio_release(acb);
}

4709 4710 4711 4712 4713 4714 4715 4716
/* Invoke bdrv_co_do_readv/bdrv_co_do_writev */
static void coroutine_fn bdrv_co_do_rw(void *opaque)
{
    BlockDriverAIOCBCoroutine *acb = opaque;
    BlockDriverState *bs = acb->common.bs;

    if (!acb->is_write) {
        acb->req.error = bdrv_co_do_readv(bs, acb->req.sector,
P
Paolo Bonzini 已提交
4717
            acb->req.nb_sectors, acb->req.qiov, acb->req.flags);
4718 4719
    } else {
        acb->req.error = bdrv_co_do_writev(bs, acb->req.sector,
P
Paolo Bonzini 已提交
4720
            acb->req.nb_sectors, acb->req.qiov, acb->req.flags);
4721 4722
    }

4723
    acb->bh = aio_bh_new(bdrv_get_aio_context(bs), bdrv_co_em_bh, acb);
4724 4725 4726
    qemu_bh_schedule(acb->bh);
}

4727 4728 4729 4730
static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs,
                                               int64_t sector_num,
                                               QEMUIOVector *qiov,
                                               int nb_sectors,
P
Paolo Bonzini 已提交
4731
                                               BdrvRequestFlags flags,
4732 4733
                                               BlockDriverCompletionFunc *cb,
                                               void *opaque,
4734
                                               bool is_write)
4735 4736 4737 4738
{
    Coroutine *co;
    BlockDriverAIOCBCoroutine *acb;

S
Stefan Hajnoczi 已提交
4739
    acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
4740 4741 4742
    acb->req.sector = sector_num;
    acb->req.nb_sectors = nb_sectors;
    acb->req.qiov = qiov;
P
Paolo Bonzini 已提交
4743
    acb->req.flags = flags;
4744
    acb->is_write = is_write;
K
Kevin Wolf 已提交
4745
    acb->done = NULL;
4746

4747
    co = qemu_coroutine_create(bdrv_co_do_rw);
4748 4749 4750 4751 4752
    qemu_coroutine_enter(co, acb);

    return &acb->common;
}

P
Paolo Bonzini 已提交
4753
static void coroutine_fn bdrv_aio_flush_co_entry(void *opaque)
4754
{
P
Paolo Bonzini 已提交
4755 4756
    BlockDriverAIOCBCoroutine *acb = opaque;
    BlockDriverState *bs = acb->common.bs;
4757

P
Paolo Bonzini 已提交
4758
    acb->req.error = bdrv_co_flush(bs);
4759
    acb->bh = aio_bh_new(bdrv_get_aio_context(bs), bdrv_co_em_bh, acb);
4760 4761 4762
    qemu_bh_schedule(acb->bh);
}

P
Paolo Bonzini 已提交
4763
BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs,
4764 4765
        BlockDriverCompletionFunc *cb, void *opaque)
{
P
Paolo Bonzini 已提交
4766
    trace_bdrv_aio_flush(bs, opaque);
4767

P
Paolo Bonzini 已提交
4768 4769
    Coroutine *co;
    BlockDriverAIOCBCoroutine *acb;
4770

S
Stefan Hajnoczi 已提交
4771
    acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
K
Kevin Wolf 已提交
4772 4773
    acb->done = NULL;

P
Paolo Bonzini 已提交
4774 4775
    co = qemu_coroutine_create(bdrv_aio_flush_co_entry);
    qemu_coroutine_enter(co, acb);
4776 4777 4778 4779

    return &acb->common;
}

4780 4781 4782 4783 4784 4785
static void coroutine_fn bdrv_aio_discard_co_entry(void *opaque)
{
    BlockDriverAIOCBCoroutine *acb = opaque;
    BlockDriverState *bs = acb->common.bs;

    acb->req.error = bdrv_co_discard(bs, acb->req.sector, acb->req.nb_sectors);
4786
    acb->bh = aio_bh_new(bdrv_get_aio_context(bs), bdrv_co_em_bh, acb);
4787 4788 4789 4790 4791 4792 4793 4794 4795 4796 4797 4798
    qemu_bh_schedule(acb->bh);
}

BlockDriverAIOCB *bdrv_aio_discard(BlockDriverState *bs,
        int64_t sector_num, int nb_sectors,
        BlockDriverCompletionFunc *cb, void *opaque)
{
    Coroutine *co;
    BlockDriverAIOCBCoroutine *acb;

    trace_bdrv_aio_discard(bs, sector_num, nb_sectors, opaque);

S
Stefan Hajnoczi 已提交
4799
    acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
4800 4801
    acb->req.sector = sector_num;
    acb->req.nb_sectors = nb_sectors;
K
Kevin Wolf 已提交
4802
    acb->done = NULL;
4803 4804 4805 4806 4807 4808
    co = qemu_coroutine_create(bdrv_aio_discard_co_entry);
    qemu_coroutine_enter(co, acb);

    return &acb->common;
}

B
bellard 已提交
4809 4810
void bdrv_init(void)
{
4811
    module_call_init(MODULE_INIT_BLOCK);
B
bellard 已提交
4812
}
4813

4814 4815 4816 4817 4818 4819
void bdrv_init_with_whitelist(void)
{
    use_bdrv_whitelist = 1;
    bdrv_init();
}

S
Stefan Hajnoczi 已提交
4820
void *qemu_aio_get(const AIOCBInfo *aiocb_info, BlockDriverState *bs,
4821
                   BlockDriverCompletionFunc *cb, void *opaque)
4822 4823 4824
{
    BlockDriverAIOCB *acb;

S
Stefan Hajnoczi 已提交
4825 4826
    acb = g_slice_alloc(aiocb_info->aiocb_size);
    acb->aiocb_info = aiocb_info;
4827 4828 4829 4830 4831 4832 4833 4834
    acb->bs = bs;
    acb->cb = cb;
    acb->opaque = opaque;
    return acb;
}

void qemu_aio_release(void *p)
{
4835
    BlockDriverAIOCB *acb = p;
S
Stefan Hajnoczi 已提交
4836
    g_slice_free1(acb->aiocb_info->aiocb_size, acb);
4837
}
B
bellard 已提交
4838

4839 4840 4841 4842 4843 4844 4845 4846 4847 4848 4849 4850 4851 4852 4853 4854 4855 4856 4857 4858 4859 4860 4861 4862 4863 4864
/**************************************************************/
/* Coroutine block device emulation */

typedef struct CoroutineIOCompletion {
    Coroutine *coroutine;
    int ret;
} CoroutineIOCompletion;

static void bdrv_co_io_em_complete(void *opaque, int ret)
{
    CoroutineIOCompletion *co = opaque;

    co->ret = ret;
    qemu_coroutine_enter(co->coroutine, NULL);
}

static int coroutine_fn bdrv_co_io_em(BlockDriverState *bs, int64_t sector_num,
                                      int nb_sectors, QEMUIOVector *iov,
                                      bool is_write)
{
    CoroutineIOCompletion co = {
        .coroutine = qemu_coroutine_self(),
    };
    BlockDriverAIOCB *acb;

    if (is_write) {
4865 4866
        acb = bs->drv->bdrv_aio_writev(bs, sector_num, iov, nb_sectors,
                                       bdrv_co_io_em_complete, &co);
4867
    } else {
4868 4869
        acb = bs->drv->bdrv_aio_readv(bs, sector_num, iov, nb_sectors,
                                      bdrv_co_io_em_complete, &co);
4870 4871
    }

4872
    trace_bdrv_co_io_em(bs, sector_num, nb_sectors, is_write, acb);
4873 4874 4875 4876 4877 4878 4879 4880 4881 4882 4883 4884 4885 4886 4887 4888 4889 4890 4891 4892 4893 4894
    if (!acb) {
        return -EIO;
    }
    qemu_coroutine_yield();

    return co.ret;
}

static int coroutine_fn bdrv_co_readv_em(BlockDriverState *bs,
                                         int64_t sector_num, int nb_sectors,
                                         QEMUIOVector *iov)
{
    return bdrv_co_io_em(bs, sector_num, nb_sectors, iov, false);
}

static int coroutine_fn bdrv_co_writev_em(BlockDriverState *bs,
                                         int64_t sector_num, int nb_sectors,
                                         QEMUIOVector *iov)
{
    return bdrv_co_io_em(bs, sector_num, nb_sectors, iov, true);
}

P
Paolo Bonzini 已提交
4895
static void coroutine_fn bdrv_flush_co_entry(void *opaque)
4896
{
P
Paolo Bonzini 已提交
4897 4898 4899 4900 4901 4902 4903
    RwCo *rwco = opaque;

    rwco->ret = bdrv_co_flush(rwco->bs);
}

int coroutine_fn bdrv_co_flush(BlockDriverState *bs)
{
K
Kevin Wolf 已提交
4904 4905
    int ret;

4906
    if (!bs || !bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
P
Paolo Bonzini 已提交
4907
        return 0;
K
Kevin Wolf 已提交
4908 4909
    }

4910
    /* Write back cached data to the OS even with cache=unsafe */
4911
    BLKDBG_EVENT(bs->file, BLKDBG_FLUSH_TO_OS);
K
Kevin Wolf 已提交
4912 4913 4914 4915 4916 4917 4918
    if (bs->drv->bdrv_co_flush_to_os) {
        ret = bs->drv->bdrv_co_flush_to_os(bs);
        if (ret < 0) {
            return ret;
        }
    }

4919 4920
    /* But don't actually force it to the disk with cache=unsafe */
    if (bs->open_flags & BDRV_O_NO_FLUSH) {
4921
        goto flush_parent;
4922 4923
    }

4924
    BLKDBG_EVENT(bs->file, BLKDBG_FLUSH_TO_DISK);
K
Kevin Wolf 已提交
4925
    if (bs->drv->bdrv_co_flush_to_disk) {
4926
        ret = bs->drv->bdrv_co_flush_to_disk(bs);
P
Paolo Bonzini 已提交
4927 4928 4929 4930 4931 4932 4933 4934
    } else if (bs->drv->bdrv_aio_flush) {
        BlockDriverAIOCB *acb;
        CoroutineIOCompletion co = {
            .coroutine = qemu_coroutine_self(),
        };

        acb = bs->drv->bdrv_aio_flush(bs, bdrv_co_io_em_complete, &co);
        if (acb == NULL) {
4935
            ret = -EIO;
P
Paolo Bonzini 已提交
4936 4937
        } else {
            qemu_coroutine_yield();
4938
            ret = co.ret;
P
Paolo Bonzini 已提交
4939 4940 4941 4942 4943 4944 4945 4946 4947 4948 4949 4950 4951
        }
    } else {
        /*
         * Some block drivers always operate in either writethrough or unsafe
         * mode and don't support bdrv_flush therefore. Usually qemu doesn't
         * know how the server works (because the behaviour is hardcoded or
         * depends on server-side configuration), so we can't ensure that
         * everything is safe on disk. Returning an error doesn't work because
         * that would break guests even if the server operates in writethrough
         * mode.
         *
         * Let's hope the user knows what he's doing.
         */
4952
        ret = 0;
P
Paolo Bonzini 已提交
4953
    }
4954 4955 4956 4957 4958 4959 4960
    if (ret < 0) {
        return ret;
    }

    /* Now flush the underlying protocol.  It will also have BDRV_O_NO_FLUSH
     * in the case of cache=unsafe, so there are no useless flushes.
     */
4961
flush_parent:
4962
    return bdrv_co_flush(bs->file);
P
Paolo Bonzini 已提交
4963 4964
}

4965
void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp)
4966
{
4967 4968 4969
    Error *local_err = NULL;
    int ret;

4970 4971 4972 4973 4974
    if (!bs->drv)  {
        return;
    }

    if (bs->drv->bdrv_invalidate_cache) {
4975
        bs->drv->bdrv_invalidate_cache(bs, &local_err);
4976
    } else if (bs->file) {
4977 4978 4979 4980 4981
        bdrv_invalidate_cache(bs->file, &local_err);
    }
    if (local_err) {
        error_propagate(errp, local_err);
        return;
4982
    }
4983

4984 4985 4986 4987 4988
    ret = refresh_total_sectors(bs, bs->total_sectors);
    if (ret < 0) {
        error_setg_errno(errp, -ret, "Could not refresh total sector count");
        return;
    }
4989 4990
}

4991
void bdrv_invalidate_cache_all(Error **errp)
4992 4993
{
    BlockDriverState *bs;
4994
    Error *local_err = NULL;
4995

4996
    QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
4997 4998 4999
        AioContext *aio_context = bdrv_get_aio_context(bs);

        aio_context_acquire(aio_context);
5000
        bdrv_invalidate_cache(bs, &local_err);
5001
        aio_context_release(aio_context);
5002 5003 5004 5005
        if (local_err) {
            error_propagate(errp, local_err);
            return;
        }
5006 5007 5008
    }
}

5009 5010 5011 5012
void bdrv_clear_incoming_migration_all(void)
{
    BlockDriverState *bs;

5013
    QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
5014 5015 5016
        AioContext *aio_context = bdrv_get_aio_context(bs);

        aio_context_acquire(aio_context);
5017
        bs->open_flags = bs->open_flags & ~(BDRV_O_INCOMING);
5018
        aio_context_release(aio_context);
5019 5020 5021
    }
}

P
Paolo Bonzini 已提交
5022 5023 5024 5025 5026 5027
int bdrv_flush(BlockDriverState *bs)
{
    Coroutine *co;
    RwCo rwco = {
        .bs = bs,
        .ret = NOT_DONE,
5028 5029
    };

P
Paolo Bonzini 已提交
5030 5031 5032 5033
    if (qemu_in_coroutine()) {
        /* Fast-path if already in coroutine context */
        bdrv_flush_co_entry(&rwco);
    } else {
5034 5035
        AioContext *aio_context = bdrv_get_aio_context(bs);

P
Paolo Bonzini 已提交
5036 5037 5038
        co = qemu_coroutine_create(bdrv_flush_co_entry);
        qemu_coroutine_enter(co, &rwco);
        while (rwco.ret == NOT_DONE) {
5039
            aio_poll(aio_context, true);
P
Paolo Bonzini 已提交
5040
        }
5041
    }
P
Paolo Bonzini 已提交
5042 5043

    return rwco.ret;
5044 5045
}

5046 5047 5048 5049 5050 5051
typedef struct DiscardCo {
    BlockDriverState *bs;
    int64_t sector_num;
    int nb_sectors;
    int ret;
} DiscardCo;
5052 5053
static void coroutine_fn bdrv_discard_co_entry(void *opaque)
{
5054
    DiscardCo *rwco = opaque;
5055 5056 5057 5058

    rwco->ret = bdrv_co_discard(rwco->bs, rwco->sector_num, rwco->nb_sectors);
}

5059 5060 5061 5062 5063
/* if no limit is specified in the BlockLimits use a default
 * of 32768 512-byte sectors (16 MiB) per request.
 */
#define MAX_DISCARD_DEFAULT 32768

5064 5065 5066
int coroutine_fn bdrv_co_discard(BlockDriverState *bs, int64_t sector_num,
                                 int nb_sectors)
{
5067 5068
    int max_discard;

5069 5070 5071 5072 5073 5074
    if (!bs->drv) {
        return -ENOMEDIUM;
    } else if (bdrv_check_request(bs, sector_num, nb_sectors)) {
        return -EIO;
    } else if (bs->read_only) {
        return -EROFS;
5075 5076
    }

F
Fam Zheng 已提交
5077
    bdrv_reset_dirty(bs, sector_num, nb_sectors);
5078

P
Paolo Bonzini 已提交
5079 5080 5081 5082 5083
    /* Do nothing if disabled.  */
    if (!(bs->open_flags & BDRV_O_UNMAP)) {
        return 0;
    }

5084 5085 5086
    if (!bs->drv->bdrv_co_discard && !bs->drv->bdrv_aio_discard) {
        return 0;
    }
5087

5088 5089 5090 5091
    max_discard = bs->bl.max_discard ?  bs->bl.max_discard : MAX_DISCARD_DEFAULT;
    while (nb_sectors > 0) {
        int ret;
        int num = nb_sectors;
5092

5093 5094 5095 5096 5097 5098
        /* align request */
        if (bs->bl.discard_alignment &&
            num >= bs->bl.discard_alignment &&
            sector_num % bs->bl.discard_alignment) {
            if (num > bs->bl.discard_alignment) {
                num = bs->bl.discard_alignment;
5099
            }
5100 5101
            num -= sector_num % bs->bl.discard_alignment;
        }
5102

5103 5104 5105 5106
        /* limit request size */
        if (num > max_discard) {
            num = max_discard;
        }
5107

5108
        if (bs->drv->bdrv_co_discard) {
5109
            ret = bs->drv->bdrv_co_discard(bs, sector_num, num);
5110 5111 5112 5113 5114 5115 5116 5117 5118 5119 5120 5121 5122
        } else {
            BlockDriverAIOCB *acb;
            CoroutineIOCompletion co = {
                .coroutine = qemu_coroutine_self(),
            };

            acb = bs->drv->bdrv_aio_discard(bs, sector_num, nb_sectors,
                                            bdrv_co_io_em_complete, &co);
            if (acb == NULL) {
                return -EIO;
            } else {
                qemu_coroutine_yield();
                ret = co.ret;
5123 5124
            }
        }
5125
        if (ret && ret != -ENOTSUP) {
5126
            return ret;
5127
        }
5128 5129 5130

        sector_num += num;
        nb_sectors -= num;
5131
    }
5132
    return 0;
5133 5134 5135 5136 5137
}

int bdrv_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors)
{
    Coroutine *co;
5138
    DiscardCo rwco = {
5139 5140 5141 5142 5143 5144 5145 5146 5147 5148
        .bs = bs,
        .sector_num = sector_num,
        .nb_sectors = nb_sectors,
        .ret = NOT_DONE,
    };

    if (qemu_in_coroutine()) {
        /* Fast-path if already in coroutine context */
        bdrv_discard_co_entry(&rwco);
    } else {
5149 5150
        AioContext *aio_context = bdrv_get_aio_context(bs);

5151 5152 5153
        co = qemu_coroutine_create(bdrv_discard_co_entry);
        qemu_coroutine_enter(co, &rwco);
        while (rwco.ret == NOT_DONE) {
5154
            aio_poll(aio_context, true);
5155 5156 5157 5158 5159 5160
        }
    }

    return rwco.ret;
}

B
bellard 已提交
5161 5162 5163 5164 5165 5166 5167 5168 5169
/**************************************************************/
/* removable device support */

/**
 * Return TRUE if the media is present
 */
int bdrv_is_inserted(BlockDriverState *bs)
{
    BlockDriver *drv = bs->drv;
5170

B
bellard 已提交
5171 5172 5173
    if (!drv)
        return 0;
    if (!drv->bdrv_is_inserted)
5174 5175
        return 1;
    return drv->bdrv_is_inserted(bs);
B
bellard 已提交
5176 5177 5178
}

/**
5179 5180
 * Return whether the media changed since the last call to this
 * function, or -ENOTSUP if we don't know.  Most drivers don't know.
B
bellard 已提交
5181 5182 5183 5184 5185
 */
int bdrv_media_changed(BlockDriverState *bs)
{
    BlockDriver *drv = bs->drv;

5186 5187 5188 5189
    if (drv && drv->bdrv_media_changed) {
        return drv->bdrv_media_changed(bs);
    }
    return -ENOTSUP;
B
bellard 已提交
5190 5191 5192 5193 5194
}

/**
 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
 */
5195
void bdrv_eject(BlockDriverState *bs, bool eject_flag)
B
bellard 已提交
5196 5197 5198
{
    BlockDriver *drv = bs->drv;

5199 5200
    if (drv && drv->bdrv_eject) {
        drv->bdrv_eject(bs, eject_flag);
B
bellard 已提交
5201
    }
5202 5203

    if (bs->device_name[0] != '\0') {
5204 5205
        qapi_event_send_device_tray_moved(bdrv_get_device_name(bs),
                                          eject_flag, &error_abort);
5206
    }
B
bellard 已提交
5207 5208 5209 5210 5211 5212
}

/**
 * Lock or unlock the media (if it is locked, the user won't be able
 * to eject it manually).
 */
5213
void bdrv_lock_medium(BlockDriverState *bs, bool locked)
B
bellard 已提交
5214 5215 5216
{
    BlockDriver *drv = bs->drv;

5217
    trace_bdrv_lock_medium(bs, locked);
S
Stefan Hajnoczi 已提交
5218

5219 5220
    if (drv && drv->bdrv_lock_medium) {
        drv->bdrv_lock_medium(bs, locked);
B
bellard 已提交
5221 5222
    }
}
5223 5224 5225 5226 5227 5228 5229 5230 5231 5232 5233

/* needed for generic scsi interface */

int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
{
    BlockDriver *drv = bs->drv;

    if (drv && drv->bdrv_ioctl)
        return drv->bdrv_ioctl(bs, req, buf);
    return -ENOTSUP;
}
5234

5235 5236 5237
BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
        unsigned long int req, void *buf,
        BlockDriverCompletionFunc *cb, void *opaque)
5238
{
5239
    BlockDriver *drv = bs->drv;
5240

5241 5242 5243
    if (drv && drv->bdrv_aio_ioctl)
        return drv->bdrv_aio_ioctl(bs, req, buf, cb, opaque);
    return NULL;
5244
}
5245

5246
void bdrv_set_guest_block_size(BlockDriverState *bs, int align)
5247
{
5248
    bs->guest_block_size = align;
5249
}
5250

5251 5252
void *qemu_blockalign(BlockDriverState *bs, size_t size)
{
5253
    return qemu_memalign(bdrv_opt_mem_align(bs), size);
5254
}
5255

5256 5257 5258 5259 5260 5261
/*
 * Check if all memory in this vector is sector aligned.
 */
bool bdrv_qiov_is_aligned(BlockDriverState *bs, QEMUIOVector *qiov)
{
    int i;
5262
    size_t alignment = bdrv_opt_mem_align(bs);
5263 5264

    for (i = 0; i < qiov->niov; i++) {
5265
        if ((uintptr_t) qiov->iov[i].iov_base % alignment) {
5266
            return false;
5267
        }
5268
        if (qiov->iov[i].iov_len % alignment) {
5269
            return false;
5270 5271 5272 5273 5274 5275
        }
    }

    return true;
}

5276 5277
BdrvDirtyBitmap *bdrv_create_dirty_bitmap(BlockDriverState *bs, int granularity,
                                          Error **errp)
5278 5279
{
    int64_t bitmap_size;
F
Fam Zheng 已提交
5280
    BdrvDirtyBitmap *bitmap;
5281

5282 5283
    assert((granularity & (granularity - 1)) == 0);

F
Fam Zheng 已提交
5284 5285
    granularity >>= BDRV_SECTOR_BITS;
    assert(granularity);
5286 5287 5288 5289 5290 5291 5292
    bitmap_size = bdrv_getlength(bs);
    if (bitmap_size < 0) {
        error_setg_errno(errp, -bitmap_size, "could not get length of device");
        errno = -bitmap_size;
        return NULL;
    }
    bitmap_size >>= BDRV_SECTOR_BITS;
F
Fam Zheng 已提交
5293 5294 5295 5296 5297 5298 5299 5300 5301 5302 5303 5304 5305 5306 5307
    bitmap = g_malloc0(sizeof(BdrvDirtyBitmap));
    bitmap->bitmap = hbitmap_alloc(bitmap_size, ffs(granularity) - 1);
    QLIST_INSERT_HEAD(&bs->dirty_bitmaps, bitmap, list);
    return bitmap;
}

void bdrv_release_dirty_bitmap(BlockDriverState *bs, BdrvDirtyBitmap *bitmap)
{
    BdrvDirtyBitmap *bm, *next;
    QLIST_FOREACH_SAFE(bm, &bs->dirty_bitmaps, list, next) {
        if (bm == bitmap) {
            QLIST_REMOVE(bitmap, list);
            hbitmap_free(bitmap->bitmap);
            g_free(bitmap);
            return;
5308
        }
5309 5310 5311
    }
}

F
Fam Zheng 已提交
5312 5313 5314 5315 5316 5317 5318 5319 5320 5321 5322 5323 5324 5325 5326 5327 5328 5329 5330 5331
BlockDirtyInfoList *bdrv_query_dirty_bitmaps(BlockDriverState *bs)
{
    BdrvDirtyBitmap *bm;
    BlockDirtyInfoList *list = NULL;
    BlockDirtyInfoList **plist = &list;

    QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
        BlockDirtyInfo *info = g_malloc0(sizeof(BlockDirtyInfo));
        BlockDirtyInfoList *entry = g_malloc0(sizeof(BlockDirtyInfoList));
        info->count = bdrv_get_dirty_count(bs, bm);
        info->granularity =
            ((int64_t) BDRV_SECTOR_SIZE << hbitmap_granularity(bm->bitmap));
        entry->value = info;
        *plist = entry;
        plist = &entry->next;
    }

    return list;
}

F
Fam Zheng 已提交
5332
int bdrv_get_dirty(BlockDriverState *bs, BdrvDirtyBitmap *bitmap, int64_t sector)
5333
{
F
Fam Zheng 已提交
5334 5335
    if (bitmap) {
        return hbitmap_get(bitmap->bitmap, sector);
5336 5337 5338 5339 5340
    } else {
        return 0;
    }
}

F
Fam Zheng 已提交
5341 5342
void bdrv_dirty_iter_init(BlockDriverState *bs,
                          BdrvDirtyBitmap *bitmap, HBitmapIter *hbi)
5343
{
F
Fam Zheng 已提交
5344
    hbitmap_iter_init(hbi, bitmap->bitmap, 0);
5345 5346 5347 5348 5349
}

void bdrv_set_dirty(BlockDriverState *bs, int64_t cur_sector,
                    int nr_sectors)
{
F
Fam Zheng 已提交
5350 5351 5352 5353
    BdrvDirtyBitmap *bitmap;
    QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
        hbitmap_set(bitmap->bitmap, cur_sector, nr_sectors);
    }
5354 5355
}

F
Fam Zheng 已提交
5356
void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector, int nr_sectors)
5357
{
F
Fam Zheng 已提交
5358 5359 5360 5361
    BdrvDirtyBitmap *bitmap;
    QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
        hbitmap_reset(bitmap->bitmap, cur_sector, nr_sectors);
    }
5362
}
5363

F
Fam Zheng 已提交
5364
int64_t bdrv_get_dirty_count(BlockDriverState *bs, BdrvDirtyBitmap *bitmap)
5365
{
F
Fam Zheng 已提交
5366
    return hbitmap_count(bitmap->bitmap);
5367
}
J
Jes Sorensen 已提交
5368

5369 5370 5371 5372 5373 5374 5375 5376 5377 5378 5379 5380 5381 5382 5383 5384 5385
/* Get a reference to bs */
void bdrv_ref(BlockDriverState *bs)
{
    bs->refcnt++;
}

/* Release a previously grabbed reference to bs.
 * If after releasing, reference count is zero, the BlockDriverState is
 * deleted. */
void bdrv_unref(BlockDriverState *bs)
{
    assert(bs->refcnt > 0);
    if (--bs->refcnt == 0) {
        bdrv_delete(bs);
    }
}

5386 5387 5388 5389 5390 5391 5392 5393 5394 5395 5396 5397 5398 5399 5400 5401 5402 5403 5404 5405 5406 5407 5408 5409 5410 5411 5412 5413 5414 5415 5416 5417 5418 5419 5420 5421 5422 5423 5424 5425 5426 5427 5428 5429 5430 5431 5432 5433 5434 5435 5436 5437 5438 5439 5440 5441 5442 5443 5444 5445 5446 5447 5448 5449 5450 5451 5452 5453 5454 5455
struct BdrvOpBlocker {
    Error *reason;
    QLIST_ENTRY(BdrvOpBlocker) list;
};

bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp)
{
    BdrvOpBlocker *blocker;
    assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
    if (!QLIST_EMPTY(&bs->op_blockers[op])) {
        blocker = QLIST_FIRST(&bs->op_blockers[op]);
        if (errp) {
            error_setg(errp, "Device '%s' is busy: %s",
                       bs->device_name, error_get_pretty(blocker->reason));
        }
        return true;
    }
    return false;
}

void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason)
{
    BdrvOpBlocker *blocker;
    assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);

    blocker = g_malloc0(sizeof(BdrvOpBlocker));
    blocker->reason = reason;
    QLIST_INSERT_HEAD(&bs->op_blockers[op], blocker, list);
}

void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason)
{
    BdrvOpBlocker *blocker, *next;
    assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
    QLIST_FOREACH_SAFE(blocker, &bs->op_blockers[op], list, next) {
        if (blocker->reason == reason) {
            QLIST_REMOVE(blocker, list);
            g_free(blocker);
        }
    }
}

void bdrv_op_block_all(BlockDriverState *bs, Error *reason)
{
    int i;
    for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
        bdrv_op_block(bs, i, reason);
    }
}

void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason)
{
    int i;
    for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
        bdrv_op_unblock(bs, i, reason);
    }
}

bool bdrv_op_blocker_is_empty(BlockDriverState *bs)
{
    int i;

    for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
        if (!QLIST_EMPTY(&bs->op_blockers[i])) {
            return false;
        }
    }
    return true;
}

5456 5457
void bdrv_iostatus_enable(BlockDriverState *bs)
{
5458
    bs->iostatus_enabled = true;
5459
    bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
5460 5461 5462 5463 5464 5465
}

/* The I/O status is only enabled if the drive explicitly
 * enables it _and_ the VM is configured to stop on errors */
bool bdrv_iostatus_is_enabled(const BlockDriverState *bs)
{
5466
    return (bs->iostatus_enabled &&
5467 5468 5469
           (bs->on_write_error == BLOCKDEV_ON_ERROR_ENOSPC ||
            bs->on_write_error == BLOCKDEV_ON_ERROR_STOP   ||
            bs->on_read_error == BLOCKDEV_ON_ERROR_STOP));
5470 5471 5472 5473
}

void bdrv_iostatus_disable(BlockDriverState *bs)
{
5474
    bs->iostatus_enabled = false;
5475 5476 5477 5478 5479
}

void bdrv_iostatus_reset(BlockDriverState *bs)
{
    if (bdrv_iostatus_is_enabled(bs)) {
5480
        bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
5481 5482 5483
        if (bs->job) {
            block_job_iostatus_reset(bs->job);
        }
5484 5485 5486 5487 5488
    }
}

void bdrv_iostatus_set_err(BlockDriverState *bs, int error)
{
5489 5490
    assert(bdrv_iostatus_is_enabled(bs));
    if (bs->iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
5491 5492
        bs->iostatus = error == ENOSPC ? BLOCK_DEVICE_IO_STATUS_NOSPACE :
                                         BLOCK_DEVICE_IO_STATUS_FAILED;
5493 5494 5495
    }
}

5496 5497 5498 5499 5500 5501 5502
void
bdrv_acct_start(BlockDriverState *bs, BlockAcctCookie *cookie, int64_t bytes,
        enum BlockAcctType type)
{
    assert(type < BDRV_MAX_IOTYPE);

    cookie->bytes = bytes;
C
Christoph Hellwig 已提交
5503
    cookie->start_time_ns = get_clock();
5504 5505 5506 5507 5508 5509 5510 5511 5512 5513
    cookie->type = type;
}

void
bdrv_acct_done(BlockDriverState *bs, BlockAcctCookie *cookie)
{
    assert(cookie->type < BDRV_MAX_IOTYPE);

    bs->nr_bytes[cookie->type] += cookie->bytes;
    bs->nr_ops[cookie->type]++;
C
Christoph Hellwig 已提交
5514
    bs->total_time_ns[cookie->type] += get_clock() - cookie->start_time_ns;
5515 5516
}

5517 5518
void bdrv_img_create(const char *filename, const char *fmt,
                     const char *base_filename, const char *base_fmt,
5519 5520
                     char *options, uint64_t img_size, int flags,
                     Error **errp, bool quiet)
J
Jes Sorensen 已提交
5521
{
5522 5523 5524 5525
    QemuOptsList *create_opts = NULL;
    QemuOpts *opts = NULL;
    const char *backing_fmt, *backing_file;
    int64_t size;
J
Jes Sorensen 已提交
5526
    BlockDriver *drv, *proto_drv;
5527
    BlockDriver *backing_drv = NULL;
5528
    Error *local_err = NULL;
J
Jes Sorensen 已提交
5529 5530 5531 5532 5533
    int ret = 0;

    /* Find driver and parse its options */
    drv = bdrv_find_format(fmt);
    if (!drv) {
5534
        error_setg(errp, "Unknown file format '%s'", fmt);
5535
        return;
J
Jes Sorensen 已提交
5536 5537
    }

5538
    proto_drv = bdrv_find_protocol(filename, true);
J
Jes Sorensen 已提交
5539
    if (!proto_drv) {
5540
        error_setg(errp, "Unknown protocol '%s'", filename);
5541
        return;
J
Jes Sorensen 已提交
5542 5543
    }

C
Chunyan Liu 已提交
5544 5545
    create_opts = qemu_opts_append(create_opts, drv->create_opts);
    create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
J
Jes Sorensen 已提交
5546 5547

    /* Create parameter list with default values */
5548 5549
    opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
    qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size);
J
Jes Sorensen 已提交
5550 5551 5552

    /* Parse -o options */
    if (options) {
5553 5554
        if (qemu_opts_do_parse(opts, options, NULL) != 0) {
            error_setg(errp, "Invalid options for file format '%s'", fmt);
J
Jes Sorensen 已提交
5555 5556 5557 5558 5559
            goto out;
        }
    }

    if (base_filename) {
5560
        if (qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename)) {
5561 5562
            error_setg(errp, "Backing file not supported for file format '%s'",
                       fmt);
J
Jes Sorensen 已提交
5563 5564 5565 5566 5567
            goto out;
        }
    }

    if (base_fmt) {
5568
        if (qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt)) {
5569 5570
            error_setg(errp, "Backing file format not supported for file "
                             "format '%s'", fmt);
J
Jes Sorensen 已提交
5571 5572 5573 5574
            goto out;
        }
    }

5575 5576 5577
    backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
    if (backing_file) {
        if (!strcmp(filename, backing_file)) {
5578 5579
            error_setg(errp, "Error: Trying to create an image with the "
                             "same filename as the backing file");
5580 5581 5582 5583
            goto out;
        }
    }

5584 5585 5586
    backing_fmt = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT);
    if (backing_fmt) {
        backing_drv = bdrv_find_format(backing_fmt);
5587
        if (!backing_drv) {
5588
            error_setg(errp, "Unknown backing file format '%s'",
5589
                       backing_fmt);
J
Jes Sorensen 已提交
5590 5591 5592 5593 5594 5595
            goto out;
        }
    }

    // The size for the image must always be specified, with one exception:
    // If we are using a backing file, we can obtain the size from there
5596 5597 5598
    size = qemu_opt_get_size(opts, BLOCK_OPT_SIZE, 0);
    if (size == -1) {
        if (backing_file) {
5599
            BlockDriverState *bs;
J
Jes Sorensen 已提交
5600
            uint64_t size;
5601 5602 5603 5604 5605
            int back_flags;

            /* backing files always opened read-only */
            back_flags =
                flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
J
Jes Sorensen 已提交
5606

5607
            bs = NULL;
5608
            ret = bdrv_open(&bs, backing_file, NULL, NULL, back_flags,
5609
                            backing_drv, &local_err);
J
Jes Sorensen 已提交
5610
            if (ret < 0) {
5611
                error_setg_errno(errp, -ret, "Could not open '%s': %s",
5612
                                 backing_file,
5613 5614 5615
                                 error_get_pretty(local_err));
                error_free(local_err);
                local_err = NULL;
J
Jes Sorensen 已提交
5616 5617 5618 5619 5620
                goto out;
            }
            bdrv_get_geometry(bs, &size);
            size *= 512;

5621
            qemu_opt_set_number(opts, BLOCK_OPT_SIZE, size);
5622 5623

            bdrv_unref(bs);
J
Jes Sorensen 已提交
5624
        } else {
5625
            error_setg(errp, "Image creation needs a size parameter");
J
Jes Sorensen 已提交
5626 5627 5628 5629
            goto out;
        }
    }

5630 5631
    if (!quiet) {
        printf("Formatting '%s', fmt=%s ", filename, fmt);
5632
        qemu_opts_print(opts);
5633 5634
        puts("");
    }
5635

C
Chunyan Liu 已提交
5636
    ret = bdrv_create(drv, filename, opts, &local_err);
5637

5638 5639 5640 5641 5642
    if (ret == -EFBIG) {
        /* This is generally a better message than whatever the driver would
         * deliver (especially because of the cluster_size_hint), since that
         * is most probably not much different from "image too large". */
        const char *cluster_size_hint = "";
5643
        if (qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE, 0)) {
5644
            cluster_size_hint = " (try using a larger cluster size)";
J
Jes Sorensen 已提交
5645
        }
5646 5647 5648 5649
        error_setg(errp, "The image size is too large for file format '%s'"
                   "%s", fmt, cluster_size_hint);
        error_free(local_err);
        local_err = NULL;
J
Jes Sorensen 已提交
5650 5651 5652
    }

out:
5653 5654
    qemu_opts_del(opts);
    qemu_opts_free(create_opts);
5655
    if (local_err) {
5656 5657
        error_propagate(errp, local_err);
    }
J
Jes Sorensen 已提交
5658
}
5659 5660 5661

AioContext *bdrv_get_aio_context(BlockDriverState *bs)
{
5662 5663 5664 5665 5666 5667 5668 5669 5670
    return bs->aio_context;
}

void bdrv_detach_aio_context(BlockDriverState *bs)
{
    if (!bs->drv) {
        return;
    }

5671 5672 5673
    if (bs->io_limits_enabled) {
        throttle_detach_aio_context(&bs->throttle_state);
    }
5674 5675 5676 5677 5678 5679 5680 5681 5682 5683 5684 5685 5686 5687 5688 5689 5690 5691 5692 5693 5694 5695 5696 5697 5698 5699 5700 5701 5702 5703 5704
    if (bs->drv->bdrv_detach_aio_context) {
        bs->drv->bdrv_detach_aio_context(bs);
    }
    if (bs->file) {
        bdrv_detach_aio_context(bs->file);
    }
    if (bs->backing_hd) {
        bdrv_detach_aio_context(bs->backing_hd);
    }

    bs->aio_context = NULL;
}

void bdrv_attach_aio_context(BlockDriverState *bs,
                             AioContext *new_context)
{
    if (!bs->drv) {
        return;
    }

    bs->aio_context = new_context;

    if (bs->backing_hd) {
        bdrv_attach_aio_context(bs->backing_hd, new_context);
    }
    if (bs->file) {
        bdrv_attach_aio_context(bs->file, new_context);
    }
    if (bs->drv->bdrv_attach_aio_context) {
        bs->drv->bdrv_attach_aio_context(bs, new_context);
    }
5705 5706 5707
    if (bs->io_limits_enabled) {
        throttle_attach_aio_context(&bs->throttle_state, new_context);
    }
5708 5709 5710 5711 5712 5713 5714 5715 5716 5717 5718 5719 5720 5721
}

void bdrv_set_aio_context(BlockDriverState *bs, AioContext *new_context)
{
    bdrv_drain_all(); /* ensure there are no in-flight requests */

    bdrv_detach_aio_context(bs);

    /* This function executes in the old AioContext so acquire the new one in
     * case it runs in a different thread.
     */
    aio_context_acquire(new_context);
    bdrv_attach_aio_context(bs, new_context);
    aio_context_release(new_context);
5722
}
5723 5724 5725 5726 5727 5728

void bdrv_add_before_write_notifier(BlockDriverState *bs,
                                    NotifierWithReturn *notifier)
{
    notifier_with_return_list_add(&bs->before_write_notifiers, notifier);
}
M
Max Reitz 已提交
5729

C
Chunyan Liu 已提交
5730
int bdrv_amend_options(BlockDriverState *bs, QemuOpts *opts)
M
Max Reitz 已提交
5731
{
C
Chunyan Liu 已提交
5732
    if (!bs->drv->bdrv_amend_options) {
M
Max Reitz 已提交
5733 5734
        return -ENOTSUP;
    }
C
Chunyan Liu 已提交
5735
    return bs->drv->bdrv_amend_options(bs, opts);
M
Max Reitz 已提交
5736
}
5737

5738 5739 5740 5741
/* This function will be called by the bdrv_recurse_is_first_non_filter method
 * of block filter and by bdrv_is_first_non_filter.
 * It is used to test if the given bs is the candidate or recurse more in the
 * node graph.
5742
 */
5743
bool bdrv_recurse_is_first_non_filter(BlockDriverState *bs,
5744
                                      BlockDriverState *candidate)
5745
{
5746 5747
    /* return false if basic checks fails */
    if (!bs || !bs->drv) {
5748
        return false;
5749 5750
    }

5751 5752 5753 5754 5755
    /* the code reached a non block filter driver -> check if the bs is
     * the same as the candidate. It's the recursion termination condition.
     */
    if (!bs->drv->is_filter) {
        return bs == candidate;
5756
    }
5757
    /* Down this path the driver is a block filter driver */
5758

5759 5760 5761 5762
    /* If the block filter recursion method is defined use it to recurse down
     * the node graph.
     */
    if (bs->drv->bdrv_recurse_is_first_non_filter) {
5763
        return bs->drv->bdrv_recurse_is_first_non_filter(bs, candidate);
5764 5765
    }

5766 5767 5768
    /* the driver is a block filter but don't allow to recurse -> return false
     */
    return false;
5769 5770
}

5771 5772 5773 5774 5775
/* This function checks if the candidate is the first non filter bs down it's
 * bs chain. Since we don't have pointers to parents it explore all bs chains
 * from the top. Some filters can choose not to pass down the recursion.
 */
bool bdrv_is_first_non_filter(BlockDriverState *candidate)
5776
{
5777 5778 5779 5780 5781 5782
    BlockDriverState *bs;

    /* walk down the bs forest recursively */
    QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
        bool perm;

5783
        /* try to recurse in this top level bs */
5784
        perm = bdrv_recurse_is_first_non_filter(bs, candidate);
5785 5786 5787 5788 5789 5790 5791 5792

        /* candidate is the first non filter */
        if (perm) {
            return true;
        }
    }

    return false;
5793
}
5794 5795 5796 5797 5798 5799 5800 5801 5802 5803 5804 5805 5806 5807 5808 5809 5810 5811 5812 5813 5814 5815 5816 5817 5818

BlockDriverState *check_to_replace_node(const char *node_name, Error **errp)
{
    BlockDriverState *to_replace_bs = bdrv_find_node(node_name);
    if (!to_replace_bs) {
        error_setg(errp, "Node name '%s' not found", node_name);
        return NULL;
    }

    if (bdrv_op_is_blocked(to_replace_bs, BLOCK_OP_TYPE_REPLACE, errp)) {
        return NULL;
    }

    /* We don't want arbitrary node of the BDS chain to be replaced only the top
     * most non filter in order to prevent data corruption.
     * Another benefit is that this tests exclude backing files which are
     * blocked by the backing blockers.
     */
    if (!bdrv_is_first_non_filter(to_replace_bs)) {
        error_setg(errp, "Only top most non filter can be replaced");
        return NULL;
    }

    return to_replace_bs;
}
5819 5820 5821 5822 5823 5824 5825 5826 5827 5828 5829 5830 5831 5832 5833 5834 5835 5836 5837 5838 5839 5840 5841 5842 5843 5844 5845 5846 5847 5848

void bdrv_io_plug(BlockDriverState *bs)
{
    BlockDriver *drv = bs->drv;
    if (drv && drv->bdrv_io_plug) {
        drv->bdrv_io_plug(bs);
    } else if (bs->file) {
        bdrv_io_plug(bs->file);
    }
}

void bdrv_io_unplug(BlockDriverState *bs)
{
    BlockDriver *drv = bs->drv;
    if (drv && drv->bdrv_io_unplug) {
        drv->bdrv_io_unplug(bs);
    } else if (bs->file) {
        bdrv_io_unplug(bs->file);
    }
}

void bdrv_flush_io_queue(BlockDriverState *bs)
{
    BlockDriver *drv = bs->drv;
    if (drv && drv->bdrv_flush_io_queue) {
        drv->bdrv_flush_io_queue(bs);
    } else if (bs->file) {
        bdrv_flush_io_queue(bs->file);
    }
}