block.c 68.6 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"
A
aliguori 已提交
26
#include "monitor.h"
B
bellard 已提交
27
#include "block_int.h"
28
#include "module.h"
29
#include "qemu-objects.h"
B
bellard 已提交
30

J
Juan Quintela 已提交
31
#ifdef CONFIG_BSD
B
bellard 已提交
32 33 34
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
B
Blue Swirl 已提交
35
#include <sys/queue.h>
36
#ifndef __DragonFly__
B
bellard 已提交
37 38
#include <sys/disk.h>
#endif
39
#endif
B
bellard 已提交
40

41 42 43 44
#ifdef _WIN32
#include <windows.h>
#endif

45 46
static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
        int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
47
        BlockDriverCompletionFunc *cb, void *opaque);
48 49
static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
        int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
50
        BlockDriverCompletionFunc *cb, void *opaque);
51 52
static BlockDriverAIOCB *bdrv_aio_flush_em(BlockDriverState *bs,
        BlockDriverCompletionFunc *cb, void *opaque);
53 54
static BlockDriverAIOCB *bdrv_aio_noop_em(BlockDriverState *bs,
        BlockDriverCompletionFunc *cb, void *opaque);
55
static int bdrv_read_em(BlockDriverState *bs, int64_t sector_num,
B
bellard 已提交
56 57 58
                        uint8_t *buf, int nb_sectors);
static int bdrv_write_em(BlockDriverState *bs, int64_t sector_num,
                         const uint8_t *buf, int nb_sectors);
B
bellard 已提交
59

60 61
static QTAILQ_HEAD(, BlockDriverState) bdrv_states =
    QTAILQ_HEAD_INITIALIZER(bdrv_states);
62

63 64
static QLIST_HEAD(, BlockDriver) bdrv_drivers =
    QLIST_HEAD_INITIALIZER(bdrv_drivers);
B
bellard 已提交
65

66 67 68
/* The device to use for VM snapshots */
static BlockDriverState *bs_snapshots;

69 70 71
/* If non-zero, use only whitelisted block drivers */
static int use_bdrv_whitelist;

B
bellard 已提交
72
int path_is_absolute(const char *path)
73
{
B
bellard 已提交
74
    const char *p;
B
bellard 已提交
75 76 77 78 79
#ifdef _WIN32
    /* specific case for names like: "\\.\d:" */
    if (*path == '/' || *path == '\\')
        return 1;
#endif
B
bellard 已提交
80 81 82 83 84
    p = strchr(path, ':');
    if (p)
        p++;
    else
        p = path;
85 86 87 88 89
#ifdef _WIN32
    return (*p == '/' || *p == '\\');
#else
    return (*p == '/');
#endif
90 91
}

B
bellard 已提交
92 93 94 95 96 97
/* 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)
98
{
B
bellard 已提交
99 100 101 102 103 104 105 106 107 108 109 110 111
    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;
112 113 114 115 116 117 118 119 120
        p1 = strrchr(base_path, '/');
#ifdef _WIN32
        {
            const char *p2;
            p2 = strrchr(base_path, '\\');
            if (!p1 || p2 > p1)
                p1 = p2;
        }
#endif
B
bellard 已提交
121 122 123 124 125 126 127 128 129 130 131 132
        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);
133 134 135
    }
}

136
void bdrv_register(BlockDriver *bdrv)
B
bellard 已提交
137
{
138
    if (!bdrv->bdrv_aio_readv) {
B
bellard 已提交
139
        /* add AIO emulation layer */
140 141
        bdrv->bdrv_aio_readv = bdrv_aio_readv_em;
        bdrv->bdrv_aio_writev = bdrv_aio_writev_em;
142
    } else if (!bdrv->bdrv_read) {
B
bellard 已提交
143 144 145 146
        /* add synchronous IO emulation layer */
        bdrv->bdrv_read = bdrv_read_em;
        bdrv->bdrv_write = bdrv_write_em;
    }
147 148 149 150

    if (!bdrv->bdrv_aio_flush)
        bdrv->bdrv_aio_flush = bdrv_aio_flush_em;

151
    QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list);
B
bellard 已提交
152
}
B
bellard 已提交
153 154 155 156

/* create a new block device (by default it is empty) */
BlockDriverState *bdrv_new(const char *device_name)
{
157
    BlockDriverState *bs;
B
bellard 已提交
158 159 160

    bs = qemu_mallocz(sizeof(BlockDriverState));
    pstrcpy(bs->device_name, sizeof(bs->device_name), device_name);
B
bellard 已提交
161
    if (device_name[0] != '\0') {
162
        QTAILQ_INSERT_TAIL(&bdrv_states, bs, list);
B
bellard 已提交
163
    }
B
bellard 已提交
164 165 166
    return bs;
}

B
bellard 已提交
167 168 169
BlockDriver *bdrv_find_format(const char *format_name)
{
    BlockDriver *drv1;
170 171
    QLIST_FOREACH(drv1, &bdrv_drivers, list) {
        if (!strcmp(drv1->format_name, format_name)) {
B
bellard 已提交
172
            return drv1;
173
        }
B
bellard 已提交
174 175 176 177
    }
    return NULL;
}

178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201
static int bdrv_is_whitelisted(BlockDriver *drv)
{
    static const char *whitelist[] = {
        CONFIG_BDRV_WHITELIST
    };
    const char **p;

    if (!whitelist[0])
        return 1;               /* no whitelist, anything goes */

    for (p = whitelist; *p; p++) {
        if (!strcmp(drv->format_name, *p)) {
            return 1;
        }
    }
    return 0;
}

BlockDriver *bdrv_find_whitelisted_format(const char *format_name)
{
    BlockDriver *drv = bdrv_find_format(format_name);
    return drv && bdrv_is_whitelisted(drv) ? drv : NULL;
}

202 203
int bdrv_create(BlockDriver *drv, const char* filename,
    QEMUOptionParameter *options)
B
bellard 已提交
204 205 206
{
    if (!drv->bdrv_create)
        return -ENOTSUP;
207 208

    return drv->bdrv_create(filename, options);
B
bellard 已提交
209 210
}

211 212 213 214
int bdrv_create_file(const char* filename, QEMUOptionParameter *options)
{
    BlockDriver *drv;

215
    drv = bdrv_find_protocol(filename);
216 217 218 219 220 221 222
    if (drv == NULL) {
        drv = bdrv_find_format("file");
    }

    return bdrv_create(drv, filename, options);
}

B
bellard 已提交
223
#ifdef _WIN32
224
void get_tmp_filename(char *filename, int size)
B
bellard 已提交
225
{
226
    char temp_dir[MAX_PATH];
227

228 229
    GetTempPath(MAX_PATH, temp_dir);
    GetTempFileName(temp_dir, "qem", 0, filename);
B
bellard 已提交
230 231
}
#else
232
void get_tmp_filename(char *filename, int size)
B
bellard 已提交
233
{
B
bellard 已提交
234
    int fd;
235
    const char *tmpdir;
B
bellard 已提交
236
    /* XXX: race condition possible */
A
aurel32 已提交
237 238 239 240
    tmpdir = getenv("TMPDIR");
    if (!tmpdir)
        tmpdir = "/tmp";
    snprintf(filename, size, "%s/vl.XXXXXX", tmpdir);
B
bellard 已提交
241 242 243
    fd = mkstemp(filename);
    close(fd);
}
B
bellard 已提交
244
#endif
B
bellard 已提交
245

B
bellard 已提交
246
#ifdef _WIN32
B
bellard 已提交
247 248 249 250 251 252
static int is_windows_drive_prefix(const char *filename)
{
    return (((filename[0] >= 'a' && filename[0] <= 'z') ||
             (filename[0] >= 'A' && filename[0] <= 'Z')) &&
            filename[1] == ':');
}
253

254
int is_windows_drive(const char *filename)
B
bellard 已提交
255
{
256
    if (is_windows_drive_prefix(filename) &&
B
bellard 已提交
257
        filename[2] == '\0')
B
bellard 已提交
258 259 260 261 262 263 264 265
        return 1;
    if (strstart(filename, "\\\\.\\", NULL) ||
        strstart(filename, "//./", NULL))
        return 1;
    return 0;
}
#endif

266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287
/*
 * 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;
}

288
BlockDriver *bdrv_find_protocol(const char *filename)
B
bellard 已提交
289 290 291
{
    BlockDriver *drv1;
    char protocol[128];
292
    int len;
B
bellard 已提交
293
    const char *p;
B
bellard 已提交
294

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

297 298 299 300 301 302 303 304 305 306 307 308
    /*
     * 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;
    }

B
bellard 已提交
309
#ifdef _WIN32
310 311 312
     if (is_windows_drive(filename) ||
         is_windows_drive_prefix(filename))
         return bdrv_find_format("file");
B
bellard 已提交
313
#endif
314

315
    p = strchr(filename, ':');
316 317
    if (!p) {
        return bdrv_find_format("file");
318
    }
319 320 321 322 323
    len = p - filename;
    if (len > sizeof(protocol) - 1)
        len = sizeof(protocol) - 1;
    memcpy(protocol, filename, len);
    protocol[len] = '\0';
324
    QLIST_FOREACH(drv1, &bdrv_drivers, list) {
325
        if (drv1->protocol_name &&
326
            !strcmp(drv1->protocol_name, protocol)) {
B
bellard 已提交
327
            return drv1;
328
        }
B
bellard 已提交
329 330 331 332
    }
    return NULL;
}

333 334 335 336 337 338 339
static BlockDriver *find_image_format(const char *filename)
{
    int ret, score, score_max;
    BlockDriver *drv1, *drv;
    uint8_t buf[2048];
    BlockDriverState *bs;

340
    ret = bdrv_file_open(&bs, filename, 0);
B
bellard 已提交
341 342
    if (ret < 0)
        return NULL;
343

344 345
    /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
    if (bs->sg || !bdrv_is_inserted(bs)) {
346
        bdrv_delete(bs);
347
        return bdrv_find_format("raw");
348
    }
349

B
bellard 已提交
350 351 352 353 354 355
    ret = bdrv_pread(bs, 0, buf, sizeof(buf));
    bdrv_delete(bs);
    if (ret < 0) {
        return NULL;
    }

B
bellard 已提交
356
    score_max = 0;
357
    drv = NULL;
358
    QLIST_FOREACH(drv1, &bdrv_drivers, list) {
B
bellard 已提交
359 360 361 362 363 364
        if (drv1->bdrv_probe) {
            score = drv1->bdrv_probe(buf, ret, filename);
            if (score > score_max) {
                score_max = score;
                drv = drv1;
            }
B
bellard 已提交
365
        }
B
bellard 已提交
366
    }
B
bellard 已提交
367 368 369
    return drv;
}

370 371 372 373 374 375 376
/**
 * Set the current 'total_sectors' value
 */
