block.c 153.8 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
#include "monitor/monitor.h"
28 29
#include "block/block_int.h"
#include "block/blockjob.h"
30
#include "qemu/module.h"
31
#include "qapi/qmp/qjson.h"
32
#include "sysemu/sysemu.h"
33
#include "qemu/notify.h"
34
#include "block/coroutine.h"
35
#include "block/qapi.h"
L
Luiz Capitulino 已提交
36
#include "qmp-commands.h"
37
#include "qemu/timer.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 182 183 184 185 186 187 188 189 190 191 192 193
/* 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,
                  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 已提交
194
static void bdrv_io_limits_intercept(BlockDriverState *bs,
195
                                     unsigned int bytes,
196
                                     bool is_write)
Z
Zhi Yong Wu 已提交
197
{
198 199
    /* does this io must wait */
    bool must_wait = throttle_schedule_timer(&bs->throttle_state, is_write);
Z
Zhi Yong Wu 已提交
200

201 202 203 204
    /* 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 已提交
205 206
    }

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

Z
Zhi Yong Wu 已提交
210

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

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

220 221 222 223 224 225 226 227 228 229
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;
}

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

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

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

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

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

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

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

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

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

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

339 340 341 342 343 344 345 346 347 348 349
    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;
    }

350
    bs = g_malloc0(sizeof(BlockDriverState));
F
Fam Zheng 已提交
351
    QLIST_INIT(&bs->dirty_bitmaps);
B
bellard 已提交
352
    pstrcpy(bs->device_name, sizeof(bs->device_name), device_name);
B
bellard 已提交
353
    if (device_name[0] != '\0') {
354
        QTAILQ_INSERT_TAIL(&bdrv_states, bs, device_list);
B
bellard 已提交
355
    }
356
    bdrv_iostatus_disable(bs);
P
Paolo Bonzini 已提交
357
    notifier_list_init(&bs->close_notifiers);
358
    notifier_with_return_list_init(&bs->before_write_notifiers);
359 360
    qemu_co_queue_init(&bs->throttled_reqs[0]);
    qemu_co_queue_init(&bs->throttled_reqs[1]);
361
    bs->refcnt = 1;
P
Paolo Bonzini 已提交
362

B
bellard 已提交
363 364 365
    return bs;
}

P
Paolo Bonzini 已提交
366 367 368 369 370
void bdrv_add_close_notifier(BlockDriverState *bs, Notifier *notify)
{
    notifier_list_add(&bs->close_notifiers, notify);
}

B
bellard 已提交
371 372 373
BlockDriver *bdrv_find_format(const char *format_name)
{
    BlockDriver *drv1;
374 375
    QLIST_FOREACH(drv1, &bdrv_drivers, list) {
        if (!strcmp(drv1->format_name, format_name)) {
B
bellard 已提交
376
            return drv1;
377
        }
B
bellard 已提交
378 379 380 381
    }
    return NULL;
}

382
static int bdrv_is_whitelisted(BlockDriver *drv, bool read_only)
383
{
384 385 386 387 388
    static const char *whitelist_rw[] = {
        CONFIG_BDRV_RW_WHITELIST
    };
    static const char *whitelist_ro[] = {
        CONFIG_BDRV_RO_WHITELIST
389 390 391
    };
    const char **p;

392
    if (!whitelist_rw[0] && !whitelist_ro[0]) {
393
        return 1;               /* no whitelist, anything goes */
394
    }
395

396
    for (p = whitelist_rw; *p; p++) {
397 398 399 400
        if (!strcmp(drv->format_name, *p)) {
            return 1;
        }
    }
401 402 403 404 405 406 407
    if (read_only) {
        for (p = whitelist_ro; *p; p++) {
            if (!strcmp(drv->format_name, *p)) {
                return 1;
            }
        }
    }
408 409 410
    return 0;
}

411 412
BlockDriver *bdrv_find_whitelisted_format(const char *format_name,
                                          bool read_only)
413 414
{
    BlockDriver *drv = bdrv_find_format(format_name);
415
    return drv && bdrv_is_whitelisted(drv, read_only) ? drv : NULL;
416 417
}

418 419 420 421 422
typedef struct CreateCo {
    BlockDriver *drv;
    char *filename;
    QEMUOptionParameter *options;
    int ret;
423
    Error *err;
424 425 426 427
} CreateCo;

static void coroutine_fn bdrv_create_co_entry(void *opaque)
{
428 429 430
    Error *local_err = NULL;
    int ret;

431 432 433
    CreateCo *cco = opaque;
    assert(cco->drv);

434
    ret = cco->drv->bdrv_create(cco->filename, cco->options, &local_err);
435
    if (local_err) {
436 437 438
        error_propagate(&cco->err, local_err);
    }
    cco->ret = ret;
439 440
}

441
int bdrv_create(BlockDriver *drv, const char* filename,
442
    QEMUOptionParameter *options, Error **errp)
B
bellard 已提交
443
{
444 445 446 447 448 449 450 451
    int ret;

    Coroutine *co;
    CreateCo cco = {
        .drv = drv,
        .filename = g_strdup(filename),
        .options = options,
        .ret = NOT_DONE,
452
        .err = NULL,
453 454 455
    };

    if (!drv->bdrv_create) {
456
        error_setg(errp, "Driver '%s' does not support image creation", drv->format_name);
457 458
        ret = -ENOTSUP;
        goto out;
459 460 461 462 463 464 465 466 467 468 469 470 471 472
    }

    if (qemu_in_coroutine()) {
        /* Fast-path if already in coroutine context */
        bdrv_create_co_entry(&cco);
    } else {
        co = qemu_coroutine_create(bdrv_create_co_entry);
        qemu_coroutine_enter(co, &cco);
        while (cco.ret == NOT_DONE) {
            qemu_aio_wait();
        }
    }

    ret = cco.ret;
473
    if (ret < 0) {
474
        if (cco.err) {
475 476 477 478 479
            error_propagate(errp, cco.err);
        } else {
            error_setg_errno(errp, -ret, "Could not create image");
        }
    }
480

481 482
out:
    g_free(cco.filename);
483
    return ret;
B
bellard 已提交
484 485
}

486 487
int bdrv_create_file(const char* filename, QEMUOptionParameter *options,
                     Error **errp)
488 489
{
    BlockDriver *drv;
490 491
    Error *local_err = NULL;
    int ret;
492

493
    drv = bdrv_find_protocol(filename, true);
494
    if (drv == NULL) {
495
        error_setg(errp, "Could not find protocol for file '%s'", filename);
496
        return -ENOENT;
497 498
    }

499
    ret = bdrv_create(drv, filename, options, &local_err);
500
    if (local_err) {
501 502 503
        error_propagate(errp, local_err);
    }
    return ret;
504 505
}

506
int bdrv_refresh_limits(BlockDriverState *bs)
507 508 509 510 511
{
    BlockDriver *drv = bs->drv;

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

K
Kevin Wolf 已提交
512 513 514 515 516 517 518 519
    if (!drv) {
        return 0;
    }

    /* Take some limits from the children as a default */
    if (bs->file) {
        bdrv_refresh_limits(bs->file);
        bs->bl.opt_transfer_length = bs->file->bl.opt_transfer_length;
520 521 522
        bs->bl.opt_mem_alignment = bs->file->bl.opt_mem_alignment;
    } else {
        bs->bl.opt_mem_alignment = 512;
K
Kevin Wolf 已提交
523 524 525 526 527 528 529
    }

    if (bs->backing_hd) {
        bdrv_refresh_limits(bs->backing_hd);
        bs->bl.opt_transfer_length =
            MAX(bs->bl.opt_transfer_length,
                bs->backing_hd->bl.opt_transfer_length);
530 531 532
        bs->bl.opt_mem_alignment =
            MAX(bs->bl.opt_mem_alignment,
                bs->backing_hd->bl.opt_mem_alignment);
K
Kevin Wolf 已提交
533 534 535 536
    }

    /* Then let the driver override it */
    if (drv->bdrv_refresh_limits) {
537 538 539 540 541 542
        return drv->bdrv_refresh_limits(bs);
    }

    return 0;
}

543 544 545 546 547
/*
 * 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 已提交
548
{
549
#ifdef _WIN32
550
    char temp_dir[MAX_PATH];
551 552 553 554 555 556
    /* 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 已提交
557
#else
B
bellard 已提交
558
    int fd;
559
    const char *tmpdir;
A
aurel32 已提交
560
    tmpdir = getenv("TMPDIR");
561 562 563
    if (!tmpdir) {
        tmpdir = "/var/tmp";
    }
564 565 566
    if (snprintf(filename, size, "%s/vl.XXXXXX", tmpdir) >= size) {
        return -EOVERFLOW;
    }
B
bellard 已提交
567
    fd = mkstemp(filename);
568 569 570 571 572
    if (fd < 0) {
        return -errno;
    }
    if (close(fd) != 0) {
        unlink(filename);
573 574 575
        return -errno;
    }
    return 0;
B
bellard 已提交
576
#endif
577
}
B
bellard 已提交
578

579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600
/*
 * 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;
}

601 602
BlockDriver *bdrv_find_protocol(const char *filename,
                                bool allow_protocol_prefix)
B
bellard 已提交
603 604 605
{
    BlockDriver *drv1;
    char protocol[128];
606
    int len;
B
bellard 已提交
607
    const char *p;
B
bellard 已提交
608

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

611 612 613 614 615 616 617 618 619 620 621 622
    /*
     * 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;
    }

623
    if (!path_has_protocol(filename) || !allow_protocol_prefix) {
624
        return bdrv_find_format("file");
625
    }
626

627 628
    p = strchr(filename, ':');
    assert(p != NULL);
629 630 631 632 633
    len = p - filename;
    if (len > sizeof(protocol) - 1)
        len = sizeof(protocol) - 1;
    memcpy(protocol, filename, len);
    protocol[len] = '\0';
634
    QLIST_FOREACH(drv1, &bdrv_drivers, list) {
635
        if (drv1->protocol_name &&
636
            !strcmp(drv1->protocol_name, protocol)) {
B
bellard 已提交
637
            return drv1;
638
        }
B
bellard 已提交
639 640 641 642
    }
    return NULL;
}

643
static int find_image_format(BlockDriverState *bs, const char *filename,
644
                             BlockDriver **pdrv, Error **errp)
645
{
646
    int score, score_max;
647 648
    BlockDriver *drv1, *drv;
    uint8_t buf[2048];
649
    int ret = 0;
650

651
    /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
652
    if (bs->sg || !bdrv_is_inserted(bs) || bdrv_getlength(bs) == 0) {
653 654
        drv = bdrv_find_format("raw");
        if (!drv) {
655
            error_setg(errp, "Could not find raw image format");
656 657 658 659
            ret = -ENOENT;
        }
        *pdrv = drv;
        return ret;
660
    }
661

B
bellard 已提交
662 663
    ret = bdrv_pread(bs, 0, buf, sizeof(buf));
    if (ret < 0) {
664 665
        error_setg_errno(errp, -ret, "Could not read image for determining its "
                         "format");
666 667
        *pdrv = NULL;
        return ret;
B
bellard 已提交
668 669
    }

B
bellard 已提交
670
    score_max = 0;
671
    drv = NULL;
672
    QLIST_FOREACH(drv1, &bdrv_drivers, list) {
B
bellard 已提交
673 674 675 676 677 678
        if (drv1->bdrv_probe) {
            score = drv1->bdrv_probe(buf, ret, filename);
            if (score > score_max) {
                score_max = score;
                drv = drv1;
            }
B
bellard 已提交
679
        }
B
bellard 已提交
680
    }
681
    if (!drv) {
682 683
        error_setg(errp, "Could not determine image format: No compatible "
                   "driver found");
684 685 686 687
        ret = -ENOENT;
    }
    *pdrv = drv;
    return ret;
B
bellard 已提交
688 689
}

690 691 692 693 694 695 696
/**
 * Set the current 'total_sectors' value
 */
static int refresh_total_sectors(BlockDriverState *bs, int64_t hint)
{
    BlockDriver *drv = bs->drv;

697 698 699 700
    /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
    if (bs->sg)
        return 0;

701 702 703 704 705 706
    /* 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 已提交
707
        hint = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE);
708 709 710 711 712 713
    }

    bs->total_sectors = hint;
    return 0;
}

P
Paolo Bonzini 已提交
714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733
/**
 * 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;
}

734 735 736 737 738 739 740 741 742 743 744
/**
 * 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;
745 746
    } else if (!strcmp(mode, "directsync")) {
        *flags |= BDRV_O_NOCACHE;
747 748 749 750 751 752 753 754 755 756 757 758 759 760
    } 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;
}

761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776
/**
 * 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--;
}

K
Kevin Wolf 已提交
777 778 779 780
static int bdrv_open_flags(BlockDriverState *bs, int flags)
{
    int open_flags = flags | BDRV_O_CACHE_WB;

781 782 783 784 785
    /* The backing file of a temporary snapshot is read-only */
    if (flags & BDRV_O_SNAPSHOT) {
        open_flags &= ~BDRV_O_RDWR;
    }

K
Kevin Wolf 已提交
786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801
    /*
     * Clear flags that are internal to the block layer before opening the
     * image.
     */
    open_flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);

    /*
     * Snapshots should be writable.
     */
    if (bs->is_temporary) {
        open_flags |= BDRV_O_RDWR;
    }

    return open_flags;
}

802 803 804
static void bdrv_assign_node_name(BlockDriverState *bs,
                                  const char *node_name,
                                  Error **errp)
805 806
{
    if (!node_name) {
807
        return;
808 809 810 811 812
    }

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

816 817 818 819
    /* 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);
820
        return;
821 822
    }

823 824 825
    /* takes care of avoiding duplicates node names */
    if (bdrv_find_node(node_name)) {
        error_setg(errp, "Duplicate node name");
826
        return;
827 828 829 830 831 832 833
    }

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

834 835
/*
 * Common part for opening disk images and files
836 837
 *
 * Removes all processed options from *options.
838
 */
839
static int bdrv_open_common(BlockDriverState *bs, BlockDriverState *file,
840
    QDict *options, int flags, BlockDriver *drv, Error **errp)
841 842
{
    int ret, open_flags;
K
Kevin Wolf 已提交
843
    const char *filename;
844
    const char *node_name = NULL;
845
    Error *local_err = NULL;
846 847

    assert(drv != NULL);
848
    assert(bs->file == NULL);
849
    assert(options != NULL && bs->options != options);
850

851 852 853 854 855 856
    if (file != NULL) {
        filename = file->filename;
    } else {
        filename = qdict_get_try_str(options, "filename");
    }

857 858 859 860 861 862
    if (drv->bdrv_needs_filename && !filename) {
        error_setg(errp, "The '%s' block driver requires a file name",
                   drv->format_name);
        return -EINVAL;
    }

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

865
    node_name = qdict_get_try_str(options, "node-name");
866 867 868 869
    bdrv_assign_node_name(bs, node_name, &local_err);
    if (error_is_set(&local_err)) {
        error_propagate(errp, local_err);
        return -EINVAL;
870 871 872
    }
    qdict_del(options, "node-name");

873 874 875 876 877 878 879 880
    /* 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;
    }

881
    bs->open_flags = flags;
882
    bs->guest_block_size = 512;
883
    bs->request_alignment = 512;
A
Asias He 已提交
884
    bs->zero_beyond_eof = true;
885 886 887 888
    open_flags = bdrv_open_flags(bs, flags);
    bs->read_only = !(open_flags & BDRV_O_RDWR);

    if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv, bs->read_only)) {
889 890 891 892 893
        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);
894 895
        return -ENOTSUP;
    }
896

897
    assert(bs->copy_on_read == 0); /* bdrv_new() and bdrv_close() make it so */
898 899 900 901 902 903 904
    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;
        }
905 906
    }

907 908 909 910 911
    if (filename != NULL) {
        pstrcpy(bs->filename, sizeof(bs->filename), filename);
    } else {
        bs->filename[0] = '\0';
    }
912 913

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

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

918 919
    /* Open the image, either directly or using a protocol */
    if (drv->bdrv_file_open) {
920
        assert(file == NULL);
921
        assert(!drv->bdrv_needs_filename || filename != NULL);
922
        ret = drv->bdrv_file_open(bs, options, open_flags, &local_err);
923
    } else {
924
        if (file == NULL) {
925 926
            error_setg(errp, "Can't use '%s' as a block driver for the "
                       "protocol level", drv->format_name);
927 928 929
            ret = -EINVAL;
            goto free_and_fail;
        }
930
        bs->file = file;
931
        ret = drv->bdrv_open(bs, options, open_flags, &local_err);
932 933
    }

934
    if (ret < 0) {
935
        if (local_err) {
936
            error_propagate(errp, local_err);
937 938
        } else if (bs->filename[0]) {
            error_setg_errno(errp, -ret, "Could not open '%s'", bs->filename);
939 940 941
        } else {
            error_setg_errno(errp, -ret, "Could not open image");
        }
942 943 944
        goto free_and_fail;
    }

945 946
    ret = refresh_total_sectors(bs, bs->total_sectors);
    if (ret < 0) {
947
        error_setg_errno(errp, -ret, "Could not refresh total sector count");
948
        goto free_and_fail;
949
    }
950

951
    bdrv_refresh_limits(bs);
952
    assert(bdrv_opt_mem_align(bs) != 0);
953
    assert((bs->request_alignment != 0) || bs->sg);
954

955 956
#ifndef _WIN32
    if (bs->is_temporary) {
D
Dunrong Huang 已提交
957 958
        assert(bs->filename[0] != '\0');
        unlink(bs->filename);
959 960 961 962 963
    }