static int refresh_total_sectors(BlockDriverState *bs, int64_t hint)
{
    BlockDriver *drv = bs->drv;

377 378 379 380
    /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
    if (bs->sg)
        return 0;

381 382 383 384 385 386 387 388 389 390 391 392 393
    /* query actual device if possible, otherwise just trust the hint */
    if (drv->bdrv_getlength) {
        int64_t length = drv->bdrv_getlength(bs);
        if (length < 0) {
            return length;
        }
        hint = length >> BDRV_SECTOR_BITS;
    }

    bs->total_sectors = hint;
    return 0;
}

394 395 396 397 398 399 400 401 402 403
/*
 * Common part for opening disk images and files
 */
static int bdrv_open_common(BlockDriverState *bs, const char *filename,
    int flags, BlockDriver *drv)
{
    int ret, open_flags;

    assert(drv != NULL);

404
    bs->file = NULL;
405
    bs->total_sectors = 0;
406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442
    bs->encrypted = 0;
    bs->valid_key = 0;
    bs->open_flags = flags;
    /* buffer_alignment defaulted to 512, drivers can change this value */
    bs->buffer_alignment = 512;

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

    if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv)) {
        return -ENOTSUP;
    }

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

    /*
     * Yes, BDRV_O_NOCACHE aka O_DIRECT means we have to present a
     * write cache to the guest.  We do need the fdatasync to flush
     * out transactions for block allocations, and we maybe have a
     * volatile write cache in our backing device to deal with.
     */
    if (flags & (BDRV_O_CACHE_WB|BDRV_O_NOCACHE))
        bs->enable_write_cache = 1;

    /*
     * Clear flags that are internal to the block layer before opening the
     * image.
     */
    open_flags = flags & ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);

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

443 444 445 446 447 448 449 450 451 452
    /* Open the image, either directly or using a protocol */
    if (drv->bdrv_file_open) {
        ret = drv->bdrv_file_open(bs, filename, open_flags);
    } else {
        ret = bdrv_file_open(&bs->file, filename, open_flags);
        if (ret >= 0) {
            ret = drv->bdrv_open(bs, open_flags);
        }
    }

453 454 455 456 457
    if (ret < 0) {
        goto free_and_fail;
    }

    bs->keep_read_only = bs->read_only = !(open_flags & BDRV_O_RDWR);
458 459 460 461

    ret = refresh_total_sectors(bs, bs->total_sectors);
    if (ret < 0) {
        goto free_and_fail;
462
    }
463

464 465 466 467 468 469 470 471
#ifndef _WIN32
    if (bs->is_temporary) {
        unlink(filename);
    }
#endif
    return 0;

free_and_fail:
472 473 474 475
    if (bs->file) {
        bdrv_delete(bs->file);
        bs->file = NULL;
    }
476 477 478 479 480 481
    qemu_free(bs->opaque);
    bs->opaque = NULL;
    bs->drv = NULL;
    return ret;
}

K
Kevin Wolf 已提交
482 483 484
/*
 * Opens a file using a protocol (file, host_device, nbd, ...)
 */
B
bellard 已提交
485
int bdrv_file_open(BlockDriverState **pbs, const char *filename, int flags)
B
bellard 已提交
486
{
B
bellard 已提交
487
    BlockDriverState *bs;
488
    BlockDriver *drv;
B
bellard 已提交
489 490
    int ret;

491
    drv = bdrv_find_protocol(filename);
492 493 494 495
    if (!drv) {
        return -ENOENT;
    }

B
bellard 已提交
496
    bs = bdrv_new("");
K
Kevin Wolf 已提交
497
    ret = bdrv_open_common(bs, filename, flags, drv);
B
bellard 已提交
498 499 500
    if (ret < 0) {
        bdrv_delete(bs);
        return ret;
501
    }
502
    bs->growable = 1;
B
bellard 已提交
503 504 505 506
    *pbs = bs;
    return 0;
}

K
Kevin Wolf 已提交
507 508 509
/*
 * Opens a disk image (raw, qcow2, vmdk, ...)
 */
K
Kevin Wolf 已提交
510 511
int bdrv_open(BlockDriverState *bs, const char *filename, int flags,
              BlockDriver *drv)
B
bellard 已提交
512
{
K
Kevin Wolf 已提交
513
    int ret;
B
bellard 已提交
514

B
bellard 已提交
515
    if (flags & BDRV_O_SNAPSHOT) {
B
bellard 已提交
516 517
        BlockDriverState *bs1;
        int64_t total_size;
A
aliguori 已提交
518
        int is_protocol = 0;
K
Kevin Wolf 已提交
519 520
        BlockDriver *bdrv_qcow2;
        QEMUOptionParameter *options;
K
Kevin Wolf 已提交
521 522
        char tmp_filename[PATH_MAX];
        char backing_filename[PATH_MAX];
523

B
bellard 已提交
524 525
        /* if snapshot, we create a temporary backing file and open it
           instead of opening 'filename' directly */
526

B
bellard 已提交
527 528
        /* if there is a backing file, use it */
        bs1 = bdrv_new("");
K
Kevin Wolf 已提交
529
        ret = bdrv_open(bs1, filename, 0, drv);
530
        if (ret < 0) {
B
bellard 已提交
531
            bdrv_delete(bs1);
532
            return ret;
B
bellard 已提交
533
        }
534
        total_size = bdrv_getlength(bs1) & BDRV_SECTOR_MASK;
A
aliguori 已提交
535 536 537 538

        if (bs1->drv && bs1->drv->protocol_name)
            is_protocol = 1;

B
bellard 已提交
539
        bdrv_delete(bs1);
540

B
bellard 已提交
541
        get_tmp_filename(tmp_filename, sizeof(tmp_filename));
A
aliguori 已提交
542 543 544 545 546

        /* Real path is meaningless for protocols */
        if (is_protocol)
            snprintf(backing_filename, sizeof(backing_filename),
                     "%s", filename);
547 548
        else if (!realpath(filename, backing_filename))
            return -errno;
A
aliguori 已提交
549

K
Kevin Wolf 已提交
550 551 552
        bdrv_qcow2 = bdrv_find_format("qcow2");
        options = parse_option_parameters("", bdrv_qcow2->create_options, NULL);

553
        set_option_parameter_int(options, BLOCK_OPT_SIZE, total_size);
K
Kevin Wolf 已提交
554 555 556 557 558 559 560
        set_option_parameter(options, BLOCK_OPT_BACKING_FILE, backing_filename);
        if (drv) {
            set_option_parameter(options, BLOCK_OPT_BACKING_FMT,
                drv->format_name);
        }

        ret = bdrv_create(bdrv_qcow2, tmp_filename, options);
561
        free_option_parameters(options);
562 563
        if (ret < 0) {
            return ret;
B
bellard 已提交
564
        }
K
Kevin Wolf 已提交
565

B
bellard 已提交
566
        filename = tmp_filename;
K
Kevin Wolf 已提交
567
        drv = bdrv_qcow2;
B
bellard 已提交
568 569
        bs->is_temporary = 1;
    }
B
bellard 已提交
570

K
Kevin Wolf 已提交
571
    /* Find the right image format driver */
572
    if (!drv) {
573
        drv = find_image_format(filename);
574
    }
575

576 577 578
    if (!drv) {
        ret = -ENOENT;
        goto unlink_and_fail;
B
bellard 已提交
579
    }
K
Kevin Wolf 已提交
580 581 582 583

    /* Open the image */
    ret = bdrv_open_common(bs, filename, flags, drv);
    if (ret < 0) {
584 585 586
        goto unlink_and_fail;
    }

K
Kevin Wolf 已提交
587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631
    /* If there is a backing file, use it */
    if ((flags & BDRV_O_NO_BACKING) == 0 && bs->backing_file[0] != '\0') {
        char backing_filename[PATH_MAX];
        int back_flags;
        BlockDriver *back_drv = NULL;

        bs->backing_hd = bdrv_new("");
        path_combine(backing_filename, sizeof(backing_filename),
                     filename, bs->backing_file);
        if (bs->backing_format[0] != '\0')
            back_drv = bdrv_find_format(bs->backing_format);

        /* backing files always opened read-only */
        back_flags =
            flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);

        ret = bdrv_open(bs->backing_hd, backing_filename, back_flags, back_drv);
        if (ret < 0) {
            bdrv_close(bs);
            return ret;
        }
        if (bs->is_temporary) {
            bs->backing_hd->keep_read_only = !(flags & BDRV_O_RDWR);
        } else {
            /* base image inherits from "parent" */
            bs->backing_hd->keep_read_only = bs->keep_read_only;
        }
    }

    if (!bdrv_key_required(bs)) {
        /* call the change callback */
        bs->media_changed = 1;
        if (bs->change_cb)
            bs->change_cb(bs->change_opaque);
    }

    return 0;

unlink_and_fail:
    if (bs->is_temporary) {
        unlink(filename);
    }
    return ret;
}

B
bellard 已提交
632 633
void bdrv_close(BlockDriverState *bs)
{
B
bellard 已提交
634
    if (bs->drv) {
635 636 637
        if (bs == bs_snapshots) {
            bs_snapshots = NULL;
        }
638
        if (bs->backing_hd) {
B
bellard 已提交
639
            bdrv_delete(bs->backing_hd);
640 641
            bs->backing_hd = NULL;
        }
B
bellard 已提交
642 643 644 645 646 647
        bs->drv->bdrv_close(bs);
        qemu_free(bs->opaque);
#ifdef _WIN32
        if (bs->is_temporary) {
            unlink(bs->filename);
        }
B
bellard 已提交
648
#endif
B
bellard 已提交
649 650
        bs->opaque = NULL;
        bs->drv = NULL;
B
bellard 已提交
651

652 653 654 655
        if (bs->file != NULL) {
            bdrv_close(bs->file);
        }

B
bellard 已提交
656
        /* call the change callback */
B
bellard 已提交
657
        bs->media_changed = 1;
B
bellard 已提交
658 659 660 661 662
        if (bs->change_cb)
            bs->change_cb(bs->change_opaque);
    }
}

663 664 665 666 667 668 669 670 671
void bdrv_close_all(void)
{
    BlockDriverState *bs;

    QTAILQ_FOREACH(bs, &bdrv_states, list) {
        bdrv_close(bs);
    }
}

B
bellard 已提交
672 673
void bdrv_delete(BlockDriverState *bs)
{
674 675
    assert(!bs->peer);

676 677 678 679
    /* remove from list, if necessary */
    if (bs->device_name[0] != '\0') {
        QTAILQ_REMOVE(&bdrv_states, bs, list);
    }
680

B
bellard 已提交
681
    bdrv_close(bs);
682 683 684 685
    if (bs->file != NULL) {
        bdrv_delete(bs->file);
    }

686
    assert(bs != bs_snapshots);
B
bellard 已提交
687
    qemu_free(bs);
B
bellard 已提交
688 689
}

690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709
int bdrv_attach(BlockDriverState *bs, DeviceState *qdev)
{
    if (bs->peer) {
        return -EBUSY;
    }
    bs->peer = qdev;
    return 0;
}

void bdrv_detach(BlockDriverState *bs, DeviceState *qdev)
{
    assert(bs->peer == qdev);
    bs->peer = NULL;
}

DeviceState *bdrv_get_attached(BlockDriverState *bs)
{
    return bs->peer;
}

A
aliguori 已提交
710 711 712 713 714 715 716 717 718 719 720 721 722 723
/*
 * Run consistency checks on an image
 *
 * Returns the number of errors or -errno when an internal error occurs
 */
int bdrv_check(BlockDriverState *bs)
{
    if (bs->drv->bdrv_check == NULL) {
        return -ENOTSUP;
    }

    return bs->drv->bdrv_check(bs);
}

724 725 726
/* commit COW file into the raw image */
int bdrv_commit(BlockDriverState *bs)
{
B
bellard 已提交
727
    BlockDriver *drv = bs->drv;
B
bellard 已提交
728
    int64_t i, total_sectors;
729 730
    int n, j, ro, open_flags;
    int ret = 0, rw_ret = 0;
731
    unsigned char sector[BDRV_SECTOR_SIZE];
732 733
    char filename[1024];
    BlockDriverState *bs_rw, *bs_ro;
734

B
bellard 已提交
735 736
    if (!drv)
        return -ENOMEDIUM;
737 738 739
    
    if (!bs->backing_hd) {
        return -ENOTSUP;
740 741
    }

742 743 744 745 746 747 748 749 750 751 752 753 754
    if (bs->backing_hd->keep_read_only) {
        return -EACCES;
    }
    
    ro = bs->backing_hd->read_only;
    strncpy(filename, bs->backing_hd->filename, sizeof(filename));
    open_flags =  bs->backing_hd->open_flags;

    if (ro) {
        /* re-open as RW */
        bdrv_delete(bs->backing_hd);
        bs->backing_hd = NULL;
        bs_rw = bdrv_new("");
K
Kevin Wolf 已提交
755
        rw_ret = bdrv_open(bs_rw, filename, open_flags | BDRV_O_RDWR, drv);
756 757 758 759
        if (rw_ret < 0) {
            bdrv_delete(bs_rw);
            /* try to re-open read-only */
            bs_ro = bdrv_new("");
K
Kevin Wolf 已提交
760
            ret = bdrv_open(bs_ro, filename, open_flags & ~BDRV_O_RDWR, drv);
761 762 763 764 765 766 767 768 769 770
            if (ret < 0) {
                bdrv_delete(bs_ro);
                /* drive not functional anymore */
                bs->drv = NULL;
                return ret;
            }
            bs->backing_hd = bs_ro;
            return rw_ret;
        }
        bs->backing_hd = bs_rw;
B
bellard 已提交
771
    }
772

J
Jan Kiszka 已提交
773
    total_sectors = bdrv_getlength(bs) >> BDRV_SECTOR_BITS;
B
bellard 已提交
774
    for (i = 0; i < total_sectors;) {
B
bellard 已提交
775
        if (drv->bdrv_is_allocated(bs, i, 65536, &n)) {
B
bellard 已提交
776 777
            for(j = 0; j < n; j++) {
                if (bdrv_read(bs, i, sector, 1) != 0) {
778 779
                    ret = -EIO;
                    goto ro_cleanup;
B
bellard 已提交
780 781 782
                }

                if (bdrv_write(bs->backing_hd, i, sector, 1) != 0) {
783 784
                    ret = -EIO;
                    goto ro_cleanup;
B
bellard 已提交
785 786
                }
                i++;
787
	    }
B
bellard 已提交
788 789 790
	} else {
            i += n;
        }
791
    }
792

793 794 795 796
    if (drv->bdrv_make_empty) {
        ret = drv->bdrv_make_empty(bs);
        bdrv_flush(bs);
    }
797

798 799 800 801 802 803
    /*
     * Make sure all data we wrote to the backing device is actually
     * stable on disk.
     */
    if (bs->backing_hd)
        bdrv_flush(bs->backing_hd);
804 805 806 807 808 809 810 811

ro_cleanup:

    if (ro) {
        /* re-open as RO */
        bdrv_delete(bs->backing_hd);
        bs->backing_hd = NULL;
        bs_ro = bdrv_new("");
K
Kevin Wolf 已提交
812
        ret = bdrv_open(bs_ro, filename, open_flags & ~BDRV_O_RDWR, drv);
813 814 815 816 817 818 819 820 821 822
        if (ret < 0) {
            bdrv_delete(bs_ro);
            /* drive not functional anymore */
            bs->drv = NULL;
            return ret;
        }
        bs->backing_hd = bs_ro;
        bs->backing_hd->keep_read_only = 0;
    }

823
    return ret;
824 825
}

826 827 828 829 830 831 832 833 834
void bdrv_commit_all(void)
{
    BlockDriverState *bs;

    QTAILQ_FOREACH(bs, &bdrv_states, list) {
        bdrv_commit(bs);
    }
}

K
Kevin Wolf 已提交
835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854
/*
 * 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;

    if (drv->bdrv_change_backing_file != NULL) {
        return drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
    } else {
        return -ENOTSUP;
    }
}

855 856 857 858 859 860 861 862 863 864 865 866 867
static int bdrv_check_byte_request(BlockDriverState *bs, int64_t offset,
                                   size_t size)
{
    int64_t len;

    if (!bdrv_is_inserted(bs))
        return -ENOMEDIUM;

    if (bs->growable)
        return 0;

    len = bdrv_getlength(bs);

K
Kevin Wolf 已提交
868 869 870 871
    if (offset < 0)
        return -EIO;

    if ((offset > len) || (len - offset < size))
872 873 874 875 876 877 878 879
        return -EIO;

    return 0;
}

static int bdrv_check_request(BlockDriverState *bs, int64_t sector_num,
                              int nb_sectors)
{
880 881
    return bdrv_check_byte_request(bs, sector_num * BDRV_SECTOR_SIZE,
                                   nb_sectors * BDRV_SECTOR_SIZE);
882 883
}

B
bellard 已提交
884
/* return < 0 if error. See bdrv_write() for the return codes */
885
int bdrv_read(BlockDriverState *bs, int64_t sector_num,
B
bellard 已提交
886 887
              uint8_t *buf, int nb_sectors)
{
B
bellard 已提交
888 889
    BlockDriver *drv = bs->drv;

B
bellard 已提交
890 891
    if (!drv)
        return -ENOMEDIUM;
892 893
    if (bdrv_check_request(bs, sector_num, nb_sectors))
        return -EIO;
B
bellard 已提交
894

895
    return drv->bdrv_read(bs, sector_num, buf, nb_sectors);
B
bellard 已提交
896 897
}

898
static void set_dirty_bitmap(BlockDriverState *bs, int64_t sector_num,
899
                             int nb_sectors, int dirty)
900 901
{
    int64_t start, end;
902
    unsigned long val, idx, bit;
903

J
Jan Kiszka 已提交
904
    start = sector_num / BDRV_SECTORS_PER_DIRTY_CHUNK;
905
    end = (sector_num + nb_sectors - 1) / BDRV_SECTORS_PER_DIRTY_CHUNK;
906 907

    for (; start <= end; start++) {
908 909 910 911
        idx = start / (sizeof(unsigned long) * 8);
        bit = start % (sizeof(unsigned long) * 8);
        val = bs->dirty_bitmap[idx];
        if (dirty) {
912 913 914 915
            if (!(val & (1 << bit))) {
                bs->dirty_count++;
                val |= 1 << bit;
            }
916
        } else {
917 918 919 920
            if (val & (1 << bit)) {
                bs->dirty_count--;
                val &= ~(1 << bit);
            }
921 922
        }
        bs->dirty_bitmap[idx] = val;
923 924 925
    }
}

926
/* Return < 0 if error. Important errors are:
B
bellard 已提交
927 928 929 930 931
  -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
*/
932
int bdrv_write(BlockDriverState *bs, int64_t sector_num,
B
bellard 已提交
933 934
               const uint8_t *buf, int nb_sectors)
{
B
bellard 已提交
935
    BlockDriver *drv = bs->drv;
B
bellard 已提交
936 937
    if (!bs->drv)
        return -ENOMEDIUM;
B
bellard 已提交
938
    if (bs->read_only)
B
bellard 已提交
939
        return -EACCES;
940 941
    if (bdrv_check_request(bs, sector_num, nb_sectors))
        return -EIO;
942

943
    if (bs->dirty_bitmap) {
944 945
        set_dirty_bitmap(bs, sector_num, nb_sectors, 1);
    }
946

947 948 949 950
    if (bs->wr_highest_sector < sector_num + nb_sectors - 1) {
        bs->wr_highest_sector = sector_num + nb_sectors - 1;
    }

951
    return drv->bdrv_write(bs, sector_num, buf, nb_sectors);
B
bellard 已提交
952 953
}

954 955
int bdrv_pread(BlockDriverState *bs, int64_t offset,
               void *buf, int count1)
B
bellard 已提交
956
{
J
Jan Kiszka 已提交
957
    uint8_t tmp_buf[BDRV_SECTOR_SIZE];
B
bellard 已提交
958 959
    int len, nb_sectors, count;
    int64_t sector_num;
960
    int ret;
B
bellard 已提交
961 962 963

    count = count1;
    /* first read to align to sector start */
J
Jan Kiszka 已提交
964
    len = (BDRV_SECTOR_SIZE - offset) & (BDRV_SECTOR_SIZE - 1);
B
bellard 已提交
965 966
    if (len > count)
        len = count;
J
Jan Kiszka 已提交
967
    sector_num = offset >> BDRV_SECTOR_BITS;
B
bellard 已提交
968
    if (len > 0) {
969 970
        if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
            return ret;
J
Jan Kiszka 已提交
971
        memcpy(buf, tmp_buf + (offset & (BDRV_SECTOR_SIZE - 1)), len);
B
bellard 已提交
972 973 974 975 976 977 978 979
        count -= len;
        if (count == 0)
            return count1;
        sector_num++;
        buf += len;
    }

    /* read the sectors "in place" */
J
Jan Kiszka 已提交
980
    nb_sectors = count >> BDRV_SECTOR_BITS;
B
bellard 已提交
981
    if (nb_sectors > 0) {
982 983
        if ((ret = bdrv_read(bs, sector_num, buf, nb_sectors)) < 0)
            return ret;
B
bellard 已提交
984
        sector_num += nb_sectors;
J
Jan Kiszka 已提交
985
        len = nb_sectors << BDRV_SECTOR_BITS;
B
bellard 已提交
986 987 988 989 990 991
        buf += len;
        count -= len;
    }

    /* add data from the last sector */
    if (count > 0) {
992 993
        if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
            return ret;
B
bellard 已提交
994 995 996 997 998
        memcpy(buf, tmp_buf, count);
    }
    return count1;
}