#endif
    return 0;

free_and_fail:
964
    bs->file = NULL;
965
    g_free(bs->opaque);
966 967 968 969 970
    bs->opaque = NULL;
    bs->drv = NULL;
    return ret;
}

K
Kevin Wolf 已提交
971 972
/*
 * Opens a file using a protocol (file, host_device, nbd, ...)
973
 *
974 975 976 977 978 979
 * options is an indirect pointer to a QDict of options to pass to the block
 * drivers, or pointer to NULL for an empty set of options. If this function
 * takes ownership of the QDict reference, it will set *options to NULL;
 * otherwise, it will contain unused/unrecognized options after this function
 * returns. Then, the caller is responsible for freeing it. If it intends to
 * reuse the QDict, QINCREF() should be called beforehand.
K
Kevin Wolf 已提交
980
 */
981
static int bdrv_file_open(BlockDriverState *bs, const char *filename,
982
                          QDict **options, int flags, Error **errp)
B
bellard 已提交
983
{
984
    BlockDriver *drv;
985
    const char *drvname;
986
    bool parse_filename = false;
987
    Error *local_err = NULL;
B
bellard 已提交
988 989
    int ret;

K
Kevin Wolf 已提交
990 991
    /* Fetch the file name from the options QDict if necessary */
    if (!filename) {
992 993 994
        filename = qdict_get_try_str(*options, "filename");
    } else if (filename && !qdict_haskey(*options, "filename")) {
        qdict_put(*options, "filename", qstring_from_str(filename));
995
        parse_filename = true;
K
Kevin Wolf 已提交
996
    } else {
997 998
        error_setg(errp, "Can't specify 'file' and 'filename' options at the "
                   "same time");
K
Kevin Wolf 已提交
999 1000 1001 1002
        ret = -EINVAL;
        goto fail;
    }

1003
    /* Find the right block driver */
1004
    drvname = qdict_get_try_str(*options, "driver");
1005
    if (drvname) {
1006
        drv = bdrv_find_format(drvname);
1007 1008 1009
        if (!drv) {
            error_setg(errp, "Unknown driver '%s'", drvname);
        }
1010
        qdict_del(*options, "driver");
1011
    } else if (filename) {
1012
        drv = bdrv_find_protocol(filename, parse_filename);
1013
        if (!drv) {
1014
            error_setg(errp, "Unknown protocol");
1015
        }
1016
    } else {
1017
        error_setg(errp, "Must specify either driver or file");
1018 1019 1020 1021
        drv = NULL;
    }

    if (!drv) {
1022
        /* errp has been set already */
1023 1024 1025 1026 1027
        ret = -ENOENT;
        goto fail;
    }

    /* Parse the filename and open it */
1028
    if (drv->bdrv_parse_filename && parse_filename) {
1029
        drv->bdrv_parse_filename(filename, *options, &local_err);
1030
        if (local_err) {
1031
            error_propagate(errp, local_err);
1032 1033 1034
            ret = -EINVAL;
            goto fail;
        }
1035 1036 1037 1038 1039 1040

        if (!drv->bdrv_needs_filename) {
            qdict_del(*options, "filename");
        } else {
            filename = qdict_get_str(*options, "filename");
        }
1041 1042
    }

M
Max Reitz 已提交
1043
    if (!drv->bdrv_file_open) {
1044 1045
        ret = bdrv_open(&bs, filename, NULL, *options, flags, drv, &local_err);
        *options = NULL;
M
Max Reitz 已提交
1046
    } else {
1047
        ret = bdrv_open_common(bs, NULL, *options, flags, drv, &local_err);
M
Max Reitz 已提交
1048
    }
B
bellard 已提交
1049
    if (ret < 0) {
1050
        error_propagate(errp, local_err);
1051 1052 1053
        goto fail;
    }

1054
    bs->growable = 1;
B
bellard 已提交
1055
    return 0;
1056 1057 1058

fail:
    return ret;
B
bellard 已提交
1059 1060
}

1061 1062 1063 1064 1065 1066 1067 1068
/*
 * 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.
 */
1069
int bdrv_open_backing_file(BlockDriverState *bs, QDict *options, Error **errp)
P
Paolo Bonzini 已提交
1070 1071 1072 1073
{
    char backing_filename[PATH_MAX];
    int back_flags, ret;
    BlockDriver *back_drv = NULL;
1074
    Error *local_err = NULL;
P
Paolo Bonzini 已提交
1075 1076

    if (bs->backing_hd != NULL) {
1077
        QDECREF(options);
P
Paolo Bonzini 已提交
1078 1079 1080
        return 0;
    }

1081 1082 1083 1084 1085
    /* NULL means an empty set of options */
    if (options == NULL) {
        options = qdict_new();
    }

P
Paolo Bonzini 已提交
1086
    bs->open_flags &= ~BDRV_O_NO_BACKING;
1087 1088 1089
    if (qdict_haskey(options, "file.filename")) {
        backing_filename[0] = '\0';
    } else if (bs->backing_file[0] == '\0' && qdict_size(options) == 0) {
1090
        QDECREF(options);
P
Paolo Bonzini 已提交
1091
        return 0;
F
Fam Zheng 已提交
1092 1093 1094
    } else {
        bdrv_get_full_backing_filename(bs, backing_filename,
                                       sizeof(backing_filename));
P
Paolo Bonzini 已提交
1095 1096 1097 1098 1099 1100 1101
    }

    if (bs->backing_format[0] != '\0') {
        back_drv = bdrv_find_format(bs->backing_format);
    }

    /* backing files always opened read-only */
1102 1103
    back_flags = bs->open_flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT |
                                    BDRV_O_COPY_ON_READ);
P
Paolo Bonzini 已提交
1104

1105 1106
    assert(bs->backing_hd == NULL);
    ret = bdrv_open(&bs->backing_hd,
1107
                    *backing_filename ? backing_filename : NULL, NULL, options,
1108
                    back_flags, back_drv, &local_err);
P
Paolo Bonzini 已提交
1109 1110 1111
    if (ret < 0) {
        bs->backing_hd = NULL;
        bs->open_flags |= BDRV_O_NO_BACKING;
1112 1113 1114
        error_setg(errp, "Could not open backing file: %s",
                   error_get_pretty(local_err));
        error_free(local_err);
P
Paolo Bonzini 已提交
1115 1116
        return ret;
    }
P
Peter Feiner 已提交
1117 1118 1119 1120 1121 1122

    if (bs->backing_hd->file) {
        pstrcpy(bs->backing_file, sizeof(bs->backing_file),
                bs->backing_hd->file->filename);
    }

1123 1124 1125
    /* Recalculate the BlockLimits with the backing file */
    bdrv_refresh_limits(bs);

P
Paolo Bonzini 已提交
1126 1127 1128
    return 0;
}

M
Max Reitz 已提交
1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141
/*
 * 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.
1142 1143
 *
 * To conform with the behavior of bdrv_open(), *pbs has to be NULL.
M
Max Reitz 已提交
1144 1145 1146
 */
int bdrv_open_image(BlockDriverState **pbs, const char *filename,
                    QDict *options, const char *bdref_key, int flags,
1147
                    bool allow_none, Error **errp)
M
Max Reitz 已提交
1148 1149 1150 1151 1152 1153
{
    QDict *image_options;
    int ret;
    char *bdref_key_dot;
    const char *reference;

1154 1155 1156
    assert(pbs);
    assert(*pbs == NULL);

M
Max Reitz 已提交
1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172
    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;
        }
        goto done;
    }

1173
    ret = bdrv_open(pbs, filename, reference, image_options, flags, NULL, errp);
M
Max Reitz 已提交
1174 1175 1176 1177 1178 1179

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

1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196
void bdrv_append_temp_snapshot(BlockDriverState *bs, Error **errp)
{
    /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
    char tmp_filename[PATH_MAX + 1];

    int64_t total_size;
    BlockDriver *bdrv_qcow2;
    QEMUOptionParameter *create_options;
    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 */
1197 1198 1199 1200 1201 1202
    total_size = bdrv_getlength(bs);
    if (total_size < 0) {
        error_setg_errno(errp, -total_size, "Could not get image size");
        return;
    }
    total_size &= BDRV_SECTOR_MASK;
1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233

    /* Create the temporary image */
    ret = get_tmp_filename(tmp_filename, sizeof(tmp_filename));
    if (ret < 0) {
        error_setg_errno(errp, -ret, "Could not get temporary filename");
        return;
    }

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

    set_option_parameter_int(create_options, BLOCK_OPT_SIZE, total_size);

    ret = bdrv_create(bdrv_qcow2, tmp_filename, create_options, &local_err);
    free_option_parameters(create_options);
    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);
        return;
    }

    /* 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 已提交
1234
    bs_snapshot = bdrv_new("", &error_abort);
1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246
    bs_snapshot->is_temporary = 1;

    ret = bdrv_open(&bs_snapshot, NULL, NULL, snapshot_options,
                    bs->open_flags & ~BDRV_O_SNAPSHOT, bdrv_qcow2, &local_err);
    if (ret < 0) {
        error_propagate(errp, local_err);
        return;
    }

    bdrv_append(bs_snapshot, bs);
}

K
Kevin Wolf 已提交
1247 1248
/*
 * Opens a disk image (raw, qcow2, vmdk, ...)
1249 1250 1251 1252 1253
 *
 * 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.
1254 1255 1256
 *
 * 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.
1257 1258 1259 1260
 *
 * 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 已提交
1261
 */
1262 1263 1264
int bdrv_open(BlockDriverState **pbs, const char *filename,
              const char *reference, QDict *options, int flags,
              BlockDriver *drv, Error **errp)
B
bellard 已提交
1265
{
K
Kevin Wolf 已提交
1266
    int ret;
1267
    BlockDriverState *file = NULL, *bs;
1268
    const char *drvname;
1269
    Error *local_err = NULL;
B
bellard 已提交
1270

1271 1272
    assert(pbs);

1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297
    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;
    }

1298 1299 1300
    if (*pbs) {
        bs = *pbs;
    } else {
K
Kevin Wolf 已提交
1301
        bs = bdrv_new("", &error_abort);
1302 1303
    }

1304 1305 1306 1307 1308 1309
    /* NULL means an empty set of options */
    if (options == NULL) {
        options = qdict_new();
    }

    bs->options = options;
1310
    options = qdict_clone_shallow(options);
1311

1312 1313
    if (flags & BDRV_O_PROTOCOL) {
        assert(!drv);
1314
        ret = bdrv_file_open(bs, filename, &options, flags & ~BDRV_O_PROTOCOL,
1315 1316
                             &local_err);
        if (!ret) {
1317
            drv = bs->drv;
1318
            goto done;
1319 1320 1321 1322 1323 1324 1325
        } else if (bs->drv) {
            goto close_and_fail;
        } else {
            goto fail;
        }
    }

1326 1327 1328 1329 1330
    /* Open image file without format layer */
    if (flags & BDRV_O_RDWR) {
        flags |= BDRV_O_ALLOW_RDWR;
    }

1331
    assert(file == NULL);
1332
    ret = bdrv_open_image(&file, filename, options, "file",
1333 1334
                          bdrv_open_flags(bs, flags | BDRV_O_UNMAP) |
                          BDRV_O_PROTOCOL, true, &local_err);
1335
    if (ret < 0) {
M
Max Reitz 已提交
1336
        goto unlink_and_fail;
1337 1338
    }

K
Kevin Wolf 已提交
1339
    /* Find the right image format driver */
1340 1341
    drvname = qdict_get_try_str(options, "driver");
    if (drvname) {
1342
        drv = bdrv_find_format(drvname);
1343
        qdict_del(options, "driver");
1344 1345 1346 1347 1348
        if (!drv) {
            error_setg(errp, "Invalid driver: '%s'", drvname);
            ret = -EINVAL;
            goto unlink_and_fail;
        }
1349 1350
    }

1351
    if (!drv) {
1352 1353 1354 1355 1356 1357 1358
        if (file) {
            ret = find_image_format(file, filename, &drv, &local_err);
        } else {
            error_setg(errp, "Must specify either driver or file");
            ret = -EINVAL;
            goto unlink_and_fail;
        }
1359
    }
1360

1361 1362
    if (!drv) {
        goto unlink_and_fail;
B
bellard 已提交
1363
    }
K
Kevin Wolf 已提交
1364 1365

    /* Open the image */
1366
    ret = bdrv_open_common(bs, file, options, flags, drv, &local_err);
K
Kevin Wolf 已提交
1367
    if (ret < 0) {
1368 1369 1370
        goto unlink_and_fail;
    }

1371
    if (file && (bs->file != file)) {
F
Fam Zheng 已提交
1372
        bdrv_unref(file);
1373 1374 1375
        file = NULL;
    }

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

1380
        qdict_extract_subqdict(options, &backing_options, "backing.");
1381
        ret = bdrv_open_backing_file(bs, backing_options, &local_err);
K
Kevin Wolf 已提交
1382
        if (ret < 0) {
1383
            goto close_and_fail;
K
Kevin Wolf 已提交
1384 1385 1386
        }
    }

1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397
    /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
     * temporary snapshot afterwards. */
    if (flags & BDRV_O_SNAPSHOT) {
        bdrv_append_temp_snapshot(bs, &local_err);
        if (local_err) {
            error_propagate(errp, local_err);
            goto close_and_fail;
        }
    }


1398
done:
1399
    /* Check if any unknown options were used */
1400
    if (options && (qdict_size(options) != 0)) {
1401
        const QDictEntry *entry = qdict_first(options);
1402 1403 1404 1405 1406 1407 1408 1409
        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);
        }
1410 1411 1412 1413 1414

        ret = -EINVAL;
        goto close_and_fail;
    }

K
Kevin Wolf 已提交
1415
    if (!bdrv_key_required(bs)) {
1416
        bdrv_dev_change_media_cb(bs, true);
1417 1418 1419 1420 1421 1422 1423
    } 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 已提交
1424 1425
    }

1426
    QDECREF(options);
1427
    *pbs = bs;
K
Kevin Wolf 已提交
1428 1429 1430
    return 0;

unlink_and_fail:
1431
    if (file != NULL) {
F
Fam Zheng 已提交
1432
        bdrv_unref(file);
1433
    }
K
Kevin Wolf 已提交
1434 1435 1436
    if (bs->is_temporary) {
        unlink(filename);
    }
1437 1438
fail:
    QDECREF(bs->options);
1439
    QDECREF(options);
1440
    bs->options = NULL;
1441 1442 1443 1444 1445 1446
    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);
    }
1447
    if (local_err) {
1448 1449
        error_propagate(errp, local_err);
    }
1450
    return ret;
1451

1452
close_and_fail:
1453 1454 1455 1456 1457 1458
    /* See fail path, but now the BDS has to be always closed */
    if (*pbs) {
        bdrv_close(bs);
    } else {
        bdrv_unref(bs);
    }
1459
    QDECREF(options);
1460
    if (local_err) {
1461 1462
        error_propagate(errp, local_err);
    }
K
Kevin Wolf 已提交
1463 1464 1465
    return ret;
}

1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 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 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633
typedef struct BlockReopenQueueEntry {
     bool prepared;
     BDRVReopenState state;
     QSIMPLEQ_ENTRY(BlockReopenQueueEntry) entry;
} BlockReopenQueueEntry;

/*
 * Adds a BlockDriverState to a simple queue for an atomic, transactional
 * reopen of multiple devices.
 *
 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
 * already performed, or alternatively may be NULL a new BlockReopenQueue will
 * be created and initialized. This newly created BlockReopenQueue should be
 * passed back in for subsequent calls that are intended to be of the same
 * atomic 'set'.
 *
 * bs is the BlockDriverState to add to the reopen queue.
 *
 * flags contains the open flags for the associated bs
 *
 * returns a pointer to bs_queue, which is either the newly allocated
 * bs_queue, or the existing bs_queue being used.
 *
 */
BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
                                    BlockDriverState *bs, int flags)
{
    assert(bs != NULL);

    BlockReopenQueueEntry *bs_entry;
    if (bs_queue == NULL) {
        bs_queue = g_new0(BlockReopenQueue, 1);
        QSIMPLEQ_INIT(bs_queue);
    }

    if (bs->file) {
        bdrv_reopen_queue(bs_queue, bs->file, flags);
    }

    bs_entry = g_new0(BlockReopenQueueEntry, 1);
    QSIMPLEQ_INSERT_TAIL(bs_queue, bs_entry, entry);

    bs_entry->state.bs = bs;
    bs_entry->state.flags = flags;

    return bs_queue;
}

/*
 * Reopen multiple BlockDriverStates atomically & transactionally.
 *
 * The queue passed in (bs_queue) must have been built up previous
 * via bdrv_reopen_queue().
 *
 * Reopens all BDS specified in the queue, with the appropriate
 * flags.  All devices are prepared for reopen, and failure of any
 * device will cause all device changes to be abandonded, and intermediate
 * data cleaned up.
 *
 * If all devices prepare successfully, then the changes are committed
 * to all devices.
 *
 */
int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp)
{
    int ret = -1;
    BlockReopenQueueEntry *bs_entry, *next;
    Error *local_err = NULL;

    assert(bs_queue != NULL);

    bdrv_drain_all();

    QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
        if (bdrv_reopen_prepare(&bs_entry->state, bs_queue, &local_err)) {
            error_propagate(errp, local_err);
            goto cleanup;
        }
        bs_entry->prepared = true;
    }

    /* If we reach this point, we have success and just need to apply the
     * changes
     */
    QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
        bdrv_reopen_commit(&bs_entry->state);
    }

    ret = 0;