999 1000
int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
                const void *buf, int count1)
B
bellard 已提交
1001
{
J
Jan Kiszka 已提交
1002
    uint8_t tmp_buf[BDRV_SECTOR_SIZE];
B
bellard 已提交
1003 1004
    int len, nb_sectors, count;
    int64_t sector_num;
1005
    int ret;
B
bellard 已提交
1006 1007 1008

    count = count1;
    /* first write to align to sector start */
J
Jan Kiszka 已提交
1009
    len = (BDRV_SECTOR_SIZE - offset) & (BDRV_SECTOR_SIZE - 1);
B
bellard 已提交
1010 1011
    if (len > count)
        len = count;
J
Jan Kiszka 已提交
1012
    sector_num = offset >> BDRV_SECTOR_BITS;
B
bellard 已提交
1013
    if (len > 0) {
1014 1015
        if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
            return ret;
J
Jan Kiszka 已提交
1016
        memcpy(tmp_buf + (offset & (BDRV_SECTOR_SIZE - 1)), buf, len);
1017 1018
        if ((ret = bdrv_write(bs, sector_num, tmp_buf, 1)) < 0)
            return ret;
B
bellard 已提交
1019 1020 1021 1022 1023 1024 1025 1026
        count -= len;
        if (count == 0)
            return count1;
        sector_num++;
        buf += len;
    }

    /* write the sectors "in place" */
J
Jan Kiszka 已提交
1027
    nb_sectors = count >> BDRV_SECTOR_BITS;
B
bellard 已提交
1028
    if (nb_sectors > 0) {
1029 1030
        if ((ret = bdrv_write(bs, sector_num, buf, nb_sectors)) < 0)
            return ret;
B
bellard 已提交
1031
        sector_num += nb_sectors;
J
Jan Kiszka 已提交
1032
        len = nb_sectors << BDRV_SECTOR_BITS;
B
bellard 已提交
1033 1034 1035 1036 1037 1038
        buf += len;
        count -= len;
    }

    /* add data from the last sector */
    if (count > 0) {
1039 1040
        if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
            return ret;
B
bellard 已提交
1041
        memcpy(tmp_buf, buf, count);
1042 1043
        if ((ret = bdrv_write(bs, sector_num, tmp_buf, 1)) < 0)
            return ret;
B
bellard 已提交
1044 1045 1046 1047
    }
    return count1;
}

K
Kevin Wolf 已提交
1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084
/*
 * 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;
    }

    /* No flush needed for cache=writethrough, it uses O_DSYNC */
    if ((bs->open_flags & BDRV_O_CACHE_MASK) != 0) {
        bdrv_flush(bs);
    }

    return 0;
}

/*
 * 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_write_sync(BlockDriverState *bs, int64_t sector_num,
    const uint8_t *buf, int nb_sectors)
{
    return bdrv_pwrite_sync(bs, BDRV_SECTOR_SIZE * sector_num,
        buf, BDRV_SECTOR_SIZE * nb_sectors);
}

B
bellard 已提交
1085 1086 1087 1088 1089 1090
/**
 * Truncate file to 'offset' bytes (needed only for file protocols)
 */
int bdrv_truncate(BlockDriverState *bs, int64_t offset)
{
    BlockDriver *drv = bs->drv;
1091
    int ret;
B
bellard 已提交
1092
    if (!drv)
B
bellard 已提交
1093
        return -ENOMEDIUM;
B
bellard 已提交
1094 1095
    if (!drv->bdrv_truncate)
        return -ENOTSUP;
1096 1097
    if (bs->read_only)
        return -EACCES;
1098 1099 1100 1101 1102
    ret = drv->bdrv_truncate(bs, offset);
    if (ret == 0) {
        ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
    }
    return ret;
B
bellard 已提交
1103 1104 1105 1106 1107 1108 1109 1110 1111
}

/**
 * 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 已提交
1112
        return -ENOMEDIUM;
1113 1114 1115 1116 1117 1118

    /* Fixed size devices use the total_sectors value for speed instead of
       issuing a length query (like lseek) on each call.  Also, legacy block
       drivers don't provide a bdrv_getlength function and must use
       total_sectors. */
    if (!bs->growable || !drv->bdrv_getlength) {
J
Jan Kiszka 已提交
1119
        return bs->total_sectors * BDRV_SECTOR_SIZE;
B
bellard 已提交
1120 1121
    }
    return drv->bdrv_getlength(bs);
B
bellard 已提交
1122 1123
}

B
bellard 已提交
1124
/* return 0 as number of sectors if no device present or error */
1125
void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
B
bellard 已提交
1126
{
B
bellard 已提交
1127 1128 1129 1130 1131
    int64_t length;
    length = bdrv_getlength(bs);
    if (length < 0)
        length = 0;
    else
J
Jan Kiszka 已提交
1132
        length = length >> BDRV_SECTOR_BITS;
B
bellard 已提交
1133
    *nb_sectors_ptr = length;
B
bellard 已提交
1134
}
B
bellard 已提交
1135

1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152
struct partition {
        uint8_t boot_ind;           /* 0x80 - active */
        uint8_t head;               /* starting head */
        uint8_t sector;             /* starting sector */
        uint8_t cyl;                /* starting cylinder */
        uint8_t sys_ind;            /* What partition type */
        uint8_t end_head;           /* end head */
        uint8_t end_sector;         /* end sector */
        uint8_t end_cyl;            /* end cylinder */
        uint32_t start_sect;        /* starting sector counting from 0 */
        uint32_t nr_sects;          /* nr of sectors in partition */
} __attribute__((packed));

/* try to guess the disk logical geometry from the MSDOS partition table. Return 0 if OK, -1 if could not guess */
static int guess_disk_lchs(BlockDriverState *bs,
                           int *pcylinders, int *pheads, int *psectors)
{
1153
    uint8_t buf[BDRV_SECTOR_SIZE];
1154 1155 1156
    int ret, i, heads, sectors, cylinders;
    struct partition *p;
    uint32_t nr_sects;
B
blueswir1 已提交
1157
    uint64_t nb_sectors;
1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196

    bdrv_get_geometry(bs, &nb_sectors);

    ret = bdrv_read(bs, 0, buf, 1);
    if (ret < 0)
        return -1;
    /* test msdos magic */
    if (buf[510] != 0x55 || buf[511] != 0xaa)
        return -1;
    for(i = 0; i < 4; i++) {
        p = ((struct partition *)(buf + 0x1be)) + i;
        nr_sects = le32_to_cpu(p->nr_sects);
        if (nr_sects && p->end_head) {
            /* We make the assumption that the partition terminates on
               a cylinder boundary */
            heads = p->end_head + 1;
            sectors = p->end_sector & 63;
            if (sectors == 0)
                continue;
            cylinders = nb_sectors / (heads * sectors);
            if (cylinders < 1 || cylinders > 16383)
                continue;
            *pheads = heads;
            *psectors = sectors;
            *pcylinders = cylinders;
#if 0
            printf("guessed geometry: LCHS=%d %d %d\n",
                   cylinders, heads, sectors);
#endif
            return 0;
        }
    }
    return -1;
}

void bdrv_guess_geometry(BlockDriverState *bs, int *pcyls, int *pheads, int *psecs)
{
    int translation, lba_detected = 0;
    int cylinders, heads, secs;
B
blueswir1 已提交
1197
    uint64_t nb_sectors;
1198 1199 1200 1201 1202 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 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251

    /* if a geometry hint is available, use it */
    bdrv_get_geometry(bs, &nb_sectors);
    bdrv_get_geometry_hint(bs, &cylinders, &heads, &secs);
    translation = bdrv_get_translation_hint(bs);
    if (cylinders != 0) {
        *pcyls = cylinders;
        *pheads = heads;
        *psecs = secs;
    } else {
        if (guess_disk_lchs(bs, &cylinders, &heads, &secs) == 0) {
            if (heads > 16) {
                /* if heads > 16, it means that a BIOS LBA
                   translation was active, so the default
                   hardware geometry is OK */
                lba_detected = 1;
                goto default_geometry;
            } else {
                *pcyls = cylinders;
                *pheads = heads;
                *psecs = secs;
                /* disable any translation to be in sync with
                   the logical geometry */
                if (translation == BIOS_ATA_TRANSLATION_AUTO) {
                    bdrv_set_translation_hint(bs,
                                              BIOS_ATA_TRANSLATION_NONE);
                }
            }
        } else {
        default_geometry:
            /* if no geometry, use a standard physical disk geometry */
            cylinders = nb_sectors / (16 * 63);

            if (cylinders > 16383)
                cylinders = 16383;
            else if (cylinders < 2)
                cylinders = 2;
            *pcyls = cylinders;
            *pheads = 16;
            *psecs = 63;
            if ((lba_detected == 1) && (translation == BIOS_ATA_TRANSLATION_AUTO)) {
                if ((*pcyls * *pheads) <= 131072) {
                    bdrv_set_translation_hint(bs,
                                              BIOS_ATA_TRANSLATION_LARGE);
                } else {
                    bdrv_set_translation_hint(bs,
                                              BIOS_ATA_TRANSLATION_LBA);
                }
            }
        }
        bdrv_set_geometry_hint(bs, *pcyls, *pheads, *psecs);
    }
}

1252
void bdrv_set_geometry_hint(BlockDriverState *bs,
B
bellard 已提交
1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266
                            int cyls, int heads, int secs)
{
    bs->cyls = cyls;
    bs->heads = heads;
    bs->secs = secs;
}

void bdrv_set_type_hint(BlockDriverState *bs, int type)
{
    bs->type = type;
    bs->removable = ((type == BDRV_TYPE_CDROM ||
                      type == BDRV_TYPE_FLOPPY));
}

B
bellard 已提交
1267 1268 1269 1270 1271
void bdrv_set_translation_hint(BlockDriverState *bs, int translation)
{
    bs->translation = translation;
}

1272
void bdrv_get_geometry_hint(BlockDriverState *bs,
B
bellard 已提交
1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284
                            int *pcyls, int *pheads, int *psecs)
{
    *pcyls = bs->cyls;
    *pheads = bs->heads;
    *psecs = bs->secs;
}

int bdrv_get_type_hint(BlockDriverState *bs)
{
    return bs->type;
}

B
bellard 已提交
1285 1286 1287 1288 1289
int bdrv_get_translation_hint(BlockDriverState *bs)
{
    return bs->translation;
}

1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301
void bdrv_set_on_error(BlockDriverState *bs, BlockErrorAction on_read_error,
                       BlockErrorAction on_write_error)
{
    bs->on_read_error = on_read_error;
    bs->on_write_error = on_write_error;
}

BlockErrorAction bdrv_get_on_error(BlockDriverState *bs, int is_read)
{
    return is_read ? bs->on_read_error : bs->on_write_error;
}

1302 1303 1304 1305 1306 1307 1308 1309
void bdrv_set_removable(BlockDriverState *bs, int removable)
{
    bs->removable = removable;
    if (removable && bs == bs_snapshots) {
        bs_snapshots = NULL;
    }
}

B
bellard 已提交
1310 1311 1312 1313 1314 1315 1316 1317 1318 1319
int bdrv_is_removable(BlockDriverState *bs)
{
    return bs->removable;
}

int bdrv_is_read_only(BlockDriverState *bs)
{
    return bs->read_only;
}

1320 1321 1322 1323 1324
int bdrv_is_sg(BlockDriverState *bs)
{
    return bs->sg;
}

1325 1326 1327 1328 1329
int bdrv_enable_write_cache(BlockDriverState *bs)
{
    return bs->enable_write_cache;
}

B
bellard 已提交
1330
/* XXX: no longer used */
1331
void bdrv_set_change_cb(BlockDriverState *bs,
B
bellard 已提交
1332 1333 1334 1335 1336 1337
                        void (*change_cb)(void *opaque), void *opaque)
{
    bs->change_cb = change_cb;
    bs->change_opaque = opaque;
}

B
bellard 已提交
1338 1339 1340 1341 1342 1343 1344
int bdrv_is_encrypted(BlockDriverState *bs)
{
    if (bs->backing_hd && bs->backing_hd->encrypted)
        return 1;
    return bs->encrypted;
}

1345 1346 1347 1348 1349 1350 1351 1352 1353
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 已提交
1354 1355 1356 1357 1358 1359 1360 1361 1362 1363
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;
    }
1364 1365 1366 1367 1368
    if (!bs->encrypted) {
        return -EINVAL;
    } else if (!bs->drv || !bs->drv->bdrv_set_key) {
        return -ENOMEDIUM;
    }
1369
    ret = bs->drv->bdrv_set_key(bs, key);
1370 1371 1372 1373 1374 1375 1376 1377 1378
    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 */
        bs->media_changed = 1;
        if (bs->change_cb)
            bs->change_cb(bs->change_opaque);
    }
1379
    return ret;
B
bellard 已提交
1380 1381 1382 1383
}

void bdrv_get_format(BlockDriverState *bs, char *buf, int buf_size)
{
B
bellard 已提交
1384
    if (!bs->drv) {
B
bellard 已提交
1385 1386 1387 1388 1389 1390
        buf[0] = '\0';
    } else {
        pstrcpy(buf, buf_size, bs->drv->format_name);
    }
}

1391
void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
B
bellard 已提交
1392 1393 1394 1395
                         void *opaque)
{
    BlockDriver *drv;

1396
    QLIST_FOREACH(drv, &bdrv_drivers, list) {
B
bellard 已提交
1397 1398 1399 1400
        it(opaque, drv->format_name);
    }
}

B
bellard 已提交
1401 1402 1403 1404
BlockDriverState *bdrv_find(const char *name)
{
    BlockDriverState *bs;

1405 1406
    QTAILQ_FOREACH(bs, &bdrv_states, list) {
        if (!strcmp(name, bs->device_name)) {
B
bellard 已提交
1407
            return bs;
1408
        }
B
bellard 已提交
1409 1410 1411 1412
    }
    return NULL;
}

M
Markus Armbruster 已提交
1413 1414 1415 1416 1417 1418 1419 1420
BlockDriverState *bdrv_next(BlockDriverState *bs)
{
    if (!bs) {
        return QTAILQ_FIRST(&bdrv_states);
    }
    return QTAILQ_NEXT(bs, list);
}

1421
void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs), void *opaque)
B
bellard 已提交
1422 1423 1424
{
    BlockDriverState *bs;

1425
    QTAILQ_FOREACH(bs, &bdrv_states, list) {
1426
        it(opaque, bs);
B
bellard 已提交
1427 1428 1429
    }
}

B
bellard 已提交
1430 1431 1432 1433 1434
const char *bdrv_get_device_name(BlockDriverState *bs)
{
    return bs->device_name;
}

P
pbrook 已提交
1435 1436
void bdrv_flush(BlockDriverState *bs)
{
1437 1438 1439 1440
    if (bs->open_flags & BDRV_O_NO_FLUSH) {
        return;
    }

1441
    if (bs->drv && bs->drv->bdrv_flush)
P
pbrook 已提交
1442 1443 1444
        bs->drv->bdrv_flush(bs);
}

A
aliguori 已提交
1445 1446 1447 1448
void bdrv_flush_all(void)
{
    BlockDriverState *bs;

1449 1450 1451
    QTAILQ_FOREACH(bs, &bdrv_states, list) {
        if (bs->drv && !bdrv_is_read_only(bs) &&
            (!bdrv_is_removable(bs) || bdrv_is_inserted(bs))) {
A
aliguori 已提交
1452
            bdrv_flush(bs);
1453 1454
        }
    }
A
aliguori 已提交
1455 1456
}

K
Kevin Wolf 已提交
1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469
int bdrv_has_zero_init(BlockDriverState *bs)
{
    assert(bs->drv);

    if (bs->drv->no_zero_init) {
        return 0;
    } else if (bs->file) {
        return bdrv_has_zero_init(bs->file);
    }

    return 1;
}

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
/*
 * 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.
 *
 * '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.
 *
 * 'nb_sectors' is the max value 'pnum' should be set to.
 */
int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
	int *pnum)
{
    int64_t n;
    if (!bs->drv->bdrv_is_allocated) {
        if (sector_num >= bs->total_sectors) {
            *pnum = 0;
            return 0;
        }
        n = bs->total_sectors - sector_num;
        *pnum = (n < nb_sectors) ? (n) : (nb_sectors);
        return 1;
    }
    return bs->drv->bdrv_is_allocated(bs, sector_num, nb_sectors, pnum);
}

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
void bdrv_mon_event(const BlockDriverState *bdrv,
                    BlockMonEventAction action, int is_read)
{
    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");
    monitor_protocol_event(QEVENT_BLOCK_IO_ERROR, data);

    qobject_decref(data);
}

1526
static void bdrv_print_dict(QObject *obj, void *opaque)
B
bellard 已提交
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
    QDict *bs_dict;
    Monitor *mon = opaque;

    bs_dict = qobject_to_qdict(obj);

    monitor_printf(mon, "%s: type=%s removable=%d",
                        qdict_get_str(bs_dict, "device"),
                        qdict_get_str(bs_dict, "type"),
                        qdict_get_bool(bs_dict, "removable"));

    if (qdict_get_bool(bs_dict, "removable")) {
        monitor_printf(mon, " locked=%d", qdict_get_bool(bs_dict, "locked"));
    }

    if (qdict_haskey(bs_dict, "inserted")) {
        QDict *qdict = qobject_to_qdict(qdict_get(bs_dict, "inserted"));

        monitor_printf(mon, " file=");
        monitor_print_filename(mon, qdict_get_str(qdict, "file"));
        if (qdict_haskey(qdict, "backing_file")) {
            monitor_printf(mon, " backing_file=");
            monitor_print_filename(mon, qdict_get_str(qdict, "backing_file"));
        }
        monitor_printf(mon, " ro=%d drv=%s encrypted=%d",
                            qdict_get_bool(qdict, "ro"),
                            qdict_get_str(qdict, "drv"),
                            qdict_get_bool(qdict, "encrypted"));
    } else {
        monitor_printf(mon, " [not inserted]");
    }

    monitor_printf(mon, "\n");
}

void bdrv_info_print(Monitor *mon, const QObject *data)
{
    qlist_iter(qobject_to_qlist(data), bdrv_print_dict, mon);
}

void bdrv_info(Monitor *mon, QObject **ret_data)
{
    QList *bs_list;
B
bellard 已提交
1570 1571
    BlockDriverState *bs;

1572 1573
    bs_list = qlist_new();

1574
    QTAILQ_FOREACH(bs, &bdrv_states, list) {
1575 1576 1577
        QObject *bs_obj;
        const char *type = "unknown";

B
bellard 已提交
1578 1579
        switch(bs->type) {
        case BDRV_TYPE_HD:
1580
            type = "hd";
B
bellard 已提交
1581 1582
            break;
        case BDRV_TYPE_CDROM:
1583
            type = "cdrom";
B
bellard 已提交
1584 1585
            break;
        case BDRV_TYPE_FLOPPY:
1586
            type = "floppy";
B
bellard 已提交
1587 1588
            break;
        }
1589 1590 1591 1592 1593 1594

        bs_obj = qobject_from_jsonf("{ 'device': %s, 'type': %s, "
                                    "'removable': %i, 'locked': %i }",
                                    bs->device_name, type, bs->removable,
                                    bs->locked);

B
bellard 已提交
1595
        if (bs->drv) {
1596 1597 1598 1599 1600 1601 1602 1603
            QObject *obj;
            QDict *bs_dict = qobject_to_qdict(bs_obj);

            obj = qobject_from_jsonf("{ 'file': %s, 'ro': %i, 'drv': %s, "
                                     "'encrypted': %i }",
                                     bs->filename, bs->read_only,
                                     bs->drv->format_name,
                                     bdrv_is_encrypted(bs));
1604
            if (bs->backing_file[0] != '\0') {
1605 1606 1607
                QDict *qdict = qobject_to_qdict(obj);
                qdict_put(qdict, "backing_file",
                          qstring_from_str(bs->backing_file));
A
aliguori 已提交
1608
            }
1609 1610

            qdict_put_obj(bs_dict, "inserted", obj);
B
bellard 已提交
1611
        }
1612
        qlist_append_obj(bs_list, bs_obj);
B
bellard 已提交
1613
    }
1614 1615

    *ret_data = QOBJECT(bs_list);
B
bellard 已提交
1616
}
1617