cleanup:
    QSIMPLEQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {
        if (ret && bs_entry->prepared) {
            bdrv_reopen_abort(&bs_entry->state);
        }
        g_free(bs_entry);
    }
    g_free(bs_queue);
    return ret;
}


/* Reopen a single BlockDriverState with the specified flags. */
int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp)
{
    int ret = -1;
    Error *local_err = NULL;
    BlockReopenQueue *queue = bdrv_reopen_queue(NULL, bs, bdrv_flags);

    ret = bdrv_reopen_multiple(queue, &local_err);
    if (local_err != NULL) {
        error_propagate(errp, local_err);
    }
    return ret;
}


/*
 * Prepares a BlockDriverState for reopen. All changes are staged in the
 * 'opaque' field of the BDRVReopenState, which is used and allocated by
 * the block driver layer .bdrv_reopen_prepare()
 *
 * bs is the BlockDriverState to reopen
 * flags are the new open flags
 * queue is the reopen queue
 *
 * Returns 0 on success, non-zero on error.  On error errp will be set
 * as well.
 *
 * On failure, bdrv_reopen_abort() will be called to clean up any data.
 * It is the responsibility of the caller to then call the abort() or
 * commit() for any other BDS that have been left in a prepare() state
 *
 */
int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
                        Error **errp)
{
    int ret = -1;
    Error *local_err = NULL;
    BlockDriver *drv;

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

    /* if we are to stay read-only, do not allow permission change
     * to r/w */
    if (!(reopen_state->bs->open_flags & BDRV_O_ALLOW_RDWR) &&
        reopen_state->flags & BDRV_O_RDWR) {
        error_set(errp, QERR_DEVICE_IS_READ_ONLY,
                  reopen_state->bs->device_name);
        goto error;
    }


    ret = bdrv_flush(reopen_state->bs);
    if (ret) {
        error_set(errp, ERROR_CLASS_GENERIC_ERROR, "Error (%s) flushing drive",
                  strerror(-ret));
        goto error;
    }

    if (drv->bdrv_reopen_prepare) {
        ret = drv->bdrv_reopen_prepare(reopen_state, queue, &local_err);
        if (ret) {
            if (local_err != NULL) {
                error_propagate(errp, local_err);
            } else {
1634 1635
                error_setg(errp, "failed while preparing to reopen image '%s'",
                           reopen_state->bs->filename);
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
            }
            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);
1678 1679

    bdrv_refresh_limits(reopen_state->bs);
1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699
}

/*
 * 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 已提交
1700 1701
void bdrv_close(BlockDriverState *bs)
{
1702 1703 1704
    if (bs->job) {
        block_job_cancel_sync(bs->job);
    }
1705 1706 1707
    bdrv_drain_all(); /* complete I/O */
    bdrv_flush(bs);
    bdrv_drain_all(); /* in case flush left pending I/O */
P
Paolo Bonzini 已提交
1708
    notifier_list_notify(&bs->close_notifiers, bs);
K
Kevin Wolf 已提交
1709

1710
    if (bs->drv) {
1711
        if (bs->backing_hd) {
F
Fam Zheng 已提交
1712
            bdrv_unref(bs->backing_hd);
1713 1714
            bs->backing_hd = NULL;
        }
B
bellard 已提交
1715
        bs->drv->bdrv_close(bs);
1716
        g_free(bs->opaque);
B
bellard 已提交
1717 1718 1719 1720
#ifdef _WIN32
        if (bs->is_temporary) {
            unlink(bs->filename);
        }
B
bellard 已提交
1721
#endif
B
bellard 已提交
1722 1723
        bs->opaque = NULL;
        bs->drv = NULL;
1724
        bs->copy_on_read = 0;
1725 1726
        bs->backing_file[0] = '\0';
        bs->backing_format[0] = '\0';
1727 1728 1729 1730 1731
        bs->total_sectors = 0;
        bs->encrypted = 0;
        bs->valid_key = 0;
        bs->sg = 0;
        bs->growable = 0;
A
Asias He 已提交
1732
        bs->zero_beyond_eof = false;
1733 1734
        QDECREF(bs->options);
        bs->options = NULL;
B
bellard 已提交
1735

1736
        if (bs->file != NULL) {
F
Fam Zheng 已提交
1737
            bdrv_unref(bs->file);
1738
            bs->file = NULL;
1739
        }
B
bellard 已提交
1740
    }
Z
Zhi Yong Wu 已提交
1741

P
Pavel Hrdina 已提交
1742 1743
    bdrv_dev_change_media_cb(bs, false);

Z
Zhi Yong Wu 已提交
1744 1745 1746 1747
    /*throttling disk I/O limits*/
    if (bs->io_limits_enabled) {
        bdrv_io_limits_disable(bs);
    }
B
bellard 已提交
1748 1749
}

1750 1751 1752 1753
void bdrv_close_all(void)
{
    BlockDriverState *bs;

1754
    QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
1755 1756 1757 1758
        bdrv_close(bs);
    }
}

1759 1760 1761 1762 1763 1764
/* 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;
    }
1765 1766 1767 1768
    if (!qemu_co_queue_empty(&bs->throttled_reqs[0])) {
        return true;
    }
    if (!qemu_co_queue_empty(&bs->throttled_reqs[1])) {
1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782
        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;
}

static bool bdrv_requests_pending_all(void)
{
    BlockDriverState *bs;
1783
    QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
1784 1785 1786 1787 1788 1789 1790
        if (bdrv_requests_pending(bs)) {
            return true;
        }
    }
    return false;
}

1791 1792 1793 1794 1795
/*
 * 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.
1796 1797 1798 1799 1800 1801
 *
 * 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.
1802 1803 1804
 */
void bdrv_drain_all(void)
{
1805 1806
    /* Always run first iteration so any pending completion BHs run */
    bool busy = true;
1807 1808
    BlockDriverState *bs;

1809
    while (busy) {
1810
        QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
1811
            bdrv_start_throttled_reqs(bs);
1812
        }
1813

1814 1815
        busy = bdrv_requests_pending_all();
        busy |= aio_poll(qemu_get_aio_context(), busy);
1816 1817 1818
    }
}

1819 1820
/* make a BlockDriverState anonymous by removing from bdrv_state and
 * graph_bdrv_state list.
1821 1822 1823 1824
   Also, NULL terminate the device_name to prevent double remove */
void bdrv_make_anon(BlockDriverState *bs)
{
    if (bs->device_name[0] != '\0') {
1825
        QTAILQ_REMOVE(&bdrv_states, bs, device_list);
1826 1827
    }
    bs->device_name[0] = '\0';
1828 1829 1830 1831
    if (bs->node_name[0] != '\0') {
        QTAILQ_REMOVE(&graph_bdrv_states, bs, node_list);
    }
    bs->node_name[0] = '\0';
1832 1833
}

P
Paolo Bonzini 已提交
1834 1835 1836 1837 1838 1839 1840
static void bdrv_rebind(BlockDriverState *bs)
{
    if (bs->drv && bs->drv->bdrv_rebind) {
        bs->drv->bdrv_rebind(bs);
    }
}

1841 1842
static void bdrv_move_feature_fields(BlockDriverState *bs_dest,
                                     BlockDriverState *bs_src)
1843
{
1844 1845
    /* move some fields that need to stay attached to the device */
    bs_dest->open_flags         = bs_src->open_flags;
1846 1847

    /* dev info */
1848 1849 1850
    bs_dest->dev_ops            = bs_src->dev_ops;
    bs_dest->dev_opaque         = bs_src->dev_opaque;
    bs_dest->dev                = bs_src->dev;
1851
    bs_dest->guest_block_size   = bs_src->guest_block_size;
1852
    bs_dest->copy_on_read       = bs_src->copy_on_read;
1853

1854
    bs_dest->enable_write_cache = bs_src->enable_write_cache;
1855

1856 1857 1858 1859 1860 1861
    /* 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];
1862
    bs_dest->io_limits_enabled  = bs_src->io_limits_enabled;
1863 1864

    /* r/w error */
1865 1866
    bs_dest->on_read_error      = bs_src->on_read_error;
    bs_dest->on_write_error     = bs_src->on_write_error;
1867 1868

    /* i/o status */
1869 1870
    bs_dest->iostatus_enabled   = bs_src->iostatus_enabled;
    bs_dest->iostatus           = bs_src->iostatus;
1871

1872
    /* dirty bitmap */
F
Fam Zheng 已提交
1873
    bs_dest->dirty_bitmaps      = bs_src->dirty_bitmaps;
1874

1875 1876 1877
    /* reference count */
    bs_dest->refcnt             = bs_src->refcnt;

1878
    /* job */
1879 1880
    bs_dest->in_use             = bs_src->in_use;
    bs_dest->job                = bs_src->job;
1881

1882
    /* keep the same entry in bdrv_states */
1883 1884
    pstrcpy(bs_dest->device_name, sizeof(bs_dest->device_name),
            bs_src->device_name);
1885
    bs_dest->device_list = bs_src->device_list;
1886
}
1887

1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902
/*
 * 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 已提交
1903

1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914
    /* 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);
    }

1915 1916
    /* bs_new must be anonymous and shouldn't have anything fancy enabled */
    assert(bs_new->device_name[0] == '\0');
F
Fam Zheng 已提交
1917
    assert(QLIST_EMPTY(&bs_new->dirty_bitmaps));
1918 1919 1920 1921
    assert(bs_new->job == NULL);
    assert(bs_new->dev == NULL);
    assert(bs_new->in_use == 0);
    assert(bs_new->io_limits_enabled == false);
1922
    assert(!throttle_have_timer(&bs_new->throttle_state));
1923

1924 1925 1926
    tmp = *bs_new;
    *bs_new = *bs_old;
    *bs_old = tmp;
1927

1928 1929 1930 1931
    /* 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);
1932

1933 1934 1935 1936 1937 1938 1939 1940
    /* bs_new shouldn't be in bdrv_states even after the swap!  */
    assert(bs_new->device_name[0] == '\0');

    /* Check a few fields that should remain attached to the device */
    assert(bs_new->dev == NULL);
    assert(bs_new->job == NULL);
    assert(bs_new->in_use == 0);
    assert(bs_new->io_limits_enabled == false);
1941
    assert(!throttle_have_timer(&bs_new->throttle_state));
P
Paolo Bonzini 已提交
1942

1943 1944 1945 1946 1947 1948 1949 1950
    /* 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 已提交
1951
    bdrv_rebind(bs_new);
1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977
    bdrv_rebind(bs_old);
}

/*
 * Add new bs contents at the top of an image chain while the chain is
 * live, while keeping required fields on the top layer.
 *
 * This will modify the BlockDriverState fields, and swap contents
 * between bs_new and bs_top. Both bs_new and bs_top are modified.
 *
 * bs_new is required to be anonymous.
 *
 * This function does not create any image files.
 */
void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top)
{
    bdrv_swap(bs_new, bs_top);

    /* The contents of 'tmp' will become bs_top, as we are
     * swapping bs_new and bs_top contents. */
    bs_top->backing_hd = bs_new;
    bs_top->open_flags &= ~BDRV_O_NO_BACKING;
    pstrcpy(bs_top->backing_file, sizeof(bs_top->backing_file),
            bs_new->filename);
    pstrcpy(bs_top->backing_format, sizeof(bs_top->backing_format),
            bs_new->drv ? bs_new->drv->format_name : "");
1978 1979
}

F
Fam Zheng 已提交
1980
static void bdrv_delete(BlockDriverState *bs)
B
bellard 已提交
1981
{
1982
    assert(!bs->dev);
1983 1984
    assert(!bs->job);
    assert(!bs->in_use);
F
Fam Zheng 已提交
1985
    assert(!bs->refcnt);
F
Fam Zheng 已提交
1986
    assert(QLIST_EMPTY(&bs->dirty_bitmaps));
1987

1988 1989
    bdrv_close(bs);

1990
    /* remove from list, if necessary */
1991
    bdrv_make_anon(bs);
1992

1993
    g_free(bs);
B
bellard 已提交
1994 1995
}

1996 1997
int bdrv_attach_dev(BlockDriverState *bs, void *dev)
/* TODO change to DeviceState *dev when all users are qdevified */
1998
{
1999
    if (bs->dev) {
2000 2001
        return -EBUSY;
    }
2002
    bs->dev = dev;
2003
    bdrv_iostatus_reset(bs);
2004 2005 2006
    return 0;
}

2007 2008
/* TODO qdevified devices don't use this, remove when devices are qdevified */
void bdrv_attach_dev_nofail(BlockDriverState *bs, void *dev)
2009
{
2010 2011 2012 2013 2014 2015 2016 2017 2018 2019
    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;
2020 2021
    bs->dev_ops = NULL;
    bs->dev_opaque = NULL;
2022
    bs->guest_block_size = 512;
2023 2024
}

2025 2026
/* TODO change to return DeviceState * when all users are qdevified */
void *bdrv_get_attached_dev(BlockDriverState *bs)
2027
{
2028
    return bs->dev;
2029 2030
}

2031 2032 2033 2034 2035 2036 2037
void bdrv_set_dev_ops(BlockDriverState *bs, const BlockDevOps *ops,
                      void *opaque)
{
    bs->dev_ops = ops;
    bs->dev_opaque = opaque;
}

P
Paolo Bonzini 已提交
2038 2039 2040
void bdrv_emit_qmp_error_event(const BlockDriverState *bdrv,
                               enum MonitorEvent ev,
                               BlockErrorAction action, bool is_read)
2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062
{
    QObject *data;
    const char *action_str;

    switch (action) {
    case BDRV_ACTION_REPORT:
        action_str = "report";
        break;
    case BDRV_ACTION_IGNORE:
        action_str = "ignore";
        break;
    case BDRV_ACTION_STOP:
        action_str = "stop";
        break;
    default:
        abort();
    }

    data = qobject_from_jsonf("{ 'device': %s, 'action': %s, 'operation': %s }",
                              bdrv->device_name,
                              action_str,
                              is_read ? "read" : "write");
P
Paolo Bonzini 已提交
2063
    monitor_protocol_event(ev, data);
2064 2065 2066 2067

    qobject_decref(data);
}

2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078
static void bdrv_emit_qmp_eject_event(BlockDriverState *bs, bool ejected)
{
    QObject *data;

    data = qobject_from_jsonf("{ 'device': %s, 'tray-open': %i }",
                              bdrv_get_device_name(bs), ejected);
    monitor_protocol_event(QEVENT_DEVICE_TRAY_MOVED, data);

    qobject_decref(data);
}

2079
static void bdrv_dev_change_media_cb(BlockDriverState *bs, bool load)
2080
{
2081
    if (bs->dev_ops && bs->dev_ops->change_media_cb) {
2082
        bool tray_was_closed = !bdrv_dev_is_tray_open(bs);
2083
        bs->dev_ops->change_media_cb(bs->dev_opaque, load);
2084 2085 2086 2087 2088 2089 2090 2091
        if (tray_was_closed) {
            /* tray open */
            bdrv_emit_qmp_eject_event(bs, true);
        }
        if (load) {
            /* tray close */
            bdrv_emit_qmp_eject_event(bs, false);
        }
2092 2093 2094
    }
}

2095 2096 2097 2098 2099
bool bdrv_dev_has_removable_media(BlockDriverState *bs)
{
    return !bs->dev || (bs->dev_ops && bs->dev_ops->change_media_cb);
}

P
Paolo Bonzini 已提交
2100 2101 2102 2103 2104 2105 2106
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);
    }
}

2107 2108 2109 2110 2111 2112 2113 2114
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;
}

2115 2116 2117 2118
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);
2119 2120 2121
    }
}

2122 2123 2124 2125 2126 2127 2128 2129
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 已提交
2130 2131 2132
/*
 * Run consistency checks on an image
 *
2133
 * Returns 0 if the check could be completed (it doesn't mean that the image is
2134
 * free of errors) or -errno when an internal error occurred. The results of the
2135
 * check are stored in res.
A
aliguori 已提交
2136
 */
2137
int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix)
A
aliguori 已提交
2138 2139 2140 2141 2142
{
    if (bs->drv->bdrv_check == NULL) {
        return -ENOTSUP;
    }

2143
    memset(res, 0, sizeof(*res));
2144
    return bs->drv->bdrv_check(bs, res, fix);
A
aliguori 已提交
2145 2146
}

2147 2148
#define COMMIT_BUF_SECTORS 2048

2149 2150 2151
/* commit COW file into the raw image */
int bdrv_commit(BlockDriverState *bs)
{
B
bellard 已提交
2152
    BlockDriver *drv = bs->drv;
2153
    int64_t sector, total_sectors, length, backing_length;
2154
    int n, ro, open_flags;
2155
    int ret = 0;
2156
    uint8_t *buf = NULL;
2157
    char filename[PATH_MAX];
2158

B
bellard 已提交
2159 2160
    if (!drv)
        return -ENOMEDIUM;
2161 2162 2163
    
    if (!bs->backing_hd) {
        return -ENOTSUP;
2164 2165
    }

2166 2167 2168 2169
    if (bdrv_in_use(bs) || bdrv_in_use(bs->backing_hd)) {
        return -EBUSY;
    }

2170
    ro = bs->backing_hd->read_only;
2171 2172
    /* Use pstrcpy (not strncpy): filename must be NUL-terminated. */
    pstrcpy(filename, sizeof(filename), bs->backing_hd->filename);
2173 2174 2175
    open_flags =  bs->backing_hd->open_flags;

    if (ro) {
2176 2177
        if (bdrv_reopen(bs->backing_hd, open_flags | BDRV_O_RDWR, NULL)) {
            return -EACCES;
2178
        }
B
bellard 已提交
2179
    }
2180

2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203
    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;
2204
    buf = g_malloc(COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE);
2205 2206

    for (sector = 0; sector < total_sectors; sector += n) {
2207 2208 2209 2210 2211
        ret = bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n);
        if (ret < 0) {
            goto ro_cleanup;
        }
        if (ret) {
K
Kevin Wolf 已提交
2212 2213
            ret = bdrv_read(bs, sector, buf, n);
            if (ret < 0) {
2214 2215 2216
                goto ro_cleanup;
            }

K
Kevin Wolf 已提交
2217 2218
            ret = bdrv_write(bs->backing_hd, sector, buf, n);
            if (ret < 0) {
2219 2220
                goto ro_cleanup;
            }
B
bellard 已提交
2221
        }
2222
    }