1618
static void bdrv_stats_iter(QObject *data, void *opaque)
1619
{
1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642
    QDict *qdict;
    Monitor *mon = opaque;

    qdict = qobject_to_qdict(data);
    monitor_printf(mon, "%s:", qdict_get_str(qdict, "device"));

    qdict = qobject_to_qdict(qdict_get(qdict, "stats"));
    monitor_printf(mon, " rd_bytes=%" PRId64
                        " wr_bytes=%" PRId64
                        " rd_operations=%" PRId64
                        " wr_operations=%" PRId64
                        "\n",
                        qdict_get_int(qdict, "rd_bytes"),
                        qdict_get_int(qdict, "wr_bytes"),
                        qdict_get_int(qdict, "rd_operations"),
                        qdict_get_int(qdict, "wr_operations"));
}

void bdrv_stats_print(Monitor *mon, const QObject *data)
{
    qlist_iter(qobject_to_qlist(data), bdrv_stats_iter, mon);
}

1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656
static QObject* bdrv_info_stats_bs(BlockDriverState *bs)
{
    QObject *res;
    QDict *dict;

    res = qobject_from_jsonf("{ 'stats': {"
                             "'rd_bytes': %" PRId64 ","
                             "'wr_bytes': %" PRId64 ","
                             "'rd_operations': %" PRId64 ","
                             "'wr_operations': %" PRId64 ","
                             "'wr_highest_offset': %" PRId64
                             "} }",
                             bs->rd_bytes, bs->wr_bytes,
                             bs->rd_ops, bs->wr_ops,
1657 1658
                             bs->wr_highest_sector *
                             (uint64_t)BDRV_SECTOR_SIZE);
1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672
    dict  = qobject_to_qdict(res);

    if (*bs->device_name) {
        qdict_put(dict, "device", qstring_from_str(bs->device_name));
    }

    if (bs->file) {
        QObject *parent = bdrv_info_stats_bs(bs->file);
        qdict_put_obj(dict, "parent", parent);
    }

    return res;
}

1673 1674 1675 1676
void bdrv_info_stats(Monitor *mon, QObject **ret_data)
{
    QObject *obj;
    QList *devices;
1677 1678
    BlockDriverState *bs;

1679 1680
    devices = qlist_new();

1681
    QTAILQ_FOREACH(bs, &bdrv_states, list) {
1682
        obj = bdrv_info_stats_bs(bs);
1683
        qlist_append_obj(devices, obj);
1684
    }
1685 1686

    *ret_data = QOBJECT(devices);
1687
}
B
bellard 已提交
1688

1689 1690 1691 1692 1693 1694 1695 1696 1697 1698
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;
}

1699
void bdrv_get_backing_filename(BlockDriverState *bs,
B
bellard 已提交
1700 1701
                               char *filename, int filename_size)
{
K
Kevin Wolf 已提交
1702
    if (!bs->backing_file) {
B
bellard 已提交
1703 1704 1705 1706 1707 1708
        pstrcpy(filename, filename_size, "");
    } else {
        pstrcpy(filename, filename_size, bs->backing_file);
    }
}

1709
int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
B
bellard 已提交
1710 1711 1712 1713
                          const uint8_t *buf, int nb_sectors)
{
    BlockDriver *drv = bs->drv;
    if (!drv)
B
bellard 已提交
1714
        return -ENOMEDIUM;
B
bellard 已提交
1715 1716
    if (!drv->bdrv_write_compressed)
        return -ENOTSUP;
K
Kevin Wolf 已提交
1717 1718
    if (bdrv_check_request(bs, sector_num, nb_sectors))
        return -EIO;
1719

1720
    if (bs->dirty_bitmap) {
1721 1722
        set_dirty_bitmap(bs, sector_num, nb_sectors, 1);
    }
1723

B
bellard 已提交
1724 1725
    return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);
}
1726

B
bellard 已提交
1727 1728 1729 1730
int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
{
    BlockDriver *drv = bs->drv;
    if (!drv)
B
bellard 已提交
1731
        return -ENOMEDIUM;
B
bellard 已提交
1732 1733 1734 1735 1736 1737
    if (!drv->bdrv_get_info)
        return -ENOTSUP;
    memset(bdi, 0, sizeof(*bdi));
    return drv->bdrv_get_info(bs, bdi);
}

1738 1739
int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
                      int64_t pos, int size)
1740 1741 1742 1743
{
    BlockDriver *drv = bs->drv;
    if (!drv)
        return -ENOMEDIUM;
1744 1745 1746 1747 1748
    if (drv->bdrv_save_vmstate)
        return drv->bdrv_save_vmstate(bs, buf, pos, size);
    if (bs->file)
        return bdrv_save_vmstate(bs->file, buf, pos, size);
    return -ENOTSUP;
1749 1750
}

1751 1752
int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
                      int64_t pos, int size)
1753 1754 1755 1756
{
    BlockDriver *drv = bs->drv;
    if (!drv)
        return -ENOMEDIUM;
1757 1758 1759 1760 1761
    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;
1762 1763
}

K
Kevin Wolf 已提交
1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775
void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event)
{
    BlockDriver *drv = bs->drv;

    if (!drv || !drv->bdrv_debug_event) {
        return;
    }

    return drv->bdrv_debug_event(bs, event);

}

B
bellard 已提交
1776 1777 1778
/**************************************************************/
/* handling of snapshots */

1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795
int bdrv_can_snapshot(BlockDriverState *bs)
{
    BlockDriver *drv = bs->drv;
    if (!drv || bdrv_is_removable(bs) || bdrv_is_read_only(bs)) {
        return 0;
    }

    if (!drv->bdrv_snapshot_create) {
        if (bs->file != NULL) {
            return bdrv_can_snapshot(bs->file);
        }
        return 0;
    }

    return 1;
}

1796 1797 1798 1799
BlockDriverState *bdrv_snapshots(void)
{
    BlockDriverState *bs;

1800
    if (bs_snapshots) {
1801
        return bs_snapshots;
1802
    }
1803 1804 1805 1806

    bs = NULL;
    while ((bs = bdrv_next(bs))) {
        if (bdrv_can_snapshot(bs)) {
1807 1808
            bs_snapshots = bs;
            return bs;
1809 1810 1811 1812 1813
        }
    }
    return NULL;
}

1814
int bdrv_snapshot_create(BlockDriverState *bs,
B
bellard 已提交
1815 1816 1817 1818
                         QEMUSnapshotInfo *sn_info)
{
    BlockDriver *drv = bs->drv;
    if (!drv)
B
bellard 已提交
1819
        return -ENOMEDIUM;
1820 1821 1822 1823 1824
    if (drv->bdrv_snapshot_create)
        return drv->bdrv_snapshot_create(bs, sn_info);
    if (bs->file)
        return bdrv_snapshot_create(bs->file, sn_info);
    return -ENOTSUP;
B
bellard 已提交
1825 1826
}

1827
int bdrv_snapshot_goto(BlockDriverState *bs,
B
bellard 已提交
1828 1829 1830
                       const char *snapshot_id)
{
    BlockDriver *drv = bs->drv;
1831 1832
    int ret, open_ret;

B
bellard 已提交
1833
    if (!drv)
B
bellard 已提交
1834
        return -ENOMEDIUM;
1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850
    if (drv->bdrv_snapshot_goto)
        return drv->bdrv_snapshot_goto(bs, snapshot_id);

    if (bs->file) {
        drv->bdrv_close(bs);
        ret = bdrv_snapshot_goto(bs->file, snapshot_id);
        open_ret = drv->bdrv_open(bs, bs->open_flags);
        if (open_ret < 0) {
            bdrv_delete(bs->file);
            bs->drv = NULL;
            return open_ret;
        }
        return ret;
    }

    return -ENOTSUP;
B
bellard 已提交
1851 1852 1853 1854 1855 1856
}

int bdrv_snapshot_delete(BlockDriverState *bs, const char *snapshot_id)
{
    BlockDriver *drv = bs->drv;
    if (!drv)
B
bellard 已提交
1857
        return -ENOMEDIUM;
1858 1859 1860 1861 1862
    if (drv->bdrv_snapshot_delete)
        return drv->bdrv_snapshot_delete(bs, snapshot_id);
    if (bs->file)
        return bdrv_snapshot_delete(bs->file, snapshot_id);
    return -ENOTSUP;
B
bellard 已提交
1863 1864
}

1865
int bdrv_snapshot_list(BlockDriverState *bs,
B
bellard 已提交
1866 1867 1868 1869
                       QEMUSnapshotInfo **psn_info)
{
    BlockDriver *drv = bs->drv;
    if (!drv)
B
bellard 已提交
1870
        return -ENOMEDIUM;
1871 1872 1873 1874 1875
    if (drv->bdrv_snapshot_list)
        return drv->bdrv_snapshot_list(bs, psn_info);
    if (bs->file)
        return bdrv_snapshot_list(bs->file, psn_info);
    return -ENOTSUP;
B
bellard 已提交
1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891
}

#define NB_SUFFIXES 4

char *get_human_readable_size(char *buf, int buf_size, int64_t size)
{
    static const char suffixes[NB_SUFFIXES] = "KMGT";
    int64_t base;
    int i;

    if (size <= 999) {
        snprintf(buf, buf_size, "%" PRId64, size);
    } else {
        base = 1024;
        for(i = 0; i < NB_SUFFIXES; i++) {
            if (size < (10 * base)) {
1892
                snprintf(buf, buf_size, "%0.1f%c",
B
bellard 已提交
1893 1894 1895 1896
                         (double)size / base,
                         suffixes[i]);
                break;
            } else if (size < (1000 * base) || i == (NB_SUFFIXES - 1)) {
1897
                snprintf(buf, buf_size, "%" PRId64 "%c",
B
bellard 已提交
1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910
                         ((size + (base >> 1)) / base),
                         suffixes[i]);
                break;
            }
            base = base * 1024;
        }
    }
    return buf;
}