2223

2224 2225
    if (drv->bdrv_make_empty) {
        ret = drv->bdrv_make_empty(bs);
K
Kevin Wolf 已提交
2226 2227 2228
        if (ret < 0) {
            goto ro_cleanup;
        }
2229 2230
        bdrv_flush(bs);
    }
2231

2232 2233 2234 2235
    /*
     * Make sure all data we wrote to the backing device is actually
     * stable on disk.
     */
K
Kevin Wolf 已提交
2236
    if (bs->backing_hd) {
2237
        bdrv_flush(bs->backing_hd);
K
Kevin Wolf 已提交
2238
    }
2239

K
Kevin Wolf 已提交
2240
    ret = 0;
2241
ro_cleanup:
2242
    g_free(buf);
2243 2244

    if (ro) {
2245 2246
        /* ignoring error return here */
        bdrv_reopen(bs->backing_hd, open_flags & ~BDRV_O_RDWR, NULL);
2247 2248
    }

2249
    return ret;
2250 2251
}

2252
int bdrv_commit_all(void)
2253 2254 2255
{
    BlockDriverState *bs;

2256
    QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
2257 2258 2259 2260 2261
        if (bs->drv && bs->backing_hd) {
            int ret = bdrv_commit(bs);
            if (ret < 0) {
                return ret;
            }
2262
        }
2263
    }
2264
    return 0;
2265 2266
}

S
Stefan Hajnoczi 已提交
2267 2268 2269 2270 2271 2272 2273
/**
 * 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)
{
2274 2275 2276 2277
    if (req->serialising) {
        req->bs->serialising_in_flight--;
    }

S
Stefan Hajnoczi 已提交
2278
    QLIST_REMOVE(req, list);
2279
    qemu_co_queue_restart_all(&req->wait_queue);
S
Stefan Hajnoczi 已提交
2280 2281 2282 2283 2284 2285 2286
}

/**
 * Add an active request to the tracked requests list
 */
static void tracked_request_begin(BdrvTrackedRequest *req,
                                  BlockDriverState *bs,
2287 2288
                                  int64_t offset,
                                  unsigned int bytes, bool is_write)
S
Stefan Hajnoczi 已提交
2289 2290 2291
{
    *req = (BdrvTrackedRequest){
        .bs = bs,
2292 2293 2294 2295 2296
        .offset         = offset,
        .bytes          = bytes,
        .is_write       = is_write,
        .co             = qemu_coroutine_self(),
        .serialising    = false,
2297 2298
        .overlap_offset = offset,
        .overlap_bytes  = bytes,
S
Stefan Hajnoczi 已提交
2299 2300
    };

2301 2302
    qemu_co_queue_init(&req->wait_queue);

S
Stefan Hajnoczi 已提交
2303 2304 2305
    QLIST_INSERT_HEAD(&bs->tracked_requests, req, list);
}

2306
static void mark_request_serialising(BdrvTrackedRequest *req, uint64_t align)
2307
{
2308
    int64_t overlap_offset = req->offset & ~(align - 1);
2309 2310
    unsigned int overlap_bytes = ROUND_UP(req->offset + req->bytes, align)
                               - overlap_offset;
2311

2312 2313 2314 2315
    if (!req->serialising) {
        req->bs->serialising_in_flight++;
        req->serialising = true;
    }
2316 2317 2318

    req->overlap_offset = MIN(req->overlap_offset, overlap_offset);
    req->overlap_bytes = MAX(req->overlap_bytes, overlap_bytes);
2319 2320
}

S
Stefan Hajnoczi 已提交
2321 2322 2323
/**
 * Round a region to cluster boundaries
 */
2324 2325 2326 2327
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 已提交
2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341
{
    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);
    }
}

2342
static int bdrv_get_cluster_size(BlockDriverState *bs)
2343 2344
{
    BlockDriverInfo bdi;
2345
    int ret;
2346

2347 2348 2349
    ret = bdrv_get_info(bs, &bdi);
    if (ret < 0 || bdi.cluster_size == 0) {
        return bs->request_alignment;
2350
    } else {
2351
        return bdi.cluster_size;
2352 2353 2354
    }
}

2355
static bool tracked_request_overlaps(BdrvTrackedRequest *req,
2356 2357
                                     int64_t offset, unsigned int bytes)
{
S
Stefan Hajnoczi 已提交
2358
    /*        aaaa   bbbb */
2359
    if (offset >= req->overlap_offset + req->overlap_bytes) {
S
Stefan Hajnoczi 已提交
2360 2361 2362
        return false;
    }
    /* bbbb   aaaa        */
2363
    if (req->overlap_offset >= offset + bytes) {
S
Stefan Hajnoczi 已提交
2364 2365 2366
        return false;
    }
    return true;
2367 2368
}

2369
static bool coroutine_fn wait_serialising_requests(BdrvTrackedRequest *self)
2370
{
2371
    BlockDriverState *bs = self->bs;
2372 2373
    BdrvTrackedRequest *req;
    bool retry;
2374
    bool waited = false;
2375

2376
    if (!bs->serialising_in_flight) {
2377
        return false;
2378 2379
    }

2380 2381 2382
    do {
        retry = false;
        QLIST_FOREACH(req, &bs->tracked_requests, list) {
2383
            if (req == self || (!req->serialising && !self->serialising)) {
2384 2385
                continue;
            }
2386 2387 2388
            if (tracked_request_overlaps(req, self->overlap_offset,
                                         self->overlap_bytes))
            {
2389 2390 2391 2392 2393 2394
                /* 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);

2395 2396 2397 2398 2399 2400 2401 2402
                /* 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;
2403
                    waited = true;
2404 2405
                    break;
                }
2406 2407 2408
            }
        }
    } while (retry);
2409 2410

    return waited;
2411 2412
}

K
Kevin Wolf 已提交
2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424
/*
 * 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;
2425
    int ret;
K
Kevin Wolf 已提交
2426

2427 2428 2429 2430 2431
    /* Backing file format doesn't make sense without a backing file */
    if (backing_fmt && !backing_file) {
        return -EINVAL;
    }

K
Kevin Wolf 已提交
2432
    if (drv->bdrv_change_backing_file != NULL) {
2433
        ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
K
Kevin Wolf 已提交
2434
    } else {
2435
        ret = -ENOTSUP;
K
Kevin Wolf 已提交
2436
    }
2437 2438 2439 2440 2441 2442

    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 已提交
2443 2444
}

2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 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
/*
 * 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.
 */
BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
                                    BlockDriverState *bs)
{
    BlockDriverState *overlay = NULL;
    BlockDriverState *intermediate;

    assert(active != NULL);
    assert(bs != NULL);

    /* if bs is the same as active, then by definition it has no overlay
     */
    if (active == bs) {
        return NULL;
    }

    intermediate = active;
    while (intermediate->backing_hd) {
        if (intermediate->backing_hd == bs) {
            overlay = intermediate;
            break;
        }
        intermediate = intermediate->backing_hd;
    }

    return overlay;
}

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
 *
 * Error conditions:
 *  if active == top, that is considered an error
 *
 */
int bdrv_drop_intermediate(BlockDriverState *active, BlockDriverState *top,
                           BlockDriverState *base)
{
    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 */
    ret = bdrv_change_backing_file(new_top_bs, base_bs->filename,
                                   base_bs->drv ? base_bs->drv->format_name : "");
    if (ret) {
        goto exit;
    }
    new_top_bs->backing_hd = base_bs;

2572
    bdrv_refresh_limits(new_top_bs);
2573 2574 2575 2576

    QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) {
        /* so that bdrv_close() does not recursively close the chain */
        intermediate_state->bs->backing_hd = NULL;
F
Fam Zheng 已提交
2577
        bdrv_unref(intermediate_state->bs);
2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588
    }
    ret = 0;

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


2589 2590 2591 2592 2593
static int bdrv_check_byte_request(BlockDriverState *bs, int64_t offset,
                                   size_t size)
{
    int64_t len;

2594 2595 2596 2597
    if (size > INT_MAX) {
        return -EIO;
    }

2598 2599 2600 2601 2602 2603 2604 2605
    if (!bdrv_is_inserted(bs))
        return -ENOMEDIUM;

    if (bs->growable)
        return 0;

    len = bdrv_getlength(bs);

K
Kevin Wolf 已提交
2606 2607 2608 2609
    if (offset < 0)
        return -EIO;

    if ((offset > len) || (len - offset < size))
2610 2611 2612 2613 2614 2615 2616 2617
        return -EIO;

    return 0;
}

static int bdrv_check_request(BlockDriverState *bs, int64_t sector_num,
                              int nb_sectors)
{
2618
    if (nb_sectors < 0 || nb_sectors > INT_MAX / BDRV_SECTOR_SIZE) {
2619 2620 2621
        return -EIO;
    }

2622 2623
    return bdrv_check_byte_request(bs, sector_num * BDRV_SECTOR_SIZE,
                                   nb_sectors * BDRV_SECTOR_SIZE);
2624 2625
}

2626 2627
typedef struct RwCo {
    BlockDriverState *bs;
2628
    int64_t offset;
2629 2630 2631
    QEMUIOVector *qiov;
    bool is_write;
    int ret;
P
Peter Lieven 已提交
2632
    BdrvRequestFlags flags;
2633 2634 2635
} RwCo;

static void coroutine_fn bdrv_rw_co_entry(void *opaque)
B
bellard 已提交
2636
{
2637
    RwCo *rwco = opaque;
B
bellard 已提交
2638

2639
    if (!rwco->is_write) {
2640 2641
        rwco->ret = bdrv_co_do_preadv(rwco->bs, rwco->offset,
                                      rwco->qiov->size, rwco->qiov,
P
Peter Lieven 已提交
2642
                                      rwco->flags);
2643 2644 2645 2646
    } else {
        rwco->ret = bdrv_co_do_pwritev(rwco->bs, rwco->offset,
                                       rwco->qiov->size, rwco->qiov,
                                       rwco->flags);
2647 2648
    }
}
2649

2650
/*
2651
 * Process a vectored synchronous request using coroutines
2652
 */
2653 2654 2655
static int bdrv_prwv_co(BlockDriverState *bs, int64_t offset,
                        QEMUIOVector *qiov, bool is_write,
                        BdrvRequestFlags flags)
2656 2657 2658 2659
{
    Coroutine *co;
    RwCo rwco = {
        .bs = bs,
2660
        .offset = offset,
2661
        .qiov = qiov,
2662 2663
        .is_write = is_write,
        .ret = NOT_DONE,
P
Peter Lieven 已提交
2664
        .flags = flags,
2665
    };
2666

2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677
    /**
     * 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);
    }

2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689
    if (qemu_in_coroutine()) {
        /* Fast-path if already in coroutine context */
        bdrv_rw_co_entry(&rwco);
    } else {
        co = qemu_coroutine_create(bdrv_rw_co_entry);
        qemu_coroutine_enter(co, &rwco);
        while (rwco.ret == NOT_DONE) {
            qemu_aio_wait();
        }
    }
    return rwco.ret;
}
B
bellard 已提交
2690

2691 2692 2693 2694
/*
 * Process a synchronous request using coroutines
 */
static int bdrv_rw_co(BlockDriverState *bs, int64_t sector_num, uint8_t *buf,
P
Peter Lieven 已提交
2695
                      int nb_sectors, bool is_write, BdrvRequestFlags flags)
2696 2697 2698 2699 2700 2701 2702
{
    QEMUIOVector qiov;
    struct iovec iov = {
        .iov_base = (void *)buf,
        .iov_len = nb_sectors * BDRV_SECTOR_SIZE,
    };

2703 2704 2705 2706
    if (nb_sectors < 0 || nb_sectors > INT_MAX / BDRV_SECTOR_SIZE) {
        return -EINVAL;
    }

2707
    qemu_iovec_init_external(&qiov, &iov, 1);
2708 2709
    return bdrv_prwv_co(bs, sector_num << BDRV_SECTOR_BITS,
                        &qiov, is_write, flags);
2710 2711
}

2712 2713 2714 2715
/* 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 已提交
2716
    return bdrv_rw_co(bs, sector_num, buf, nb_sectors, false, 0);
B
bellard 已提交
2717 2718
}

2719 2720 2721 2722 2723 2724 2725 2726 2727
/* 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;
2728
    ret = bdrv_read(bs, sector_num, buf, nb_sectors);
2729 2730 2731 2732
    bs->io_limits_enabled = enabled;
    return ret;
}

2733
/* Return < 0 if error. Important errors are:
B
bellard 已提交
2734 2735 2736 2737 2738
  -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
*/
2739
int bdrv_write(BlockDriverState *bs, int64_t sector_num,
B
bellard 已提交
2740 2741
               const uint8_t *buf, int nb_sectors)
{
P
Peter Lieven 已提交
2742
    return bdrv_rw_co(bs, sector_num, (uint8_t *)buf, nb_sectors, true, 0);
B
bellard 已提交
2743 2744
}

2745 2746
int bdrv_write_zeroes(BlockDriverState *bs, int64_t sector_num,
                      int nb_sectors, BdrvRequestFlags flags)
P
Peter Lieven 已提交
2747 2748
{
    return bdrv_rw_co(bs, sector_num, NULL, nb_sectors, true,
2749
                      BDRV_REQ_ZERO_WRITE | flags);
2750 2751
}

P
Peter Lieven 已提交
2752 2753 2754 2755 2756 2757 2758 2759 2760 2761
/*
 * 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)
{
2762
    int64_t target_size;
P
Peter Lieven 已提交
2763 2764 2765
    int64_t ret, nb_sectors, sector_num = 0;
    int n;

2766 2767 2768 2769 2770 2771
    target_size = bdrv_getlength(bs);
    if (target_size < 0) {
        return target_size;
    }
    target_size /= BDRV_SECTOR_SIZE;

P
Peter Lieven 已提交
2772 2773 2774 2775 2776 2777 2778 2779 2780
    for (;;) {
        nb_sectors = target_size - sector_num;
        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);
2781 2782 2783 2784 2785
        if (ret < 0) {
            error_report("error getting block status at sector %" PRId64 ": %s",
                         sector_num, strerror(-ret));
            return ret;
        }
P
Peter Lieven 已提交
2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799
        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;
    }
}

2800
int bdrv_pread(BlockDriverState *bs, int64_t offset, void *buf, int bytes)
B
bellard 已提交
2801
{
2802 2803 2804 2805 2806
    QEMUIOVector qiov;
    struct iovec iov = {
        .iov_base = (void *)buf,
        .iov_len = bytes,
    };
2807
    int ret;
B
bellard 已提交
2808

2809 2810
    if (bytes < 0) {
        return -EINVAL;
B
bellard 已提交
2811 2812
    }

2813 2814 2815 2816
    qemu_iovec_init_external(&qiov, &iov, 1);
    ret = bdrv_prwv_co(bs, offset, &qiov, false, 0);
    if (ret < 0) {
        return ret;
B
bellard 已提交
2817
    }
2818 2819

    return bytes;
B
bellard 已提交
2820 2821
}

2822
int bdrv_pwritev(BlockDriverState *bs, int64_t offset, QEMUIOVector *qiov)
B
bellard 已提交
2823
{
2824
    int ret;
B
bellard 已提交
2825

2826 2827 2828
    ret = bdrv_prwv_co(bs, offset, qiov, true, 0);
    if (ret < 0) {
        return ret;
B
bellard 已提交
2829 2830
    }

2831 2832 2833 2834
    return qiov->size;
}

int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
2835
                const void *buf, int bytes)
2836 2837 2838 2839
{
    QEMUIOVector qiov;
    struct iovec iov = {
        .iov_base   = (void *) buf,
2840
        .iov_len    = bytes,
2841 2842
    };

2843 2844 2845 2846
    if (bytes < 0) {
        return -EINVAL;
    }

2847 2848
    qemu_iovec_init_external(&qiov, &iov, 1);
    return bdrv_pwritev(bs, offset, &qiov);
B
bellard 已提交
2849 2850
}

K
Kevin Wolf 已提交
2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866
/*
 * 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;
    }

2867 2868
    /* No flush needed for cache modes that already do it */
    if (bs->enable_write_cache) {
K
Kevin Wolf 已提交
2869 2870 2871 2872 2873 2874
        bdrv_flush(bs);
    }

    return 0;
}

2875
static int coroutine_fn bdrv_co_do_copy_on_readv(BlockDriverState *bs,
S
Stefan Hajnoczi 已提交
2876 2877 2878 2879 2880 2881 2882 2883 2884
        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;

2885
    BlockDriver *drv = bs->drv;
S
Stefan Hajnoczi 已提交
2886 2887 2888 2889 2890 2891 2892 2893 2894 2895
    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.
     */
2896 2897
    bdrv_round_to_clusters(bs, sector_num, nb_sectors,
                           &cluster_sector_num, &cluster_nb_sectors);
S
Stefan Hajnoczi 已提交
2898

2899 2900
    trace_bdrv_co_do_copy_on_readv(bs, sector_num, nb_sectors,
                                   cluster_sector_num, cluster_nb_sectors);
S
Stefan Hajnoczi 已提交
2901 2902 2903 2904 2905

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

2906 2907
    ret = drv->bdrv_co_readv(bs, cluster_sector_num, cluster_nb_sectors,
                             &bounce_qiov);
S
Stefan Hajnoczi 已提交
2908 2909 2910 2911
    if (ret < 0) {
        goto err;
    }

2912 2913
    if (drv->bdrv_co_write_zeroes &&
        buffer_is_zero(bounce_buffer, iov.iov_len)) {
K
Kevin Wolf 已提交
2914
        ret = bdrv_co_do_write_zeroes(bs, cluster_sector_num,
2915
                                      cluster_nb_sectors, 0);
2916
    } else {
2917 2918 2919
        /* This does not change the data on the disk, it is not necessary
         * to flush even in cache=writethrough mode.
         */
2920
        ret = drv->bdrv_co_writev(bs, cluster_sector_num, cluster_nb_sectors,
S
Stefan Hajnoczi 已提交
2921
                                  &bounce_qiov);
2922 2923
    }

S
Stefan Hajnoczi 已提交
2924 2925 2926 2927 2928 2929 2930 2931 2932
    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;
2933 2934
    qemu_iovec_from_buf(qiov, 0, bounce_buffer + skip_bytes,
                        nb_sectors * BDRV_SECTOR_SIZE);
S
Stefan Hajnoczi 已提交
2935 2936 2937 2938 2939 2940

err:
    qemu_vfree(bounce_buffer);
    return ret;
}

2941
/*
2942 2943 2944
 * 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.
2945
 */
2946
static int coroutine_fn bdrv_aligned_preadv(BlockDriverState *bs,
2947
    BdrvTrackedRequest *req, int64_t offset, unsigned int bytes,
2948
    int64_t align, QEMUIOVector *qiov, int flags)
K
Kevin Wolf 已提交
2949 2950
{
    BlockDriver *drv = bs->drv;
S
Stefan Hajnoczi 已提交
2951
    int ret;
K
Kevin Wolf 已提交
2952

2953 2954
    int64_t sector_num = offset >> BDRV_SECTOR_BITS;
    unsigned int nb_sectors = bytes >> BDRV_SECTOR_BITS;
K
Kevin Wolf 已提交
2955

2956 2957 2958 2959
    assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0);
    assert((bytes & (BDRV_SECTOR_SIZE - 1)) == 0);

    /* Handle Copy on Read and associated serialisation */
2960
    if (flags & BDRV_REQ_COPY_ON_READ) {
2961 2962 2963 2964 2965 2966
        /* 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));
2967 2968
    }

2969
    wait_serialising_requests(req);
2970

2971
    if (flags & BDRV_REQ_COPY_ON_READ) {
S
Stefan Hajnoczi 已提交
2972 2973
        int pnum;

2974
        ret = bdrv_is_allocated(bs, sector_num, nb_sectors, &pnum);
S
Stefan Hajnoczi 已提交
2975 2976 2977 2978 2979
        if (ret < 0) {
            goto out;
        }

        if (!ret || pnum != nb_sectors) {
2980
            ret = bdrv_co_do_copy_on_readv(bs, sector_num, nb_sectors, qiov);
S
Stefan Hajnoczi 已提交
2981 2982 2983 2984
            goto out;
        }
    }

2985
    /* Forward the request to the BlockDriver */
2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997
    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 */
        int64_t len, total_sectors, max_nb_sectors;

        len = bdrv_getlength(bs);
        if (len < 0) {
            ret = len;
            goto out;
        }

2998
        total_sectors = DIV_ROUND_UP(len, BDRV_SECTOR_SIZE);
2999 3000
        max_nb_sectors = ROUND_UP(MAX(0, total_sectors - sector_num),
                                  align >> BDRV_SECTOR_BITS);
3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015
        if (max_nb_sectors > 0) {
            ret = drv->bdrv_co_readv(bs, sector_num,
                                     MIN(nb_sectors, max_nb_sectors), qiov);
        } 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 已提交
3016 3017

out:
S
Stefan Hajnoczi 已提交
3018
    return ret;
K
Kevin Wolf 已提交
3019 3020
}

3021 3022 3023
/*
 * Handle a read request in coroutine context
 */
3024 3025
static int coroutine_fn bdrv_co_do_preadv(BlockDriverState *bs,
    int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
3026 3027 3028
    BdrvRequestFlags flags)
{
    BlockDriver *drv = bs->drv;
3029 3030
    BdrvTrackedRequest req;

3031 3032 3033 3034 3035 3036
    /* 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;
3037 3038 3039 3040 3041
    int ret;

    if (!drv) {
        return -ENOMEDIUM;
    }
3042
    if (bdrv_check_byte_request(bs, offset, bytes)) {
3043 3044 3045 3046 3047 3048 3049 3050 3051
        return -EIO;
    }

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

    /* throttling disk I/O */
    if (bs->io_limits_enabled) {
3052
        bdrv_io_limits_intercept(bs, bytes, false);
3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079
    }

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

3080
    tracked_request_begin(&req, bs, offset, bytes, false);
3081
    ret = bdrv_aligned_preadv(bs, &req, offset, bytes, align,
3082 3083
                              use_local_qiov ? &local_qiov : qiov,
                              flags);
3084
    tracked_request_end(&req);
3085 3086 3087 3088 3089

    if (use_local_qiov) {
        qemu_iovec_destroy(&local_qiov);
        qemu_vfree(head_buf);
        qemu_vfree(tail_buf);
3090 3091 3092 3093 3094
    }

    return ret;
}

3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106
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);
}

3107
int coroutine_fn bdrv_co_readv(BlockDriverState *bs, int64_t sector_num,
K
Kevin Wolf 已提交
3108 3109
    int nb_sectors, QEMUIOVector *qiov)
{
3110
    trace_bdrv_co_readv(bs, sector_num, nb_sectors);
K
Kevin Wolf 已提交
3111

3112 3113 3114 3115 3116 3117 3118 3119 3120 3121
    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);
3122 3123
}

3124 3125 3126 3127 3128
/* 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

3129
static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs,
3130
    int64_t sector_num, int nb_sectors, BdrvRequestFlags flags)
3131 3132 3133
{
    BlockDriver *drv = bs->drv;
    QEMUIOVector qiov;
3134 3135
    struct iovec iov = {0};
    int ret = 0;
3136

3137 3138
    int max_write_zeroes = bs->bl.max_write_zeroes ?
                           bs->bl.max_write_zeroes : MAX_WRITE_ZEROES_DEFAULT;
K
Kevin Wolf 已提交
3139

3140 3141 3142
    while (nb_sectors > 0 && !ret) {
        int num = nb_sectors;

3143 3144 3145 3146 3147 3148 3149
        /* 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.  */
3150
                num = bs->bl.write_zeroes_alignment;
3151 3152 3153 3154 3155 3156
                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;
3157
            }
K
Kevin Wolf 已提交
3158
        }
3159

3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174
        /* 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) {
3175 3176
                iov.iov_base = qemu_blockalign(bs, num * BDRV_SECTOR_SIZE);
                memset(iov.iov_base, 0, num * BDRV_SECTOR_SIZE);
3177 3178
            }
            qemu_iovec_init_external(&qiov, &iov, 1);
3179

3180
            ret = drv->bdrv_co_writev(bs, sector_num, num, &qiov);
3181 3182 3183 3184 3185 3186 3187 3188

            /* 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;
            }
3189 3190 3191 3192 3193
        }

        sector_num += num;
        nb_sectors -= num;
    }
3194 3195 3196 3197 3198

    qemu_vfree(iov.iov_base);
    return ret;
}

3199
/*
3200
 * Forwards an already correctly aligned write request to the BlockDriver.
3201
 */
3202
static int coroutine_fn bdrv_aligned_pwritev(BlockDriverState *bs,
3203 3204
    BdrvTrackedRequest *req, int64_t offset, unsigned int bytes,
    QEMUIOVector *qiov, int flags)
3205 3206
{
    BlockDriver *drv = bs->drv;
3207
    bool waited;
3208
    int ret;
K
Kevin Wolf 已提交
3209

3210 3211
    int64_t sector_num = offset >> BDRV_SECTOR_BITS;
    unsigned int nb_sectors = bytes >> BDRV_SECTOR_BITS;
3212

3213 3214
    assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0);
    assert((bytes & (BDRV_SECTOR_SIZE - 1)) == 0);
3215

3216 3217
    waited = wait_serialising_requests(req);
    assert(!waited || !req->serialising);
3218 3219
    assert(req->overlap_offset <= offset);
    assert(offset + bytes <= req->overlap_offset + req->overlap_bytes);
3220

3221
    ret = notifier_with_return_list_notify(&bs->before_write_notifiers, req);
3222 3223 3224 3225

    if (ret < 0) {
        /* Do nothing, write notifier decided to fail this request */
    } else if (flags & BDRV_REQ_ZERO_WRITE) {
3226
        BLKDBG_EVENT(bs, BLKDBG_PWRITEV_ZERO);
3227
        ret = bdrv_co_do_write_zeroes(bs, sector_num, nb_sectors, flags);
3228
    } else {
3229
        BLKDBG_EVENT(bs, BLKDBG_PWRITEV);
3230 3231
        ret = drv->bdrv_co_writev(bs, sector_num, nb_sectors, qiov);
    }
3232
    BLKDBG_EVENT(bs, BLKDBG_PWRITEV_DONE);
3233

3234 3235 3236 3237
    if (ret == 0 && !bs->enable_write_cache) {
        ret = bdrv_co_flush(bs);
    }

F
Fam Zheng 已提交
3238
    bdrv_set_dirty(bs, sector_num, nb_sectors);
K
Kevin Wolf 已提交
3239 3240 3241 3242

    if (bs->wr_highest_sector < sector_num + nb_sectors - 1) {
        bs->wr_highest_sector = sector_num + nb_sectors - 1;
    }
3243 3244 3245
    if (bs->growable && ret >= 0) {
        bs->total_sectors = MAX(bs->total_sectors, sector_num + nb_sectors);
    }
K
Kevin Wolf 已提交
3246

3247
    return ret;
K
Kevin Wolf 已提交
3248 3249
}

3250 3251 3252
/*
 * Handle a write request in coroutine context
 */
3253 3254
static int coroutine_fn bdrv_co_do_pwritev(BlockDriverState *bs,
    int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
3255 3256
    BdrvRequestFlags flags)
{
3257
    BdrvTrackedRequest req;
3258 3259 3260 3261 3262 3263
    /* 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;
3264 3265 3266 3267 3268 3269 3270 3271
    int ret;

    if (!bs->drv) {
        return -ENOMEDIUM;
    }
    if (bs->read_only) {
        return -EACCES;
    }
3272
    if (bdrv_check_byte_request(bs, offset, bytes)) {
3273 3274 3275 3276 3277
        return -EIO;
    }

    /* throttling disk I/O */
    if (bs->io_limits_enabled) {
3278
        bdrv_io_limits_intercept(bs, bytes, true);
3279 3280
    }

3281 3282 3283 3284 3285
    /*
     * 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.
     */
3286
    tracked_request_begin(&req, bs, offset, bytes, true);
3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301

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

3302
        BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_HEAD);
3303 3304 3305 3306 3307
        ret = bdrv_aligned_preadv(bs, &req, offset & ~(align - 1), align,
                                  align, &head_qiov, 0);
        if (ret < 0) {
            goto fail;
        }
3308
        BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_AFTER_HEAD);
3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322

        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;
3323
        bool waited;
3324 3325

        mark_request_serialising(&req, align);
3326 3327
        waited = wait_serialising_requests(&req);
        assert(!waited || !use_local_qiov);
3328 3329 3330 3331 3332 3333 3334 3335

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

3336
        BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_TAIL);
3337 3338 3339 3340 3341
        ret = bdrv_aligned_preadv(bs, &req, (offset + bytes) & ~(align - 1), align,
                                  align, &tail_qiov, 0);
        if (ret < 0) {
            goto fail;
        }
3342
        BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_AFTER_TAIL);
3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360

        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:
3361
    tracked_request_end(&req);
3362

3363 3364 3365
    if (use_local_qiov) {
        qemu_iovec_destroy(&local_qiov);
    }
3366 3367
    qemu_vfree(head_buf);
    qemu_vfree(tail_buf);
3368

3369 3370 3371
    return ret;
}

3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383
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);
}

3384 3385 3386 3387 3388
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);

3389 3390 3391 3392
    return bdrv_co_do_writev(bs, sector_num, nb_sectors, qiov, 0);
}

int coroutine_fn bdrv_co_write_zeroes(BlockDriverState *bs,
3393 3394
                                      int64_t sector_num, int nb_sectors,
                                      BdrvRequestFlags flags)
3395
{
3396
    trace_bdrv_co_write_zeroes(bs, sector_num, nb_sectors, flags);
3397

3398 3399 3400 3401
    if (!(bs->open_flags & BDRV_O_UNMAP)) {
        flags &= ~BDRV_REQ_MAY_UNMAP;
    }

3402
    return bdrv_co_do_writev(bs, sector_num, nb_sectors, NULL,
3403
                             BDRV_REQ_ZERO_WRITE | flags);
3404 3405
}

B
bellard 已提交
3406 3407 3408 3409 3410 3411
/**
 * Truncate file to 'offset' bytes (needed only for file protocols)
 */
int bdrv_truncate(BlockDriverState *bs, int64_t offset)
{
    BlockDriver *drv = bs->drv;
3412
    int ret;
B
bellard 已提交
3413
    if (!drv)
B
bellard 已提交
3414
        return -ENOMEDIUM;
B
bellard 已提交
3415 3416
    if (!drv->bdrv_truncate)
        return -ENOTSUP;
3417 3418
    if (bs->read_only)
        return -EACCES;
M
Marcelo Tosatti 已提交
3419 3420
    if (bdrv_in_use(bs))
        return -EBUSY;
3421 3422 3423
    ret = drv->bdrv_truncate(bs, offset);
    if (ret == 0) {
        ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
3424
        bdrv_dev_resize_cb(bs);
3425 3426
    }
    return ret;
B
bellard 已提交
3427 3428
}

3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447
/**
 * 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 已提交
3448 3449 3450 3451 3452 3453 3454
/**
 * Length of a file in bytes. Return < 0 if error or unknown.
 */
int64_t bdrv_getlength(BlockDriverState *bs)
{
    BlockDriver *drv = bs->drv;
    if (!drv)
B
bellard 已提交
3455
        return -ENOMEDIUM;
3456

3457 3458 3459 3460
    if (drv->has_variable_length) {
        int ret = refresh_total_sectors(bs, bs->total_sectors);
        if (ret < 0) {
            return ret;
3461
        }
B
bellard 已提交
3462
    }
3463
    return bs->total_sectors * BDRV_SECTOR_SIZE;
B
bellard 已提交
3464 3465
}

B
bellard 已提交
3466
/* return 0 as number of sectors if no device present or error */
3467
void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
B
bellard 已提交
3468
{
B
bellard 已提交
3469 3470 3471 3472 3473
    int64_t length;
    length = bdrv_getlength(bs);
    if (length < 0)
        length = 0;
    else
J
Jan Kiszka 已提交
3474
        length = length >> BDRV_SECTOR_BITS;
B
bellard 已提交
3475
    *nb_sectors_ptr = length;
B
bellard 已提交
3476
}
B
bellard 已提交
3477

3478 3479
void bdrv_set_on_error(BlockDriverState *bs, BlockdevOnError on_read_error,
                       BlockdevOnError on_write_error)
3480 3481 3482 3483 3484
{
    bs->on_read_error = on_read_error;
    bs->on_write_error = on_write_error;
}

3485
BlockdevOnError bdrv_get_on_error(BlockDriverState *bs, bool is_read)
3486 3487 3488 3489
{
    return is_read ? bs->on_read_error : bs->on_write_error;
}

3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515
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:
        return (error == ENOSPC) ? BDRV_ACTION_STOP : BDRV_ACTION_REPORT;
    case BLOCKDEV_ON_ERROR_STOP:
        return BDRV_ACTION_STOP;
    case BLOCKDEV_ON_ERROR_REPORT:
        return BDRV_ACTION_REPORT;
    case BLOCKDEV_ON_ERROR_IGNORE:
        return BDRV_ACTION_IGNORE;
    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);
P
Paolo Bonzini 已提交
3516
    bdrv_emit_qmp_error_event(bs, QEVENT_BLOCK_IO_ERROR, action, is_read);
3517 3518 3519 3520 3521 3522
    if (action == BDRV_ACTION_STOP) {
        vm_stop(RUN_STATE_IO_ERROR);
        bdrv_iostatus_set_err(bs, error);
    }
}

B
bellard 已提交
3523 3524 3525 3526 3527
int bdrv_is_read_only(BlockDriverState *bs)
{
    return bs->read_only;
}

3528 3529 3530 3531 3532
int bdrv_is_sg(BlockDriverState *bs)
{
    return bs->sg;
}

3533 3534 3535 3536 3537
int bdrv_enable_write_cache(BlockDriverState *bs)
{
    return bs->enable_write_cache;
}

3538 3539 3540
void bdrv_set_enable_write_cache(BlockDriverState *bs, bool wce)
{
    bs->enable_write_cache = wce;
3541 3542 3543 3544 3545 3546 3547

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

B
bellard 已提交
3550 3551 3552 3553 3554 3555 3556
int bdrv_is_encrypted(BlockDriverState *bs)
{
    if (bs->backing_hd && bs->backing_hd->encrypted)
        return 1;
    return bs->encrypted;
}

3557 3558 3559 3560 3561 3562 3563 3564 3565
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 已提交
3566 3567 3568 3569 3570 3571 3572 3573 3574 3575
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;
    }