char *bdrv_snapshot_dump(char *buf, int buf_size, QEMUSnapshotInfo *sn)
{
    char buf1[128], date_buf[128], clock_buf[128];
1911 1912 1913
#ifdef _WIN32
    struct tm *ptm;
#else
B
bellard 已提交
1914
    struct tm tm;
1915
#endif
B
bellard 已提交
1916 1917 1918 1919
    time_t ti;
    int64_t secs;

    if (!sn) {
1920 1921
        snprintf(buf, buf_size,
                 "%-10s%-20s%7s%20s%15s",
B
bellard 已提交
1922 1923 1924
                 "ID", "TAG", "VM SIZE", "DATE", "VM CLOCK");
    } else {
        ti = sn->date_sec;
1925 1926 1927 1928 1929
#ifdef _WIN32
        ptm = localtime(&ti);
        strftime(date_buf, sizeof(date_buf),
                 "%Y-%m-%d %H:%M:%S", ptm);
#else
B
bellard 已提交
1930 1931 1932
        localtime_r(&ti, &tm);
        strftime(date_buf, sizeof(date_buf),
                 "%Y-%m-%d %H:%M:%S", &tm);
1933
#endif
B
bellard 已提交
1934 1935 1936 1937 1938
        secs = sn->vm_clock_nsec / 1000000000;
        snprintf(clock_buf, sizeof(clock_buf),
                 "%02d:%02d:%02d.%03d",
                 (int)(secs / 3600),
                 (int)((secs / 60) % 60),
1939
                 (int)(secs % 60),
B
bellard 已提交
1940 1941
                 (int)((sn->vm_clock_nsec / 1000000) % 1000));
        snprintf(buf, buf_size,
1942
                 "%-10s%-20s%7s%20s%15s",
B
bellard 已提交
1943 1944 1945 1946 1947 1948 1949 1950
                 sn->id_str, sn->name,
                 get_human_readable_size(buf1, sizeof(buf1), sn->vm_state_size),
                 date_buf,
                 clock_buf);
    }
    return buf;
}

B
bellard 已提交
1951

B
bellard 已提交
1952
/**************************************************************/
B
bellard 已提交
1953
/* async I/Os */
B
bellard 已提交
1954

1955
BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
1956
                                 QEMUIOVector *qiov, int nb_sectors,
1957
                                 BlockDriverCompletionFunc *cb, void *opaque)
B
bellard 已提交
1958 1959
{
    BlockDriver *drv = bs->drv;
1960
    BlockDriverAIOCB *ret;
B
bellard 已提交
1961

B
bellard 已提交
1962
    if (!drv)
1963
        return NULL;
1964 1965
    if (bdrv_check_request(bs, sector_num, nb_sectors))
        return NULL;
1966

1967 1968
    ret = drv->bdrv_aio_readv(bs, sector_num, qiov, nb_sectors,
                              cb, opaque);
1969 1970 1971

    if (ret) {
	/* Update stats even though technically transfer has not happened. */
J
Jan Kiszka 已提交
1972
	bs->rd_bytes += (unsigned) nb_sectors * BDRV_SECTOR_SIZE;
1973 1974 1975 1976
	bs->rd_ops ++;
    }

    return ret;
B
bellard 已提交
1977 1978
}

1979 1980 1981
BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
                                  QEMUIOVector *qiov, int nb_sectors,
                                  BlockDriverCompletionFunc *cb, void *opaque)
B
bellard 已提交
1982
{
B
bellard 已提交
1983
    BlockDriver *drv = bs->drv;
1984
    BlockDriverAIOCB *ret;
B
bellard 已提交
1985

B
bellard 已提交
1986
    if (!drv)
1987
        return NULL;
B
bellard 已提交
1988
    if (bs->read_only)
1989
        return NULL;
1990 1991
    if (bdrv_check_request(bs, sector_num, nb_sectors))
        return NULL;
B
bellard 已提交
1992

1993
    if (bs->dirty_bitmap) {
1994 1995
        set_dirty_bitmap(bs, sector_num, nb_sectors, 1);
    }
1996

1997 1998
    ret = drv->bdrv_aio_writev(bs, sector_num, qiov, nb_sectors,
                               cb, opaque);
1999 2000

    if (ret) {
2001 2002 2003 2004 2005 2006
        /* Update stats even though technically transfer has not happened. */
        bs->wr_bytes += (unsigned) nb_sectors * BDRV_SECTOR_SIZE;
        bs->wr_ops ++;
        if (bs->wr_highest_sector < sector_num + nb_sectors - 1) {
            bs->wr_highest_sector = sector_num + nb_sectors - 1;
        }
2007 2008 2009
    }

    return ret;
B
bellard 已提交
2010 2011
}

K
Kevin Wolf 已提交
2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030

typedef struct MultiwriteCB {
    int error;
    int num_requests;
    int num_callbacks;
    struct {
        BlockDriverCompletionFunc *cb;
        void *opaque;
        QEMUIOVector *free_qiov;
        void *free_buf;
    } 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);
2031 2032 2033
        if (mcb->callbacks[i].free_qiov) {
            qemu_iovec_destroy(mcb->callbacks[i].free_qiov);
        }
K
Kevin Wolf 已提交
2034
        qemu_free(mcb->callbacks[i].free_qiov);
2035
        qemu_vfree(mcb->callbacks[i].free_buf);
K
Kevin Wolf 已提交
2036 2037 2038 2039 2040 2041 2042
    }
}

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

2043
    if (ret < 0 && !mcb->error) {
K
Kevin Wolf 已提交
2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058
        mcb->error = ret;
        multiwrite_user_cb(mcb);
    }

    mcb->num_requests--;
    if (mcb->num_requests == 0) {
        if (mcb->error == 0) {
            multiwrite_user_cb(mcb);
        }
        qemu_free(mcb);
    }
}

static int multiwrite_req_compare(const void *a, const void *b)
{
2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071
    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 已提交
2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106
}

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

        // This handles the cases that are valid for all block drivers, namely
        // exactly sequential writes and overlapping writes.
        if (reqs[i].sector <= oldreq_last) {
            merge = 1;
        }

        // The block driver may decide that it makes sense to combine requests
        // even if there is a gap of some sectors between them. In this case,
        // the gap is filled with zeros (therefore only applicable for yet
        // unused space in format like qcow2).
        if (!merge && bs->drv->bdrv_merge_requests) {
            merge = bs->drv->bdrv_merge_requests(bs, &reqs[outidx], &reqs[i]);
        }

2107 2108 2109 2110
        if (reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1 > IOV_MAX) {
            merge = 0;
        }

K
Kevin Wolf 已提交
2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133
        if (merge) {
            size_t size;
            QEMUIOVector *qiov = qemu_mallocz(sizeof(*qiov));
            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;
            qemu_iovec_concat(qiov, reqs[outidx].qiov, size);

            // We might need to add some zeros between the two requests
            if (reqs[i].sector > oldreq_last) {
                size_t zero_bytes = (reqs[i].sector - oldreq_last) << 9;
                uint8_t *buf = qemu_blockalign(bs, zero_bytes);
                memset(buf, 0, zero_bytes);
                qemu_iovec_add(qiov, buf, zero_bytes);
                mcb->callbacks[i].free_buf = buf;
            }

            // Add the second request
            qemu_iovec_concat(qiov, reqs[i].qiov, reqs[i].qiov->size);

2134
            reqs[outidx].nb_sectors = qiov->size >> 9;
K
Kevin Wolf 已提交
2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195
            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)
{
    BlockDriverAIOCB *acb;
    MultiwriteCB *mcb;
    int i;

    if (num_reqs == 0) {
        return 0;
    }

    // Create MultiwriteCB structure
    mcb = qemu_mallocz(sizeof(*mcb) + num_reqs * sizeof(*mcb->callbacks));
    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);

    // Run the aio requests
    for (i = 0; i < num_reqs; i++) {
        acb = bdrv_aio_writev(bs, reqs[i].sector, reqs[i].qiov,
            reqs[i].nb_sectors, multiwrite_cb, mcb);

        if (acb == NULL) {
            // We can only fail the whole thing if no request has been
            // submitted yet. Otherwise we'll wait for the submitted AIOs to
            // complete and report the error in the callback.
            if (mcb->num_requests == 0) {
2196
                reqs[i].error = -EIO;
K
Kevin Wolf 已提交
2197 2198
                goto fail;
            } else {
2199 2200
                mcb->num_requests++;
                multiwrite_cb(mcb, -EIO);
K
Kevin Wolf 已提交
2201 2202 2203 2204 2205 2206 2207 2208 2209 2210
                break;
            }
        } else {
            mcb->num_requests++;
        }
    }

    return 0;

fail:
B
Bruce Rogers 已提交
2211
    qemu_free(mcb);
K
Kevin Wolf 已提交
2212 2213 2214
    return -1;
}

2215 2216 2217 2218 2219
BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs,
        BlockDriverCompletionFunc *cb, void *opaque)
{
    BlockDriver *drv = bs->drv;

2220 2221 2222 2223
    if (bs->open_flags & BDRV_O_NO_FLUSH) {
        return bdrv_aio_noop_em(bs, cb, opaque);
    }

2224 2225 2226 2227 2228
    if (!drv)
        return NULL;
    return drv->bdrv_aio_flush(bs, cb, opaque);
}

B
bellard 已提交
2229 2230
void bdrv_aio_cancel(BlockDriverAIOCB *acb)
{
2231
    acb->pool->cancel(acb);
B
bellard 已提交
2232 2233
}

2234

B
bellard 已提交
2235 2236 2237
/**************************************************************/
/* async block device emulation */

2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249
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)
{
2250 2251
    BlockDriverAIOCBSync *acb =
        container_of(blockacb, BlockDriverAIOCBSync, common);
2252
    qemu_bh_delete(acb->bh);
A
Avi Kivity 已提交
2253
    acb->bh = NULL;
2254 2255 2256 2257 2258 2259 2260 2261
    qemu_aio_release(acb);
}

static AIOPool bdrv_em_aio_pool = {
    .aiocb_size         = sizeof(BlockDriverAIOCBSync),
    .cancel             = bdrv_aio_cancel_em,
};

2262
static void bdrv_aio_bh_cb(void *opaque)
B
bellard 已提交
2263
{
2264
    BlockDriverAIOCBSync *acb = opaque;
2265 2266 2267

    if (!acb->is_write)
        qemu_iovec_from_buffer(acb->qiov, acb->bounce, acb->qiov->size);
2268
    qemu_vfree(acb->bounce);
2269
    acb->common.cb(acb->common.opaque, acb->ret);
2270
    qemu_bh_delete(acb->bh);
A
Avi Kivity 已提交
2271
    acb->bh = NULL;
2272
    qemu_aio_release(acb);
B
bellard 已提交
2273
}
2274

2275 2276 2277 2278 2279 2280 2281 2282
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 已提交
2283
{
2284 2285
    BlockDriverAIOCBSync *acb;

2286
    acb = qemu_aio_get(&bdrv_em_aio_pool, bs, cb, opaque);
2287 2288
    acb->is_write = is_write;
    acb->qiov = qiov;
2289
    acb->bounce = qemu_blockalign(bs, qiov->size);
2290

2291 2292
    if (!acb->bh)
        acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
2293 2294 2295 2296 2297 2298 2299 2300

    if (is_write) {
        qemu_iovec_to_buffer(acb->qiov, acb->bounce);
        acb->ret = bdrv_write(bs, sector_num, acb->bounce, nb_sectors);
    } else {
        acb->ret = bdrv_read(bs, sector_num, acb->bounce, nb_sectors);
    }

2301
    qemu_bh_schedule(acb->bh);
2302

2303
    return &acb->common;
2304 2305
}