3576 3577 3578 3579 3580
    if (!bs->encrypted) {
        return -EINVAL;
    } else if (!bs->drv || !bs->drv->bdrv_set_key) {
        return -ENOMEDIUM;
    }
3581
    ret = bs->drv->bdrv_set_key(bs, key);
3582 3583 3584 3585 3586
    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 */
3587
        bdrv_dev_change_media_cb(bs, true);
3588
    }
3589
    return ret;
B
bellard 已提交
3590 3591
}

3592
const char *bdrv_get_format_name(BlockDriverState *bs)
B
bellard 已提交
3593
{
3594
    return bs->drv ? bs->drv->format_name : NULL;
B
bellard 已提交
3595 3596
}

3597
void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
B
bellard 已提交
3598 3599 3600 3601
                         void *opaque)
{
    BlockDriver *drv;

3602
    QLIST_FOREACH(drv, &bdrv_drivers, list) {
B
bellard 已提交
3603 3604 3605 3606
        it(opaque, drv->format_name);
    }
}

3607
/* This function is to find block backend bs */
B
bellard 已提交
3608 3609 3610 3611
BlockDriverState *bdrv_find(const char *name)
{
    BlockDriverState *bs;

3612
    QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
3613
        if (!strcmp(name, bs->device_name)) {
B
bellard 已提交
3614
            return bs;
3615
        }
B
bellard 已提交
3616 3617 3618 3619
    }
    return NULL;
}

3620 3621 3622 3623 3624 3625 3626 3627 3628 3629 3630 3631 3632 3633 3634
/* 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;
}

3635 3636 3637 3638 3639 3640 3641 3642 3643 3644 3645 3646 3647 3648 3649 3650 3651
/* 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;
}

3652 3653 3654 3655 3656 3657 3658 3659 3660
BlockDriverState *bdrv_lookup_bs(const char *device,
                                 const char *node_name,
                                 Error **errp)
{
    BlockDriverState *bs = NULL;

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

3661 3662
        if (bs) {
            return bs;
3663 3664 3665
        }
    }

3666 3667
    if (node_name) {
        bs = bdrv_find_node(node_name);
3668

3669 3670 3671
        if (bs) {
            return bs;
        }
3672 3673
    }

3674 3675 3676 3677
    error_setg(errp, "Cannot find device=%s nor node_name=%s",
                     device ? device : "",
                     node_name ? node_name : "");
    return NULL;
3678 3679
}

M
Markus Armbruster 已提交
3680 3681 3682 3683 3684
BlockDriverState *bdrv_next(BlockDriverState *bs)
{
    if (!bs) {
        return QTAILQ_FIRST(&bdrv_states);
    }
3685
    return QTAILQ_NEXT(bs, device_list);
M
Markus Armbruster 已提交
3686 3687
}

3688
void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs), void *opaque)
B
bellard 已提交
3689 3690 3691
{
    BlockDriverState *bs;

3692
    QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
3693
        it(opaque, bs);
B
bellard 已提交
3694 3695 3696
    }
}

B
bellard 已提交
3697 3698 3699 3700 3701
const char *bdrv_get_device_name(BlockDriverState *bs)
{
    return bs->device_name;
}

M
Markus Armbruster 已提交
3702 3703 3704 3705 3706
int bdrv_get_flags(BlockDriverState *bs)
{
    return bs->open_flags;
}

3707
int bdrv_flush_all(void)
A
aliguori 已提交
3708 3709
{
    BlockDriverState *bs;
3710
    int result = 0;
A
aliguori 已提交
3711

3712
    QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
3713 3714 3715 3716
        int ret = bdrv_flush(bs);
        if (ret < 0 && !result) {
            result = ret;
        }
3717
    }
3718 3719

    return result;
A
aliguori 已提交
3720 3721
}

3722 3723 3724 3725 3726
int bdrv_has_zero_init_1(BlockDriverState *bs)
{
    return 1;
}

K
Kevin Wolf 已提交
3727 3728 3729 3730
int bdrv_has_zero_init(BlockDriverState *bs)
{
    assert(bs->drv);

3731 3732 3733 3734 3735
    /* 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 已提交
3736 3737
    if (bs->drv->bdrv_has_zero_init) {
        return bs->drv->bdrv_has_zero_init(bs);
K
Kevin Wolf 已提交
3738 3739
    }

3740 3741
    /* safe default */
    return 0;
K
Kevin Wolf 已提交
3742 3743
}

3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767 3768 3769 3770 3771 3772 3773
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;
}

3774
typedef struct BdrvCoGetBlockStatusData {
3775
    BlockDriverState *bs;
3776
    BlockDriverState *base;
3777 3778 3779
    int64_t sector_num;
    int nb_sectors;
    int *pnum;
3780
    int64_t ret;
3781
    bool done;
3782
} BdrvCoGetBlockStatusData;
3783

3784 3785 3786 3787 3788
/*
 * 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.
 *
3789 3790 3791
 * If 'sector_num' is beyond the end of the disk image the return value is 0
 * and 'pnum' is set to 0.
 *
3792 3793 3794 3795
 * '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.
 *
3796 3797
 * '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.
3798
 */
3799 3800 3801
static int64_t coroutine_fn bdrv_co_get_block_status(BlockDriverState *bs,
                                                     int64_t sector_num,
                                                     int nb_sectors, int *pnum)
3802
{
3803
    int64_t length;
3804
    int64_t n;
3805
    int64_t ret, ret2;
3806

3807 3808 3809 3810 3811 3812
    length = bdrv_getlength(bs);
    if (length < 0) {
        return length;
    }

    if (sector_num >= (length >> BDRV_SECTOR_BITS)) {
3813 3814 3815 3816 3817 3818 3819 3820 3821
        *pnum = 0;
        return 0;
    }

    n = bs->total_sectors - sector_num;
    if (n < nb_sectors) {
        nb_sectors = n;
    }

3822
    if (!bs->drv->bdrv_co_get_block_status) {
3823
        *pnum = nb_sectors;
3824 3825 3826 3827 3828
        ret = BDRV_BLOCK_DATA;
        if (bs->drv->protocol_name) {
            ret |= BDRV_BLOCK_OFFSET_VALID | (sector_num * BDRV_SECTOR_SIZE);
        }
        return ret;
3829
    }
3830

3831 3832
    ret = bs->drv->bdrv_co_get_block_status(bs, sector_num, nb_sectors, pnum);
    if (ret < 0) {
3833
        *pnum = 0;
3834 3835 3836
        return ret;
    }

3837 3838 3839 3840 3841 3842
    if (ret & BDRV_BLOCK_RAW) {
        assert(ret & BDRV_BLOCK_OFFSET_VALID);
        return bdrv_get_block_status(bs->file, ret >> BDRV_SECTOR_BITS,
                                     *pnum, pnum);
    }

3843 3844
    if (!(ret & BDRV_BLOCK_DATA) && !(ret & BDRV_BLOCK_ZERO)) {
        if (bdrv_unallocated_blocks_are_zero(bs)) {
3845
            ret |= BDRV_BLOCK_ZERO;
3846
        } else if (bs->backing_hd) {
3847 3848 3849 3850 3851 3852
            BlockDriverState *bs2 = bs->backing_hd;
            int64_t length2 = bdrv_getlength(bs2);
            if (length2 >= 0 && sector_num >= (length2 >> BDRV_SECTOR_BITS)) {
                ret |= BDRV_BLOCK_ZERO;
            }
        }
3853
    }
3854 3855 3856 3857 3858 3859 3860 3861 3862 3863 3864 3865 3866 3867

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

3868
    return ret;
3869 3870
}

3871 3872
/* Coroutine wrapper for bdrv_get_block_status() */
static void coroutine_fn bdrv_get_block_status_co_entry(void *opaque)
3873
{
3874
    BdrvCoGetBlockStatusData *data = opaque;
3875 3876
    BlockDriverState *bs = data->bs;

3877 3878
    data->ret = bdrv_co_get_block_status(bs, data->sector_num, data->nb_sectors,
                                         data->pnum);
3879 3880 3881 3882
    data->done = true;
}

/*
3883
 * Synchronous wrapper around bdrv_co_get_block_status().
3884
 *
3885
 * See bdrv_co_get_block_status() for details.
3886
 */
3887 3888
int64_t bdrv_get_block_status(BlockDriverState *bs, int64_t sector_num,
                              int nb_sectors, int *pnum)
3889
{
3890
    Coroutine *co;
3891
    BdrvCoGetBlockStatusData data = {
3892 3893 3894 3895 3896 3897 3898
        .bs = bs,
        .sector_num = sector_num,
        .nb_sectors = nb_sectors,
        .pnum = pnum,
        .done = false,
    };

3899 3900
    if (qemu_in_coroutine()) {
        /* Fast-path if already in coroutine context */
3901
        bdrv_get_block_status_co_entry(&data);
3902
    } else {
3903
        co = qemu_coroutine_create(bdrv_get_block_status_co_entry);
3904 3905 3906 3907
        qemu_coroutine_enter(co, &data);
        while (!data.done) {
            qemu_aio_wait();
        }
3908 3909
    }
    return data.ret;
3910 3911
}

3912 3913 3914
int coroutine_fn bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num,
                                   int nb_sectors, int *pnum)
{
3915 3916 3917 3918 3919 3920 3921
    int64_t ret = bdrv_get_block_status(bs, sector_num, nb_sectors, pnum);
    if (ret < 0) {
        return ret;
    }
    return
        (ret & BDRV_BLOCK_DATA) ||
        ((ret & BDRV_BLOCK_ZERO) && !bdrv_has_zero_init(bs));
3922 3923
}

3924 3925 3926 3927 3928 3929 3930 3931 3932 3933 3934 3935
/*
 * 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.
 *
 */
3936 3937 3938 3939
int bdrv_is_allocated_above(BlockDriverState *top,
                            BlockDriverState *base,
                            int64_t sector_num,
                            int nb_sectors, int *pnum)
3940 3941 3942 3943 3944 3945 3946
{
    BlockDriverState *intermediate;
    int ret, n = nb_sectors;

    intermediate = top;
    while (intermediate && intermediate != base) {
        int pnum_inter;
3947 3948
        ret = bdrv_is_allocated(intermediate, sector_num, nb_sectors,
                                &pnum_inter);
3949 3950 3951 3952 3953 3954 3955 3956 3957 3958 3959 3960 3961
        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.
         */
3962 3963 3964
        if (n > pnum_inter &&
            (intermediate == top ||
             sector_num + pnum_inter < intermediate->total_sectors)) {
3965 3966 3967 3968 3969 3970 3971 3972 3973 3974
            n = pnum_inter;
        }

        intermediate = intermediate->backing_hd;
    }

    *pnum = n;
    return 0;
}

3975 3976 3977 3978 3979 3980 3981 3982 3983 3984
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;
}

3985
void bdrv_get_backing_filename(BlockDriverState *bs,
B
bellard 已提交
3986 3987
                               char *filename, int filename_size)
{
K
Kevin Wolf 已提交
3988
    pstrcpy(filename, filename_size, bs->backing_file);
B
bellard 已提交
3989 3990
}

3991
int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
B
bellard 已提交
3992 3993 3994 3995
                          const uint8_t *buf, int nb_sectors)
{
    BlockDriver *drv = bs->drv;
    if (!drv)
B
bellard 已提交
3996
        return -ENOMEDIUM;
B
bellard 已提交
3997 3998
    if (!drv->bdrv_write_compressed)
        return -ENOTSUP;
K
Kevin Wolf 已提交
3999 4000
    if (bdrv_check_request(bs, sector_num, nb_sectors))
        return -EIO;
4001

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

B
bellard 已提交
4004 4005
    return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);
}
4006

B
bellard 已提交
4007 4008 4009 4010
int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
{
    BlockDriver *drv = bs->drv;
    if (!drv)
B
bellard 已提交
4011
        return -ENOMEDIUM;
B
bellard 已提交
4012 4013 4014 4015 4016 4017
    if (!drv->bdrv_get_info)
        return -ENOTSUP;
    memset(bdi, 0, sizeof(*bdi));
    return drv->bdrv_get_info(bs, bdi);
}

M
Max Reitz 已提交
4018 4019 4020 4021 4022 4023 4024 4025 4026
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;
}

4027 4028
int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
                      int64_t pos, int size)
4029 4030 4031 4032 4033 4034 4035 4036 4037 4038 4039 4040
{
    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)
4041 4042
{
    BlockDriver *drv = bs->drv;
4043 4044

    if (!drv) {
4045
        return -ENOMEDIUM;
4046 4047 4048 4049 4050 4051
    } 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);
    }

4052
    return -ENOTSUP;
4053 4054
}

4055 4056
int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
                      int64_t pos, int size)
4057 4058 4059 4060
{
    BlockDriver *drv = bs->drv;
    if (!drv)
        return -ENOMEDIUM;
4061 4062 4063 4064 4065
    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;
4066 4067
}

K
Kevin Wolf 已提交
4068 4069
void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event)
{
4070
    if (!bs || !bs->drv || !bs->drv->bdrv_debug_event) {
K
Kevin Wolf 已提交
4071 4072 4073
        return;
    }

4074
    bs->drv->bdrv_debug_event(bs, event);
K
Kevin Wolf 已提交
4075 4076 4077 4078 4079 4080 4081 4082 4083 4084 4085 4086 4087 4088 4089 4090
}

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 已提交
4091 4092 4093 4094 4095 4096 4097 4098 4099 4100 4101 4102 4103
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 已提交
4104 4105
int bdrv_debug_resume(BlockDriverState *bs, const char *tag)
{
4106
    while (bs && (!bs->drv || !bs->drv->bdrv_debug_resume)) {
K
Kevin Wolf 已提交
4107 4108
        bs = bs->file;
    }
K
Kevin Wolf 已提交
4109

K
Kevin Wolf 已提交
4110 4111 4112 4113 4114 4115 4116 4117 4118 4119 4120 4121 4122 4123 4124 4125 4126 4127
    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 已提交
4128 4129
}

4130 4131 4132 4133 4134
int bdrv_is_snapshot(BlockDriverState *bs)
{
    return !!(bs->open_flags & BDRV_O_SNAPSHOT);
}

4135 4136 4137 4138
/* 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. */
4139 4140 4141
BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
        const char *backing_file)
{
4142 4143 4144 4145 4146 4147 4148 4149
    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) {
4150 4151 4152
        return NULL;
    }

4153 4154 4155 4156 4157 4158 4159 4160 4161 4162 4163 4164 4165 4166 4167
    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;
            }
4168
        } else {
4169 4170 4171 4172 4173 4174 4175 4176 4177 4178 4179 4180 4181 4182 4183 4184 4185 4186 4187 4188 4189 4190 4191
            /* 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;
            }
4192 4193 4194
        }
    }

4195 4196 4197 4198
    g_free(filename_full);
    g_free(backing_file_full);
    g_free(filename_tmp);
    return retval;
4199 4200
}

4201 4202 4203 4204 4205 4206 4207 4208 4209 4210 4211 4212 4213
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);
}

4214 4215 4216 4217 4218 4219 4220 4221 4222 4223 4224 4225 4226 4227 4228 4229
BlockDriverState *bdrv_find_base(BlockDriverState *bs)
{
    BlockDriverState *curr_bs = NULL;

    if (!bs) {
        return NULL;
    }

    curr_bs = bs;

    while (curr_bs->backing_hd) {
        curr_bs = curr_bs->backing_hd;
    }
    return curr_bs;
}

B
bellard 已提交
4230
/**************************************************************/
B
bellard 已提交
4231
/* async I/Os */
B
bellard 已提交
4232

4233
BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
4234
                                 QEMUIOVector *qiov, int nb_sectors,
4235
                                 BlockDriverCompletionFunc *cb, void *opaque)
B
bellard 已提交
4236
{
4237 4238
    trace_bdrv_aio_readv(bs, sector_num, nb_sectors, opaque);

P
Paolo Bonzini 已提交
4239
    return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors, 0,
4240
                                 cb, opaque, false);
B
bellard 已提交
4241 4242
}

4243 4244 4245
BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
                                  QEMUIOVector *qiov, int nb_sectors,
                                  BlockDriverCompletionFunc *cb, void *opaque)
B
bellard 已提交
4246
{
4247 4248
    trace_bdrv_aio_writev(bs, sector_num, nb_sectors, opaque);

P
Paolo Bonzini 已提交
4249
    return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors, 0,
4250
                                 cb, opaque, true);
B
bellard 已提交
4251 4252
}

P
Paolo Bonzini 已提交
4253 4254 4255 4256 4257 4258 4259 4260 4261 4262 4263
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 已提交
4264 4265 4266 4267 4268 4269 4270 4271 4272 4273 4274 4275 4276 4277 4278 4279 4280 4281

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);
4282 4283 4284
        if (mcb->callbacks[i].free_qiov) {
            qemu_iovec_destroy(mcb->callbacks[i].free_qiov);
        }
4285
        g_free(mcb->callbacks[i].free_qiov);
K
Kevin Wolf 已提交
4286 4287 4288 4289 4290 4291 4292
    }
}

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

4293 4294
    trace_multiwrite_cb(mcb, ret);

4295
    if (ret < 0 && !mcb->error) {
K
Kevin Wolf 已提交
4296 4297 4298 4299 4300
        mcb->error = ret;
    }

    mcb->num_requests--;
    if (mcb->num_requests == 0) {
4301
        multiwrite_user_cb(mcb);
4302
        g_free(mcb);
K
Kevin Wolf 已提交
4303 4304 4305 4306 4307
    }
}

static int multiwrite_req_compare(const void *a, const void *b)
{
4308 4309 4310 4311 4312 4313 4314 4315 4316 4317 4318 4319 4320
    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 已提交
4321 4322 4323 4324 4325 4326 4327 4328 4329 4330 4331 4332 4333 4334 4335 4336 4337 4338 4339 4340 4341
}

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

4342
        // Handle exactly sequential writes and overlapping writes.
K
Kevin Wolf 已提交
4343 4344 4345 4346
        if (reqs[i].sector <= oldreq_last) {
            merge = 1;
        }

4347 4348 4349 4350
        if (reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1 > IOV_MAX) {
            merge = 0;
        }

K
Kevin Wolf 已提交
4351 4352
        if (merge) {
            size_t size;
4353
            QEMUIOVector *qiov = g_malloc0(sizeof(*qiov));
K
Kevin Wolf 已提交
4354 4355 4356 4357 4358 4359
            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;
4360
            qemu_iovec_concat(qiov, reqs[outidx].qiov, 0, size);
K
Kevin Wolf 已提交
4361

4362 4363
            // We should need to add any zeros between the two requests
            assert (reqs[i].sector <= oldreq_last);
K
Kevin Wolf 已提交
4364 4365

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

4368
            reqs[outidx].nb_sectors = qiov->size >> 9;
K
Kevin Wolf 已提交
4369 4370 4371 4372 4373 4374 4375 4376 4377 4378 4379 4380 4381 4382 4383 4384 4385 4386 4387 4388 4389 4390 4391 4392 4393 4394 4395 4396 4397 4398 4399 4400 4401
            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;

4402 4403 4404 4405 4406 4407 4408 4409
    /* 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 已提交
4410 4411 4412 4413 4414
    if (num_reqs == 0) {
        return 0;
    }

    // Create MultiwriteCB structure
4415
    mcb = g_malloc0(sizeof(*mcb) + num_reqs * sizeof(*mcb->callbacks));
K
Kevin Wolf 已提交
4416 4417 4418 4419 4420 4421 4422 4423 4424 4425 4426
    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);

4427 4428
    trace_bdrv_aio_multiwrite(mcb, mcb->num_callbacks, num_reqs);

4429 4430
    /* Run the aio requests. */
    mcb->num_requests = num_reqs;
K
Kevin Wolf 已提交
4431
    for (i = 0; i < num_reqs; i++) {
P
Paolo Bonzini 已提交
4432 4433 4434 4435
        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 已提交
4436 4437 4438 4439 4440
    }

    return 0;
}

B
bellard 已提交
4441 4442
void bdrv_aio_cancel(BlockDriverAIOCB *acb)
{
S
Stefan Hajnoczi 已提交
4443
    acb->aiocb_info->cancel(acb);
B
bellard 已提交
4444 4445 4446 4447 4448
}

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

4449 4450 4451 4452 4453 4454 4455 4456 4457 4458 4459 4460
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)
{
4461 4462
    BlockDriverAIOCBSync *acb =
        container_of(blockacb, BlockDriverAIOCBSync, common);
4463
    qemu_bh_delete(acb->bh);
A
Avi Kivity 已提交
4464
    acb->bh = NULL;
4465 4466 4467
    qemu_aio_release(acb);
}

S
Stefan Hajnoczi 已提交
4468
static const AIOCBInfo bdrv_em_aiocb_info = {
4469 4470 4471 4472
    .aiocb_size         = sizeof(BlockDriverAIOCBSync),
    .cancel             = bdrv_aio_cancel_em,
};

4473
static void bdrv_aio_bh_cb(void *opaque)
B
bellard 已提交
4474
{
4475
    BlockDriverAIOCBSync *acb = opaque;
4476 4477

    if (!acb->is_write)
4478
        qemu_iovec_from_buf(acb->qiov, 0, acb->bounce, acb->qiov->size);
4479
    qemu_vfree(acb->bounce);
4480
    acb->common.cb(acb->common.opaque, acb->ret);
4481
    qemu_bh_delete(acb->bh);
A
Avi Kivity 已提交
4482
    acb->bh = NULL;
4483
    qemu_aio_release(acb);
B
bellard 已提交
4484
}
4485

4486 4487 4488 4489 4490 4491 4492 4493
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 已提交
4494
{
4495 4496
    BlockDriverAIOCBSync *acb;

S
Stefan Hajnoczi 已提交
4497
    acb = qemu_aio_get(&bdrv_em_aiocb_info, bs, cb, opaque);
4498 4499
    acb->is_write = is_write;
    acb->qiov = qiov;
4500
    acb->bounce = qemu_blockalign(bs, qiov->size);
4501
    acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
4502 4503

    if (is_write) {
4504
        qemu_iovec_to_buf(acb->qiov, 0, acb->bounce, qiov->size);
4505
        acb->ret = bs->drv->bdrv_write(bs, sector_num, acb->bounce, nb_sectors);
4506
    } else {
4507
        acb->ret = bs->drv->bdrv_read(bs, sector_num, acb->bounce, nb_sectors);
4508 4509
    }

4510
    qemu_bh_schedule(acb->bh);
4511

4512
    return &acb->common;
4513 4514
}

4515 4516
static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
        int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
4517
        BlockDriverCompletionFunc *cb, void *opaque)
4518
{
4519 4520
    return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 0);
}
B
bellard 已提交
4521

4522 4523 4524 4525 4526
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);
4527 4528
}

4529 4530 4531 4532 4533

typedef struct BlockDriverAIOCBCoroutine {
    BlockDriverAIOCB common;
    BlockRequest req;
    bool is_write;
K
Kevin Wolf 已提交
4534
    bool *done;
4535 4536 4537 4538 4539
    QEMUBH* bh;
} BlockDriverAIOCBCoroutine;

static void bdrv_aio_co_cancel_em(BlockDriverAIOCB *blockacb)
{
K
Kevin Wolf 已提交
4540 4541 4542 4543 4544 4545 4546 4547
    BlockDriverAIOCBCoroutine *acb =
        container_of(blockacb, BlockDriverAIOCBCoroutine, common);
    bool done = false;

    acb->done = &done;
    while (!done) {
        qemu_aio_wait();
    }
4548 4549
}

S
Stefan Hajnoczi 已提交
4550
static const AIOCBInfo bdrv_em_co_aiocb_info = {
4551 4552 4553 4554
    .aiocb_size         = sizeof(BlockDriverAIOCBCoroutine),
    .cancel             = bdrv_aio_co_cancel_em,
};

P
Paolo Bonzini 已提交
4555
static void bdrv_co_em_bh(void *opaque)
4556 4557 4558 4559
{
    BlockDriverAIOCBCoroutine *acb = opaque;

    acb->common.cb(acb->common.opaque, acb->req.error);
K
Kevin Wolf 已提交
4560 4561 4562 4563 4564

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

4565 4566 4567 4568
    qemu_bh_delete(acb->bh);
    qemu_aio_release(acb);
}

4569 4570 4571 4572 4573 4574 4575 4576
/* 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 已提交
4577
            acb->req.nb_sectors, acb->req.qiov, acb->req.flags);
4578 4579
    } else {
        acb->req.error = bdrv_co_do_writev(bs, acb->req.sector,
P
Paolo Bonzini 已提交
4580
            acb->req.nb_sectors, acb->req.qiov, acb->req.flags);
4581 4582
    }

P
Paolo Bonzini 已提交
4583
    acb->bh = qemu_bh_new(bdrv_co_em_bh, acb);
4584 4585 4586
    qemu_bh_schedule(acb->bh);
}

4587 4588 4589 4590
static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs,
                                               int64_t sector_num,
                                               QEMUIOVector *qiov,
                                               int nb_sectors,
P
Paolo Bonzini 已提交
4591
                                               BdrvRequestFlags flags,
4592 4593
                                               BlockDriverCompletionFunc *cb,
                                               void *opaque,
4594
                                               bool is_write)
4595 4596 4597 4598
{
    Coroutine *co;
    BlockDriverAIOCBCoroutine *acb;

S
Stefan Hajnoczi 已提交
4599
    acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
4600 4601 4602
    acb->req.sector = sector_num;
    acb->req.nb_sectors = nb_sectors;
    acb->req.qiov = qiov;
P
Paolo Bonzini 已提交
4603
    acb->req.flags = flags;
4604
    acb->is_write = is_write;
K
Kevin Wolf 已提交
4605
    acb->done = NULL;
4606

4607
    co = qemu_coroutine_create(bdrv_co_do_rw);
4608 4609 4610 4611 4612
    qemu_coroutine_enter(co, acb);

    return &acb->common;
}

P
Paolo Bonzini 已提交
4613
static void coroutine_fn bdrv_aio_flush_co_entry(void *opaque)
4614
{
P
Paolo Bonzini 已提交
4615 4616
    BlockDriverAIOCBCoroutine *acb = opaque;
    BlockDriverState *bs = acb->common.bs;
4617

P
Paolo Bonzini 已提交
4618 4619
    acb->req.error = bdrv_co_flush(bs);
    acb->bh = qemu_bh_new(bdrv_co_em_bh, acb);
4620 4621 4622
    qemu_bh_schedule(acb->bh);
}

P
Paolo Bonzini 已提交
4623
BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs,
4624 4625
        BlockDriverCompletionFunc *cb, void *opaque)
{
P
Paolo Bonzini 已提交
4626
    trace_bdrv_aio_flush(bs, opaque);
4627

P
Paolo Bonzini 已提交
4628 4629
    Coroutine *co;
    BlockDriverAIOCBCoroutine *acb;
4630

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

P
Paolo Bonzini 已提交
4634 4635
    co = qemu_coroutine_create(bdrv_aio_flush_co_entry);
    qemu_coroutine_enter(co, acb);
4636 4637 4638 4639

    return &acb->common;
}

4640 4641 4642 4643 4644 4645 4646 4647 4648 4649 4650 4651 4652 4653 4654 4655 4656 4657 4658
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);
    acb->bh = qemu_bh_new(bdrv_co_em_bh, acb);
    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 已提交
4659
    acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
4660 4661
    acb->req.sector = sector_num;
    acb->req.nb_sectors = nb_sectors;
K
Kevin Wolf 已提交
4662
    acb->done = NULL;
4663 4664 4665 4666 4667 4668
    co = qemu_coroutine_create(bdrv_aio_discard_co_entry);
    qemu_coroutine_enter(co, acb);

    return &acb->common;
}

B
bellard 已提交
4669 4670
void bdrv_init(void)
{
4671
    module_call_init(MODULE_INIT_BLOCK);
B
bellard 已提交
4672
}
4673

4674 4675 4676 4677 4678 4679
void bdrv_init_with_whitelist(void)
{
    use_bdrv_whitelist = 1;
    bdrv_init();
}

S
Stefan Hajnoczi 已提交
4680
void *qemu_aio_get(const AIOCBInfo *aiocb_info, BlockDriverState *bs,
4681
                   BlockDriverCompletionFunc *cb, void *opaque)
4682 4683 4684
{
    BlockDriverAIOCB *acb;

S
Stefan Hajnoczi 已提交
4685 4686
    acb = g_slice_alloc(aiocb_info->aiocb_size);
    acb->aiocb_info = aiocb_info;
4687 4688 4689 4690 4691 4692 4693 4694
    acb->bs = bs;
    acb->cb = cb;
    acb->opaque = opaque;
    return acb;
}

void qemu_aio_release(void *p)
{
4695
    BlockDriverAIOCB *acb = p;
S
Stefan Hajnoczi 已提交
4696
    g_slice_free1(acb->aiocb_info->aiocb_size, acb);
4697
}
B
bellard 已提交
4698

4699 4700 4701 4702 4703 4704 4705 4706 4707 4708 4709 4710 4711 4712 4713 4714 4715 4716 4717 4718 4719 4720 4721 4722 4723 4724
/**************************************************************/
/* 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) {
4725 4726
        acb = bs->drv->bdrv_aio_writev(bs, sector_num, iov, nb_sectors,
                                       bdrv_co_io_em_complete, &co);
4727
    } else {
4728 4729
        acb = bs->drv->bdrv_aio_readv(bs, sector_num, iov, nb_sectors,
                                      bdrv_co_io_em_complete, &co);
4730 4731
    }

4732
    trace_bdrv_co_io_em(bs, sector_num, nb_sectors, is_write, acb);
4733 4734 4735 4736 4737 4738 4739 4740 4741 4742 4743 4744 4745 4746 4747 4748 4749 4750 4751 4752 4753 4754
    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 已提交
4755
static void coroutine_fn bdrv_flush_co_entry(void *opaque)
4756
{
P
Paolo Bonzini 已提交
4757 4758 4759 4760 4761 4762 4763
    RwCo *rwco = opaque;

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

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

4766
    if (!bs || !bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
P
Paolo Bonzini 已提交
4767
        return 0;
K
Kevin Wolf 已提交
4768 4769
    }

4770
    /* Write back cached data to the OS even with cache=unsafe */
4771
    BLKDBG_EVENT(bs->file, BLKDBG_FLUSH_TO_OS);
K
Kevin Wolf 已提交
4772 4773 4774 4775 4776 4777 4778
    if (bs->drv->bdrv_co_flush_to_os) {
        ret = bs->drv->bdrv_co_flush_to_os(bs);
        if (ret < 0) {
            return ret;
        }
    }

4779 4780
    /* But don't actually force it to the disk with cache=unsafe */
    if (bs->open_flags & BDRV_O_NO_FLUSH) {
4781
        goto flush_parent;
4782 4783
    }

4784
    BLKDBG_EVENT(bs->file, BLKDBG_FLUSH_TO_DISK);
K
Kevin Wolf 已提交
4785
    if (bs->drv->bdrv_co_flush_to_disk) {
4786
        ret = bs->drv->bdrv_co_flush_to_disk(bs);
P
Paolo Bonzini 已提交
4787 4788 4789 4790 4791 4792 4793 4794
    } 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) {
4795
            ret = -EIO;
P
Paolo Bonzini 已提交
4796 4797
        } else {
            qemu_coroutine_yield();
4798
            ret = co.ret;
P
Paolo Bonzini 已提交
4799 4800 4801 4802 4803 4804 4805 4806 4807 4808 4809 4810 4811
        }
    } 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.
         */
4812
        ret = 0;
P
Paolo Bonzini 已提交
4813
    }
4814 4815 4816 4817 4818 4819 4820
    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.
     */
4821
flush_parent:
4822
    return bdrv_co_flush(bs->file);
P
Paolo Bonzini 已提交
4823 4824
}

4825
void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp)
4826
{
4827 4828 4829
    Error *local_err = NULL;
    int ret;

4830 4831 4832 4833 4834
    if (!bs->drv)  {
        return;
    }

    if (bs->drv->bdrv_invalidate_cache) {
4835
        bs->drv->bdrv_invalidate_cache(bs, &local_err);
4836
    } else if (bs->file) {
4837 4838 4839 4840 4841
        bdrv_invalidate_cache(bs->file, &local_err);
    }
    if (local_err) {
        error_propagate(errp, local_err);
        return;
4842
    }
4843

4844 4845 4846 4847 4848
    ret = refresh_total_sectors(bs, bs->total_sectors);
    if (ret < 0) {
        error_setg_errno(errp, -ret, "Could not refresh total sector count");
        return;
    }
4849 4850
}

4851
void bdrv_invalidate_cache_all(Error **errp)
4852 4853
{
    BlockDriverState *bs;
4854
    Error *local_err = NULL;
4855

4856
    QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
4857 4858 4859 4860 4861
        bdrv_invalidate_cache(bs, &local_err);
        if (local_err) {
            error_propagate(errp, local_err);
            return;
        }
4862 4863 4864
    }
}

4865 4866 4867 4868
void bdrv_clear_incoming_migration_all(void)
{
    BlockDriverState *bs;

4869
    QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
4870 4871 4872 4873
        bs->open_flags = bs->open_flags & ~(BDRV_O_INCOMING);
    }
}

P
Paolo Bonzini 已提交
4874 4875 4876 4877 4878 4879
int bdrv_flush(BlockDriverState *bs)
{
    Coroutine *co;
    RwCo rwco = {
        .bs = bs,
        .ret = NOT_DONE,
4880 4881
    };

P
Paolo Bonzini 已提交
4882 4883 4884 4885 4886 4887 4888 4889 4890
    if (qemu_in_coroutine()) {
        /* Fast-path if already in coroutine context */
        bdrv_flush_co_entry(&rwco);
    } else {
        co = qemu_coroutine_create(bdrv_flush_co_entry);
        qemu_coroutine_enter(co, &rwco);
        while (rwco.ret == NOT_DONE) {
            qemu_aio_wait();
        }
4891
    }
P
Paolo Bonzini 已提交
4892 4893

    return rwco.ret;
4894 4895
}