2306 2307
static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
        int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
2308
        BlockDriverCompletionFunc *cb, void *opaque)
2309
{
2310 2311
    return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 0);
}
B
bellard 已提交
2312

2313 2314 2315 2316 2317
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);
2318 2319
}

2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338
static BlockDriverAIOCB *bdrv_aio_flush_em(BlockDriverState *bs,
        BlockDriverCompletionFunc *cb, void *opaque)
{
    BlockDriverAIOCBSync *acb;

    acb = qemu_aio_get(&bdrv_em_aio_pool, bs, cb, opaque);
    acb->is_write = 1; /* don't bounce in the completion hadler */
    acb->qiov = NULL;
    acb->bounce = NULL;
    acb->ret = 0;

    if (!acb->bh)
        acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);

    bdrv_flush(bs);
    qemu_bh_schedule(acb->bh);
    return &acb->common;
}

2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357
static BlockDriverAIOCB *bdrv_aio_noop_em(BlockDriverState *bs,
        BlockDriverCompletionFunc *cb, void *opaque)
{
    BlockDriverAIOCBSync *acb;

    acb = qemu_aio_get(&bdrv_em_aio_pool, bs, cb, opaque);
    acb->is_write = 1; /* don't bounce in the completion handler */
    acb->qiov = NULL;
    acb->bounce = NULL;
    acb->ret = 0;

    if (!acb->bh) {
        acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
    }

    qemu_bh_schedule(acb->bh);
    return &acb->common;
}

B
bellard 已提交
2358 2359
/**************************************************************/
/* sync block device emulation */
B
bellard 已提交
2360

B
bellard 已提交
2361 2362 2363
static void bdrv_rw_em_cb(void *opaque, int ret)
{
    *(int *)opaque = ret;
B
bellard 已提交
2364 2365
}

B
bellard 已提交
2366 2367
#define NOT_DONE 0x7fffffff

2368
static int bdrv_read_em(BlockDriverState *bs, int64_t sector_num,
B
bellard 已提交
2369
                        uint8_t *buf, int nb_sectors)
P
pbrook 已提交
2370
{
2371 2372
    int async_ret;
    BlockDriverAIOCB *acb;
2373 2374
    struct iovec iov;
    QEMUIOVector qiov;
B
bellard 已提交
2375

2376 2377
    async_context_push();

B
bellard 已提交
2378
    async_ret = NOT_DONE;
2379
    iov.iov_base = (void *)buf;
2380
    iov.iov_len = nb_sectors * BDRV_SECTOR_SIZE;
2381 2382 2383
    qemu_iovec_init_external(&qiov, &iov, 1);
    acb = bdrv_aio_readv(bs, sector_num, &qiov, nb_sectors,
        bdrv_rw_em_cb, &async_ret);
2384 2385 2386 2387
    if (acb == NULL) {
        async_ret = -1;
        goto fail;
    }
2388

B
bellard 已提交
2389 2390 2391
    while (async_ret == NOT_DONE) {
        qemu_aio_wait();
    }
2392

2393 2394 2395

fail:
    async_context_pop();
B
bellard 已提交
2396
    return async_ret;
P
pbrook 已提交
2397 2398
}

B
bellard 已提交
2399 2400 2401
static int bdrv_write_em(BlockDriverState *bs, int64_t sector_num,
                         const uint8_t *buf, int nb_sectors)
{
2402 2403
    int async_ret;
    BlockDriverAIOCB *acb;
2404 2405
    struct iovec iov;
    QEMUIOVector qiov;
B
bellard 已提交
2406

2407 2408
    async_context_push();

B
bellard 已提交
2409
    async_ret = NOT_DONE;
2410
    iov.iov_base = (void *)buf;
2411
    iov.iov_len = nb_sectors * BDRV_SECTOR_SIZE;
2412 2413 2414
    qemu_iovec_init_external(&qiov, &iov, 1);
    acb = bdrv_aio_writev(bs, sector_num, &qiov, nb_sectors,
        bdrv_rw_em_cb, &async_ret);
2415 2416 2417 2418
    if (acb == NULL) {
        async_ret = -1;
        goto fail;
    }
B
bellard 已提交
2419 2420 2421
    while (async_ret == NOT_DONE) {
        qemu_aio_wait();
    }
2422 2423 2424

fail:
    async_context_pop();
B
bellard 已提交
2425 2426
    return async_ret;
}
B
bellard 已提交
2427 2428 2429

void bdrv_init(void)
{
2430
    module_call_init(MODULE_INIT_BLOCK);
B
bellard 已提交
2431
}
2432

2433 2434 2435 2436 2437 2438
void bdrv_init_with_whitelist(void)
{
    use_bdrv_whitelist = 1;
    bdrv_init();
}

2439 2440
void *qemu_aio_get(AIOPool *pool, BlockDriverState *bs,
                   BlockDriverCompletionFunc *cb, void *opaque)
2441 2442 2443
{
    BlockDriverAIOCB *acb;

2444 2445 2446
    if (pool->free_aiocb) {
        acb = pool->free_aiocb;
        pool->free_aiocb = acb->next;
2447
    } else {
2448 2449
        acb = qemu_mallocz(pool->aiocb_size);
        acb->pool = pool;
2450 2451 2452 2453 2454 2455 2456 2457 2458
    }
    acb->bs = bs;
    acb->cb = cb;
    acb->opaque = opaque;
    return acb;
}

void qemu_aio_release(void *p)
{
2459 2460 2461 2462
    BlockDriverAIOCB *acb = (BlockDriverAIOCB *)p;
    AIOPool *pool = acb->pool;
    acb->next = pool->free_aiocb;
    pool->free_aiocb = acb;
2463
}
B
bellard 已提交
2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484

/**************************************************************/
/* removable device support */

/**
 * Return TRUE if the media is present
 */
int bdrv_is_inserted(BlockDriverState *bs)
{
    BlockDriver *drv = bs->drv;
    int ret;
    if (!drv)
        return 0;
    if (!drv->bdrv_is_inserted)
        return 1;
    ret = drv->bdrv_is_inserted(bs);
    return ret;
}

/**
 * Return TRUE if the media changed since the last call to this
2485
 * function. It is currently only used for floppy disks
B
bellard 已提交
2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504
 */
int bdrv_media_changed(BlockDriverState *bs)
{
    BlockDriver *drv = bs->drv;
    int ret;

    if (!drv || !drv->bdrv_media_changed)
        ret = -ENOTSUP;
    else
        ret = drv->bdrv_media_changed(bs);
    if (ret == -ENOTSUP)
        ret = bs->media_changed;
    bs->media_changed = 0;
    return ret;
}

/**
 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
 */
2505
int bdrv_eject(BlockDriverState *bs, int eject_flag)
B
bellard 已提交
2506 2507 2508 2509
{
    BlockDriver *drv = bs->drv;
    int ret;

2510 2511 2512 2513
    if (bs->locked) {
        return -EBUSY;
    }

B
bellard 已提交
2514 2515 2516 2517 2518 2519 2520 2521
    if (!drv || !drv->bdrv_eject) {
        ret = -ENOTSUP;
    } else {
        ret = drv->bdrv_eject(bs, eject_flag);
    }
    if (ret == -ENOTSUP) {
        if (eject_flag)
            bdrv_close(bs);
2522
        ret = 0;
B
bellard 已提交
2523
    }
2524 2525

    return ret;
B
bellard 已提交
2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545
}

int bdrv_is_locked(BlockDriverState *bs)
{
    return bs->locked;
}

/**
 * Lock or unlock the media (if it is locked, the user won't be able
 * to eject it manually).
 */
void bdrv_set_locked(BlockDriverState *bs, int locked)
{
    BlockDriver *drv = bs->drv;

    bs->locked = locked;
    if (drv && drv->bdrv_set_locked) {
        drv->bdrv_set_locked(bs, locked);
    }
}
2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556

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

2558 2559 2560
BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
        unsigned long int req, void *buf,
        BlockDriverCompletionFunc *cb, void *opaque)
2561
{
2562
    BlockDriver *drv = bs->drv;
2563

2564 2565 2566
    if (drv && drv->bdrv_aio_ioctl)
        return drv->bdrv_aio_ioctl(bs, req, buf, cb, opaque);
    return NULL;
2567
}
2568

2569 2570


2571 2572 2573 2574
void *qemu_blockalign(BlockDriverState *bs, size_t size)
{
    return qemu_memalign((bs && bs->buffer_alignment) ? bs->buffer_alignment : 512, size);
}
2575 2576 2577 2578

void bdrv_set_dirty_tracking(BlockDriverState *bs, int enable)
{
    int64_t bitmap_size;
2579

2580
    bs->dirty_count = 0;
2581
    if (enable) {
2582 2583 2584 2585
        if (!bs->dirty_bitmap) {
            bitmap_size = (bdrv_getlength(bs) >> BDRV_SECTOR_BITS) +
                    BDRV_SECTORS_PER_DIRTY_CHUNK * 8 - 1;
            bitmap_size /= BDRV_SECTORS_PER_DIRTY_CHUNK * 8;
2586

2587
            bs->dirty_bitmap = qemu_mallocz(bitmap_size);
2588
        }
2589
    } else {
2590
        if (bs->dirty_bitmap) {
2591
            qemu_free(bs->dirty_bitmap);
2592
            bs->dirty_bitmap = NULL;
2593
        }
2594 2595 2596 2597 2598
    }
}

int bdrv_get_dirty(BlockDriverState *bs, int64_t sector)
{
J
Jan Kiszka 已提交
2599
    int64_t chunk = sector / (int64_t)BDRV_SECTORS_PER_DIRTY_CHUNK;
2600

2601 2602 2603 2604
    if (bs->dirty_bitmap &&
        (sector << BDRV_SECTOR_BITS) < bdrv_getlength(bs)) {
        return bs->dirty_bitmap[chunk / (sizeof(unsigned long) * 8)] &
            (1 << (chunk % (sizeof(unsigned long) * 8)));
2605 2606 2607 2608 2609
    } else {
        return 0;
    }
}

2610 2611
void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector,
                      int nr_sectors)
2612 2613 2614
{
    set_dirty_bitmap(bs, cur_sector, nr_sectors, 0);
}
2615 2616 2617 2618 2619

int64_t bdrv_get_dirty_count(BlockDriverState *bs)
{
    return bs->dirty_count;
}