4896 4897 4898 4899 4900 4901
typedef struct DiscardCo {
    BlockDriverState *bs;
    int64_t sector_num;
    int nb_sectors;
    int ret;
} DiscardCo;
4902 4903
static void coroutine_fn bdrv_discard_co_entry(void *opaque)
{
4904
    DiscardCo *rwco = opaque;
4905 4906 4907 4908

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

4909 4910 4911 4912 4913
/* 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

4914 4915 4916
int coroutine_fn bdrv_co_discard(BlockDriverState *bs, int64_t sector_num,
                                 int nb_sectors)
{
4917 4918
    int max_discard;

4919 4920 4921 4922 4923 4924
    if (!bs->drv) {
        return -ENOMEDIUM;
    } else if (bdrv_check_request(bs, sector_num, nb_sectors)) {
        return -EIO;
    } else if (bs->read_only) {
        return -EROFS;
4925 4926
    }

F
Fam Zheng 已提交
4927
    bdrv_reset_dirty(bs, sector_num, nb_sectors);
4928

P
Paolo Bonzini 已提交
4929 4930 4931 4932 4933
    /* Do nothing if disabled.  */
    if (!(bs->open_flags & BDRV_O_UNMAP)) {
        return 0;
    }

4934 4935 4936
    if (!bs->drv->bdrv_co_discard && !bs->drv->bdrv_aio_discard) {
        return 0;
    }
4937

4938 4939 4940 4941
    max_discard = bs->bl.max_discard ?  bs->bl.max_discard : MAX_DISCARD_DEFAULT;
    while (nb_sectors > 0) {
        int ret;
        int num = nb_sectors;
4942

4943 4944 4945 4946 4947 4948
        /* 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;
4949
            }
4950 4951
            num -= sector_num % bs->bl.discard_alignment;
        }
4952

4953 4954 4955 4956
        /* limit request size */
        if (num > max_discard) {
            num = max_discard;
        }
4957

4958
        if (bs->drv->bdrv_co_discard) {
4959
            ret = bs->drv->bdrv_co_discard(bs, sector_num, num);
4960 4961 4962 4963 4964 4965 4966 4967 4968 4969 4970 4971 4972
        } 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;
4973 4974
            }
        }
4975
        if (ret && ret != -ENOTSUP) {
4976
            return ret;
4977
        }
4978 4979 4980

        sector_num += num;
        nb_sectors -= num;
4981
    }
4982
    return 0;
4983 4984 4985 4986 4987
}

int bdrv_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors)
{
    Coroutine *co;
4988
    DiscardCo rwco = {
4989 4990 4991 4992 4993 4994 4995 4996 4997 4998 4999 5000 5001 5002 5003 5004 5005 5006 5007 5008
        .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 {
        co = qemu_coroutine_create(bdrv_discard_co_entry);
        qemu_coroutine_enter(co, &rwco);
        while (rwco.ret == NOT_DONE) {
            qemu_aio_wait();
        }
    }

    return rwco.ret;
}

B
bellard 已提交
5009 5010 5011 5012 5013 5014 5015 5016 5017
/**************************************************************/
/* removable device support */

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

B
bellard 已提交
5019 5020 5021
    if (!drv)
        return 0;
    if (!drv->bdrv_is_inserted)
5022 5023
        return 1;
    return drv->bdrv_is_inserted(bs);
B
bellard 已提交
5024 5025 5026
}

/**
5027 5028
 * 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 已提交
5029 5030 5031 5032 5033
 */
int bdrv_media_changed(BlockDriverState *bs)
{
    BlockDriver *drv = bs->drv;

5034 5035 5036 5037
    if (drv && drv->bdrv_media_changed) {
        return drv->bdrv_media_changed(bs);
    }
    return -ENOTSUP;
B
bellard 已提交
5038 5039 5040 5041 5042
}

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

5047 5048
    if (drv && drv->bdrv_eject) {
        drv->bdrv_eject(bs, eject_flag);
B
bellard 已提交
5049
    }
5050 5051 5052 5053

    if (bs->device_name[0] != '\0') {
        bdrv_emit_qmp_eject_event(bs, eject_flag);
    }
B
bellard 已提交
5054 5055 5056 5057 5058 5059
}

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

5064
    trace_bdrv_lock_medium(bs, locked);
S
Stefan Hajnoczi 已提交
5065

5066 5067
    if (drv && drv->bdrv_lock_medium) {
        drv->bdrv_lock_medium(bs, locked);
B
bellard 已提交
5068 5069
    }
}
5070 5071 5072 5073 5074 5075 5076 5077 5078 5079 5080

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

5082 5083 5084
BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
        unsigned long int req, void *buf,
        BlockDriverCompletionFunc *cb, void *opaque)
5085
{
5086
    BlockDriver *drv = bs->drv;
5087

5088 5089 5090
    if (drv && drv->bdrv_aio_ioctl)
        return drv->bdrv_aio_ioctl(bs, req, buf, cb, opaque);
    return NULL;
5091
}
5092

5093
void bdrv_set_guest_block_size(BlockDriverState *bs, int align)
5094
{
5095
    bs->guest_block_size = align;
5096
}
5097

5098 5099
void *qemu_blockalign(BlockDriverState *bs, size_t size)
{
5100
    return qemu_memalign(bdrv_opt_mem_align(bs), size);
5101
}
5102

5103 5104 5105 5106 5107 5108
/*
 * Check if all memory in this vector is sector aligned.
 */
bool bdrv_qiov_is_aligned(BlockDriverState *bs, QEMUIOVector *qiov)
{
    int i;
5109
    size_t alignment = bdrv_opt_mem_align(bs);
5110 5111

    for (i = 0; i < qiov->niov; i++) {
5112
        if ((uintptr_t) qiov->iov[i].iov_base % alignment) {
5113
            return false;
5114
        }
5115
        if (qiov->iov[i].iov_len % alignment) {
5116
            return false;
5117 5118 5119 5120 5121 5122
        }
    }

    return true;
}

5123 5124
BdrvDirtyBitmap *bdrv_create_dirty_bitmap(BlockDriverState *bs, int granularity,
                                          Error **errp)
5125 5126
{
    int64_t bitmap_size;
F
Fam Zheng 已提交
5127
    BdrvDirtyBitmap *bitmap;
5128

5129 5130
    assert((granularity & (granularity - 1)) == 0);

F
Fam Zheng 已提交
5131 5132
    granularity >>= BDRV_SECTOR_BITS;
    assert(granularity);
5133 5134 5135 5136 5137 5138 5139
    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 已提交
5140 5141 5142 5143 5144 5145 5146 5147 5148 5149 5150 5151 5152 5153 5154
    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;
5155
        }
5156 5157 5158
    }
}

F
Fam Zheng 已提交
5159 5160 5161 5162 5163 5164 5165 5166 5167 5168 5169 5170 5171 5172 5173 5174 5175 5176 5177 5178
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 已提交
5179
int bdrv_get_dirty(BlockDriverState *bs, BdrvDirtyBitmap *bitmap, int64_t sector)
5180
{
F
Fam Zheng 已提交
5181 5182
    if (bitmap) {
        return hbitmap_get(bitmap->bitmap, sector);
5183 5184 5185 5186 5187
    } else {
        return 0;
    }
}

F
Fam Zheng 已提交
5188 5189
void bdrv_dirty_iter_init(BlockDriverState *bs,
                          BdrvDirtyBitmap *bitmap, HBitmapIter *hbi)
5190
{
F
Fam Zheng 已提交
5191
    hbitmap_iter_init(hbi, bitmap->bitmap, 0);
5192 5193 5194 5195 5196
}

void bdrv_set_dirty(BlockDriverState *bs, int64_t cur_sector,
                    int nr_sectors)
{
F
Fam Zheng 已提交
5197 5198 5199 5200
    BdrvDirtyBitmap *bitmap;
    QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
        hbitmap_set(bitmap->bitmap, cur_sector, nr_sectors);
    }
5201 5202
}

F
Fam Zheng 已提交
5203
void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector, int nr_sectors)
5204
{
F
Fam Zheng 已提交
5205 5206 5207 5208
    BdrvDirtyBitmap *bitmap;
    QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
        hbitmap_reset(bitmap->bitmap, cur_sector, nr_sectors);
    }
5209
}
5210

F
Fam Zheng 已提交
5211
int64_t bdrv_get_dirty_count(BlockDriverState *bs, BdrvDirtyBitmap *bitmap)
5212
{
F
Fam Zheng 已提交
5213
    return hbitmap_count(bitmap->bitmap);
5214
}
J
Jes Sorensen 已提交
5215

5216 5217 5218 5219 5220 5221 5222 5223 5224 5225 5226 5227 5228 5229 5230 5231 5232
/* 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);
    }
}

5233 5234 5235 5236 5237 5238 5239 5240 5241 5242 5243
void bdrv_set_in_use(BlockDriverState *bs, int in_use)
{
    assert(bs->in_use != in_use);
    bs->in_use = in_use;
}

int bdrv_in_use(BlockDriverState *bs)
{
    return bs->in_use;
}

5244 5245
void bdrv_iostatus_enable(BlockDriverState *bs)
{
5246
    bs->iostatus_enabled = true;
5247
    bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
5248 5249 5250 5251 5252 5253
}

/* 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)
{
5254
    return (bs->iostatus_enabled &&
5255 5256 5257
           (bs->on_write_error == BLOCKDEV_ON_ERROR_ENOSPC ||
            bs->on_write_error == BLOCKDEV_ON_ERROR_STOP   ||
            bs->on_read_error == BLOCKDEV_ON_ERROR_STOP));
5258 5259 5260 5261
}

void bdrv_iostatus_disable(BlockDriverState *bs)
{
5262
    bs->iostatus_enabled = false;
5263 5264 5265 5266 5267
}

void bdrv_iostatus_reset(BlockDriverState *bs)
{
    if (bdrv_iostatus_is_enabled(bs)) {
5268
        bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
5269 5270 5271
        if (bs->job) {
            block_job_iostatus_reset(bs->job);
        }
5272 5273 5274 5275 5276
    }
}

void bdrv_iostatus_set_err(BlockDriverState *bs, int error)
{
5277 5278
    assert(bdrv_iostatus_is_enabled(bs));
    if (bs->iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
5279 5280
        bs->iostatus = error == ENOSPC ? BLOCK_DEVICE_IO_STATUS_NOSPACE :
                                         BLOCK_DEVICE_IO_STATUS_FAILED;
5281 5282 5283
    }
}

5284 5285 5286 5287 5288 5289 5290
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 已提交
5291
    cookie->start_time_ns = get_clock();
5292 5293 5294 5295 5296 5297 5298 5299 5300 5301
    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 已提交
5302
    bs->total_time_ns[cookie->type] += get_clock() - cookie->start_time_ns;
5303 5304
}

5305 5306
void bdrv_img_create(const char *filename, const char *fmt,
                     const char *base_filename, const char *base_fmt,
5307 5308
                     char *options, uint64_t img_size, int flags,
                     Error **errp, bool quiet)
J
Jes Sorensen 已提交
5309 5310
{
    QEMUOptionParameter *param = NULL, *create_options = NULL;
K
Kevin Wolf 已提交
5311
    QEMUOptionParameter *backing_fmt, *backing_file, *size;
J
Jes Sorensen 已提交
5312
    BlockDriver *drv, *proto_drv;
5313
    BlockDriver *backing_drv = NULL;
5314
    Error *local_err = NULL;
J
Jes Sorensen 已提交
5315 5316 5317 5318 5319
    int ret = 0;

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

5324
    proto_drv = bdrv_find_protocol(filename, true);
J
Jes Sorensen 已提交
5325
    if (!proto_drv) {
5326
        error_setg(errp, "Unknown protocol '%s'", filename);
5327
        return;
J
Jes Sorensen 已提交
5328 5329 5330 5331 5332 5333 5334 5335 5336 5337 5338 5339 5340 5341 5342 5343
    }

    create_options = append_option_parameters(create_options,
                                              drv->create_options);
    create_options = append_option_parameters(create_options,
                                              proto_drv->create_options);

    /* Create parameter list with default values */
    param = parse_option_parameters("", create_options, param);

    set_option_parameter_int(param, BLOCK_OPT_SIZE, img_size);

    /* Parse -o options */
    if (options) {
        param = parse_option_parameters(options, create_options, param);
        if (param == NULL) {
5344
            error_setg(errp, "Invalid options for file format '%s'.", fmt);
J
Jes Sorensen 已提交
5345 5346 5347 5348 5349 5350 5351
            goto out;
        }
    }

    if (base_filename) {
        if (set_option_parameter(param, BLOCK_OPT_BACKING_FILE,
                                 base_filename)) {
5352 5353
            error_setg(errp, "Backing file not supported for file format '%s'",
                       fmt);
J
Jes Sorensen 已提交
5354 5355 5356 5357 5358 5359
            goto out;
        }
    }

    if (base_fmt) {
        if (set_option_parameter(param, BLOCK_OPT_BACKING_FMT, base_fmt)) {
5360 5361
            error_setg(errp, "Backing file format not supported for file "
                             "format '%s'", fmt);
J
Jes Sorensen 已提交
5362 5363 5364 5365
            goto out;
        }
    }

5366 5367 5368
    backing_file = get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
    if (backing_file && backing_file->value.s) {
        if (!strcmp(filename, backing_file->value.s)) {
5369 5370
            error_setg(errp, "Error: Trying to create an image with the "
                             "same filename as the backing file");
5371 5372 5373 5374
            goto out;
        }
    }

J
Jes Sorensen 已提交
5375 5376
    backing_fmt = get_option_parameter(param, BLOCK_OPT_BACKING_FMT);
    if (backing_fmt && backing_fmt->value.s) {
5377 5378
        backing_drv = bdrv_find_format(backing_fmt->value.s);
        if (!backing_drv) {
5379 5380
            error_setg(errp, "Unknown backing file format '%s'",
                       backing_fmt->value.s);
J
Jes Sorensen 已提交
5381 5382 5383 5384 5385 5386
            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
K
Kevin Wolf 已提交
5387 5388
    size = get_option_parameter(param, BLOCK_OPT_SIZE);
    if (size && size->value.n == -1) {
J
Jes Sorensen 已提交
5389
        if (backing_file && backing_file->value.s) {
5390
            BlockDriverState *bs;
J
Jes Sorensen 已提交
5391 5392
            uint64_t size;
            char buf[32];
5393 5394 5395 5396 5397
            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 已提交
5398

5399
            bs = NULL;
5400
            ret = bdrv_open(&bs, backing_file->value.s, NULL, NULL, back_flags,
5401
                            backing_drv, &local_err);
J
Jes Sorensen 已提交
5402
            if (ret < 0) {
5403 5404 5405 5406 5407
                error_setg_errno(errp, -ret, "Could not open '%s': %s",
                                 backing_file->value.s,
                                 error_get_pretty(local_err));
                error_free(local_err);
                local_err = NULL;
J
Jes Sorensen 已提交
5408 5409 5410 5411 5412 5413 5414
                goto out;
            }
            bdrv_get_geometry(bs, &size);
            size *= 512;

            snprintf(buf, sizeof(buf), "%" PRId64, size);
            set_option_parameter(param, BLOCK_OPT_SIZE, buf);
5415 5416

            bdrv_unref(bs);
J
Jes Sorensen 已提交
5417
        } else {
5418
            error_setg(errp, "Image creation needs a size parameter");
J
Jes Sorensen 已提交
5419 5420 5421 5422
            goto out;
        }
    }

5423 5424 5425 5426 5427
    if (!quiet) {
        printf("Formatting '%s', fmt=%s ", filename, fmt);
        print_option_parameters(param);
        puts("");
    }
5428 5429 5430 5431 5432 5433 5434 5435
    ret = bdrv_create(drv, filename, param, &local_err);
    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 = "";
        if (get_option_parameter(create_options, BLOCK_OPT_CLUSTER_SIZE)) {
            cluster_size_hint = " (try using a larger cluster size)";
J
Jes Sorensen 已提交
5436
        }
5437 5438 5439 5440
        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 已提交
5441 5442 5443 5444 5445 5446
    }

out:
    free_option_parameters(create_options);
    free_option_parameters(param);

5447
    if (local_err) {
5448 5449
        error_propagate(errp, local_err);
    }
J
Jes Sorensen 已提交
5450
}
5451 5452 5453 5454 5455 5456

AioContext *bdrv_get_aio_context(BlockDriverState *bs)
{
    /* Currently BlockDriverState always uses the main loop AioContext */
    return qemu_get_aio_context();
}
5457 5458 5459 5460 5461 5462

void bdrv_add_before_write_notifier(BlockDriverState *bs,
                                    NotifierWithReturn *notifier)
{
    notifier_with_return_list_add(&bs->before_write_notifiers, notifier);
}
M
Max Reitz 已提交
5463 5464 5465 5466 5467 5468 5469 5470

int bdrv_amend_options(BlockDriverState *bs, QEMUOptionParameter *options)
{
    if (bs->drv->bdrv_amend_options == NULL) {
        return -ENOTSUP;
    }
    return bs->drv->bdrv_amend_options(bs, options);
}
5471

5472 5473 5474 5475
/* 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.
5476
 */
5477
bool bdrv_recurse_is_first_non_filter(BlockDriverState *bs,
5478
                                      BlockDriverState *candidate)
5479
{
5480 5481
    /* return false if basic checks fails */
    if (!bs || !bs->drv) {
5482
        return false;
5483 5484
    }

5485 5486 5487 5488 5489
    /* 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;
5490
    }
5491
    /* Down this path the driver is a block filter driver */
5492

5493 5494 5495 5496
    /* 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) {
5497
        return bs->drv->bdrv_recurse_is_first_non_filter(bs, candidate);
5498 5499
    }

5500 5501 5502
    /* the driver is a block filter but don't allow to recurse -> return false
     */
    return false;
5503 5504
}

5505 5506 5507 5508 5509
/* 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)
5510
{
5511 5512 5513 5514 5515 5516
    BlockDriverState *bs;

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

5517
        /* try to recurse in this top level bs */
5518
        perm = bdrv_recurse_is_first_non_filter(bs, candidate);
5519 5520 5521 5522 5523 5524 5525 5526

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

    return false;
5527
}