block.c 44.5 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"
25
#ifdef HOST_BSD
26 27 28 29
/* include native header before sys-queue.h */
#include <sys/queue.h>
#endif

P
pbrook 已提交
30
#include "qemu-common.h"
A
aliguori 已提交
31
#include "monitor.h"
B
bellard 已提交
32
#include "block_int.h"
B
bellard 已提交
33

34
#ifdef HOST_BSD
B
bellard 已提交
35 36 37
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
38
#ifndef __DragonFly__
B
bellard 已提交
39 40
#include <sys/disk.h>
#endif
41
#endif
B
bellard 已提交
42

43 44 45 46
#ifdef _WIN32
#include <windows.h>
#endif

B
bellard 已提交
47 48 49
#define SECTOR_BITS 9
#define SECTOR_SIZE (1 << SECTOR_BITS)

50 51
static AIOPool vectored_aio_pool;

B
bellard 已提交
52 53 54 55 56 57
typedef struct BlockDriverAIOCBSync {
    BlockDriverAIOCB common;
    QEMUBH *bh;
    int ret;
} BlockDriverAIOCBSync;

58 59 60 61 62 63
static BlockDriverAIOCB *bdrv_aio_read_em(BlockDriverState *bs,
        int64_t sector_num, uint8_t *buf, int nb_sectors,
        BlockDriverCompletionFunc *cb, void *opaque);
static BlockDriverAIOCB *bdrv_aio_write_em(BlockDriverState *bs,
        int64_t sector_num, const uint8_t *buf, int nb_sectors,
        BlockDriverCompletionFunc *cb, void *opaque);
B
bellard 已提交
64
static void bdrv_aio_cancel_em(BlockDriverAIOCB *acb);
65
static int bdrv_read_em(BlockDriverState *bs, int64_t sector_num,
B
bellard 已提交
66 67 68
                        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 已提交
69

70 71
BlockDriverState *bdrv_first;

B
bellard 已提交
72 73
static BlockDriver *first_drv;

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

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


139
static void bdrv_register(BlockDriver *bdrv)
B
bellard 已提交
140
{
141
    if (!bdrv->bdrv_aio_read) {
B
bellard 已提交
142 143 144 145
        /* add AIO emulation layer */
        bdrv->bdrv_aio_read = bdrv_aio_read_em;
        bdrv->bdrv_aio_write = bdrv_aio_write_em;
        bdrv->bdrv_aio_cancel = bdrv_aio_cancel_em;
B
bellard 已提交
146
        bdrv->aiocb_size = sizeof(BlockDriverAIOCBSync);
147
    } else if (!bdrv->bdrv_read) {
B
bellard 已提交
148 149 150 151
        /* add synchronous IO emulation layer */
        bdrv->bdrv_read = bdrv_read_em;
        bdrv->bdrv_write = bdrv_write_em;
    }
152
    aio_pool_init(&bdrv->aio_pool, bdrv->aiocb_size, bdrv->bdrv_aio_cancel);
B
bellard 已提交
153 154 155
    bdrv->next = first_drv;
    first_drv = bdrv;
}
B
bellard 已提交
156 157 158 159 160 161 162 163

/* create a new block device (by default it is empty) */
BlockDriverState *bdrv_new(const char *device_name)
{
    BlockDriverState **pbs, *bs;

    bs = qemu_mallocz(sizeof(BlockDriverState));
    pstrcpy(bs->device_name, sizeof(bs->device_name), device_name);
B
bellard 已提交
164 165 166 167 168 169 170
    if (device_name[0] != '\0') {
        /* insert at the end */
        pbs = &bdrv_first;
        while (*pbs != NULL)
            pbs = &(*pbs)->next;
        *pbs = bs;
    }
B
bellard 已提交
171 172 173
    return bs;
}

B
bellard 已提交
174 175 176 177 178 179 180 181 182 183
BlockDriver *bdrv_find_format(const char *format_name)
{
    BlockDriver *drv1;
    for(drv1 = first_drv; drv1 != NULL; drv1 = drv1->next) {
        if (!strcmp(drv1->format_name, format_name))
            return drv1;
    }
    return NULL;
}

184 185 186 187 188 189 190 191 192 193 194 195 196 197
int bdrv_create2(BlockDriver *drv,
                const char *filename, int64_t size_in_sectors,
                const char *backing_file, const char *backing_format,
                int flags)
{
    if (drv->bdrv_create2)
        return drv->bdrv_create2(filename, size_in_sectors, backing_file,
                                 backing_format, flags);
    if (drv->bdrv_create)
        return drv->bdrv_create(filename, size_in_sectors, backing_file,
                                flags);
    return -ENOTSUP;
}

198
int bdrv_create(BlockDriver *drv,
B
bellard 已提交
199 200 201 202 203 204 205 206
                const char *filename, int64_t size_in_sectors,
                const char *backing_file, int flags)
{
    if (!drv->bdrv_create)
        return -ENOTSUP;
    return drv->bdrv_create(filename, size_in_sectors, backing_file, flags);
}

B
bellard 已提交
207
#ifdef _WIN32
208
void get_tmp_filename(char *filename, int size)
B
bellard 已提交
209
{
210
    char temp_dir[MAX_PATH];
211

212 213
    GetTempPath(MAX_PATH, temp_dir);
    GetTempFileName(temp_dir, "qem", 0, filename);
B
bellard 已提交
214 215
}
#else
216
void get_tmp_filename(char *filename, int size)
B
bellard 已提交
217
{
B
bellard 已提交
218
    int fd;
219
    const char *tmpdir;
B
bellard 已提交
220
    /* XXX: race condition possible */
A
aurel32 已提交
221 222 223 224
    tmpdir = getenv("TMPDIR");
    if (!tmpdir)
        tmpdir = "/tmp";
    snprintf(filename, size, "%s/vl.XXXXXX", tmpdir);
B
bellard 已提交
225 226 227
    fd = mkstemp(filename);
    close(fd);
}
B
bellard 已提交
228
#endif
B
bellard 已提交
229

B
bellard 已提交
230
#ifdef _WIN32
B
bellard 已提交
231 232 233 234 235 236
static int is_windows_drive_prefix(const char *filename)
{
    return (((filename[0] >= 'a' && filename[0] <= 'z') ||
             (filename[0] >= 'A' && filename[0] <= 'Z')) &&
            filename[1] == ':');
}
237

B
bellard 已提交
238 239
static int is_windows_drive(const char *filename)
{
240
    if (is_windows_drive_prefix(filename) &&
B
bellard 已提交
241
        filename[2] == '\0')
B
bellard 已提交
242 243 244 245 246 247 248 249
        return 1;
    if (strstart(filename, "\\\\.\\", NULL) ||
        strstart(filename, "//./", NULL))
        return 1;
    return 0;
}
#endif

B
bellard 已提交
250 251 252 253 254 255
static BlockDriver *find_protocol(const char *filename)
{
    BlockDriver *drv1;
    char protocol[128];
    int len;
    const char *p;
B
bellard 已提交
256 257

#ifdef _WIN32
B
bellard 已提交
258 259
    if (is_windows_drive(filename) ||
        is_windows_drive_prefix(filename))
B
bellard 已提交
260 261
        return &bdrv_raw;
#endif
B
bellard 已提交
262 263 264 265 266 267 268 269 270
    p = strchr(filename, ':');
    if (!p)
        return &bdrv_raw;
    len = p - filename;
    if (len > sizeof(protocol) - 1)
        len = sizeof(protocol) - 1;
    memcpy(protocol, filename, len);
    protocol[len] = '\0';
    for(drv1 = first_drv; drv1 != NULL; drv1 = drv1->next) {
271
        if (drv1->protocol_name &&
B
bellard 已提交
272 273 274 275 276 277
            !strcmp(drv1->protocol_name, protocol))
            return drv1;
    }
    return NULL;
}

B
bellard 已提交
278 279
/* XXX: force raw format if block or character device ? It would
   simplify the BSD case */
B
bellard 已提交
280 281
static BlockDriver *find_image_format(const char *filename)
{
B
bellard 已提交
282
    int ret, score, score_max;
B
bellard 已提交
283
    BlockDriver *drv1, *drv;
B
bellard 已提交
284 285
    uint8_t buf[2048];
    BlockDriverState *bs;
286

B
bellard 已提交
287 288 289 290 291 292 293 294 295 296
    /* detect host devices. By convention, /dev/cdrom[N] is always
       recognized as a host CDROM */
    if (strstart(filename, "/dev/cdrom", NULL))
        return &bdrv_host_device;
#ifdef _WIN32
    if (is_windows_drive(filename))
        return &bdrv_host_device;
#else
    {
        struct stat st;
297
        if (stat(filename, &st) >= 0 &&
B
bellard 已提交
298 299 300 301 302
            (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode))) {
            return &bdrv_host_device;
        }
    }
#endif
303

B
bellard 已提交
304
    drv = find_protocol(filename);
B
bellard 已提交
305
    /* no need to test disk image formats for vvfat */
B
bellard 已提交
306 307
    if (drv == &bdrv_vvfat)
        return drv;
B
bellard 已提交
308

B
bellard 已提交
309 310 311 312 313 314 315 316 317
    ret = bdrv_file_open(&bs, filename, BDRV_O_RDONLY);
    if (ret < 0)
        return NULL;
    ret = bdrv_pread(bs, 0, buf, sizeof(buf));
    bdrv_delete(bs);
    if (ret < 0) {
        return NULL;
    }

B
bellard 已提交
318 319
    score_max = 0;
    for(drv1 = first_drv; drv1 != NULL; drv1 = drv1->next) {
B
bellard 已提交
320 321 322 323 324 325
        if (drv1->bdrv_probe) {
            score = drv1->bdrv_probe(buf, ret, filename);
            if (score > score_max) {
                score_max = score;
                drv = drv1;
            }
B
bellard 已提交
326
        }
B
bellard 已提交
327
    }
B
bellard 已提交
328 329 330
    return drv;
}

B
bellard 已提交
331
int bdrv_file_open(BlockDriverState **pbs, const char *filename, int flags)
B
bellard 已提交
332
{
B
bellard 已提交
333 334 335 336 337 338 339 340
    BlockDriverState *bs;
    int ret;

    bs = bdrv_new("");
    ret = bdrv_open2(bs, filename, flags | BDRV_O_FILE, NULL);
    if (ret < 0) {
        bdrv_delete(bs);
        return ret;
341
    }
342
    bs->growable = 1;
B
bellard 已提交
343 344 345 346 347 348 349
    *pbs = bs;
    return 0;
}

int bdrv_open(BlockDriverState *bs, const char *filename, int flags)
{
    return bdrv_open2(bs, filename, flags, NULL);
B
bellard 已提交
350 351
}

B
bellard 已提交
352
int bdrv_open2(BlockDriverState *bs, const char *filename, int flags,
B
bellard 已提交
353 354
               BlockDriver *drv)
{
B
bellard 已提交
355
    int ret, open_flags;
356 357
    char tmp_filename[PATH_MAX];
    char backing_filename[PATH_MAX];
358

B
bellard 已提交
359 360 361
    bs->read_only = 0;
    bs->is_temporary = 0;
    bs->encrypted = 0;
362
    bs->valid_key = 0;
B
bellard 已提交
363

B
bellard 已提交
364
    if (flags & BDRV_O_SNAPSHOT) {
B
bellard 已提交
365 366
        BlockDriverState *bs1;
        int64_t total_size;
A
aliguori 已提交
367
        int is_protocol = 0;
368

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

B
bellard 已提交
372 373
        /* if there is a backing file, use it */
        bs1 = bdrv_new("");
374
        ret = bdrv_open2(bs1, filename, 0, drv);
375
        if (ret < 0) {
B
bellard 已提交
376
            bdrv_delete(bs1);
377
            return ret;
B
bellard 已提交
378
        }
B
bellard 已提交
379
        total_size = bdrv_getlength(bs1) >> SECTOR_BITS;
A
aliguori 已提交
380 381 382 383

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

B
bellard 已提交
384
        bdrv_delete(bs1);
385

B
bellard 已提交
386
        get_tmp_filename(tmp_filename, sizeof(tmp_filename));
A
aliguori 已提交
387 388 389 390 391 392 393 394

        /* Real path is meaningless for protocols */
        if (is_protocol)
            snprintf(backing_filename, sizeof(backing_filename),
                     "%s", filename);
        else
            realpath(filename, backing_filename);

395 396 397
        ret = bdrv_create2(&bdrv_qcow2, tmp_filename,
                           total_size, backing_filename, 
                           (drv ? drv->format_name : NULL), 0);
398 399
        if (ret < 0) {
            return ret;
B
bellard 已提交
400 401
        }
        filename = tmp_filename;
402
        drv = &bdrv_qcow2;
B
bellard 已提交
403 404
        bs->is_temporary = 1;
    }
B
bellard 已提交
405

B
bellard 已提交
406
    pstrcpy(bs->filename, sizeof(bs->filename), filename);
B
bellard 已提交
407 408
    if (flags & BDRV_O_FILE) {
        drv = find_protocol(filename);
409 410 411 412 413 414
    } else if (!drv) {
        drv = find_image_format(filename);
    }
    if (!drv) {
        ret = -ENOENT;
        goto unlink_and_fail;
B
bellard 已提交
415 416 417
    }
    bs->drv = drv;
    bs->opaque = qemu_mallocz(drv->instance_size);
B
bellard 已提交
418 419 420
    /* Note: for compatibility, we open disk image files as RDWR, and
       RDONLY as fallback */
    if (!(flags & BDRV_O_FILE))
421
        open_flags = BDRV_O_RDWR | (flags & BDRV_O_CACHE_MASK);
B
bellard 已提交
422 423 424
    else
        open_flags = flags & ~(BDRV_O_FILE | BDRV_O_SNAPSHOT);
    ret = drv->bdrv_open(bs, filename, open_flags);
425
    if ((ret == -EACCES || ret == -EPERM) && !(flags & BDRV_O_FILE)) {
426
        ret = drv->bdrv_open(bs, filename, open_flags & ~BDRV_O_RDWR);
B
bellard 已提交
427 428
        bs->read_only = 1;
    }
B
bellard 已提交
429 430
    if (ret < 0) {
        qemu_free(bs->opaque);
B
bellard 已提交
431 432
        bs->opaque = NULL;
        bs->drv = NULL;
433 434 435
    unlink_and_fail:
        if (bs->is_temporary)
            unlink(filename);
B
bellard 已提交
436
        return ret;
437
    }
438 439 440
    if (drv->bdrv_getlength) {
        bs->total_sectors = bdrv_getlength(bs) >> SECTOR_BITS;
    }
B
bellard 已提交
441
#ifndef _WIN32
B
bellard 已提交
442 443 444 445
    if (bs->is_temporary) {
        unlink(filename);
    }
#endif
B
bellard 已提交
446
    if (bs->backing_file[0] != '\0') {
B
bellard 已提交
447
        /* if there is a backing file, use it */
448
        BlockDriver *back_drv = NULL;
B
bellard 已提交
449
        bs->backing_hd = bdrv_new("");
B
bellard 已提交
450 451
        path_combine(backing_filename, sizeof(backing_filename),
                     filename, bs->backing_file);
452 453 454 455
        if (bs->backing_format[0] != '\0')
            back_drv = bdrv_find_format(bs->backing_format);
        ret = bdrv_open2(bs->backing_hd, backing_filename, open_flags,
                         back_drv);
456 457 458 459
        if (ret < 0) {
            bdrv_close(bs);
            return ret;
        }
460 461
    }

462 463 464 465 466 467
    if (!bdrv_key_required(bs)) {
        /* call the change callback */
        bs->media_changed = 1;
        if (bs->change_cb)
            bs->change_cb(bs->change_opaque);
    }
B
bellard 已提交
468
    return 0;
B
bellard 已提交
469 470 471 472
}

void bdrv_close(BlockDriverState *bs)
{
B
bellard 已提交
473
    if (bs->drv) {
B
bellard 已提交
474 475 476 477 478 479 480 481
        if (bs->backing_hd)
            bdrv_delete(bs->backing_hd);
        bs->drv->bdrv_close(bs);
        qemu_free(bs->opaque);
#ifdef _WIN32
        if (bs->is_temporary) {
            unlink(bs->filename);
        }
B
bellard 已提交
482
#endif
B
bellard 已提交
483 484
        bs->opaque = NULL;
        bs->drv = NULL;
B
bellard 已提交
485 486

        /* call the change callback */
B
bellard 已提交
487
        bs->media_changed = 1;
B
bellard 已提交
488 489 490 491 492 493 494
        if (bs->change_cb)
            bs->change_cb(bs->change_opaque);
    }
}

void bdrv_delete(BlockDriverState *bs)
{
495 496 497 498 499 500 501 502
    BlockDriverState **pbs;

    pbs = &bdrv_first;
    while (*pbs != bs && *pbs != NULL)
        pbs = &(*pbs)->next;
    if (*pbs == bs)
        *pbs = bs->next;

B
bellard 已提交
503 504
    bdrv_close(bs);
    qemu_free(bs);
B
bellard 已提交
505 506
}

507 508 509
/* commit COW file into the raw image */
int bdrv_commit(BlockDriverState *bs)
{
B
bellard 已提交
510
    BlockDriver *drv = bs->drv;
B
bellard 已提交
511
    int64_t i, total_sectors;
B
bellard 已提交
512 513
    int n, j;
    unsigned char sector[512];
514

B
bellard 已提交
515 516
    if (!drv)
        return -ENOMEDIUM;
517 518

    if (bs->read_only) {
B
bellard 已提交
519
	return -EACCES;
520 521
    }

B
bellard 已提交
522 523 524
    if (!bs->backing_hd) {
	return -ENOTSUP;
    }
525

B
bellard 已提交
526 527
    total_sectors = bdrv_getlength(bs) >> SECTOR_BITS;
    for (i = 0; i < total_sectors;) {
B
bellard 已提交
528
        if (drv->bdrv_is_allocated(bs, i, 65536, &n)) {
B
bellard 已提交
529 530 531 532 533 534 535 536 537
            for(j = 0; j < n; j++) {
                if (bdrv_read(bs, i, sector, 1) != 0) {
                    return -EIO;
                }

                if (bdrv_write(bs->backing_hd, i, sector, 1) != 0) {
                    return -EIO;
                }
                i++;
538
	    }
B
bellard 已提交
539 540 541
	} else {
            i += n;
        }
542
    }
543

B
bellard 已提交
544 545
    if (drv->bdrv_make_empty)
	return drv->bdrv_make_empty(bs);
546

547 548 549
    return 0;
}

550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582
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);

    if ((offset + size) > len)
        return -EIO;

    return 0;
}

static int bdrv_check_request(BlockDriverState *bs, int64_t sector_num,
                              int nb_sectors)
{
    int64_t offset;

    /* Deal with byte accesses */
    if (sector_num < 0)
        offset = -sector_num;
    else
        offset = sector_num * 512;

    return bdrv_check_byte_request(bs, offset, nb_sectors * 512);
}

B
bellard 已提交
583
/* return < 0 if error. See bdrv_write() for the return codes */
584
int bdrv_read(BlockDriverState *bs, int64_t sector_num,
B
bellard 已提交
585 586
              uint8_t *buf, int nb_sectors)
{
B
bellard 已提交
587 588
    BlockDriver *drv = bs->drv;

B
bellard 已提交
589 590
    if (!drv)
        return -ENOMEDIUM;
591 592
    if (bdrv_check_request(bs, sector_num, nb_sectors))
        return -EIO;
B
bellard 已提交
593

594
    return drv->bdrv_read(bs, sector_num, buf, nb_sectors);
B
bellard 已提交
595 596
}

597
/* Return < 0 if error. Important errors are:
B
bellard 已提交
598 599 600 601 602
  -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
*/
603
int bdrv_write(BlockDriverState *bs, int64_t sector_num,
B
bellard 已提交
604 605
               const uint8_t *buf, int nb_sectors)
{
B
bellard 已提交
606
    BlockDriver *drv = bs->drv;
B
bellard 已提交
607 608
    if (!bs->drv)
        return -ENOMEDIUM;
B
bellard 已提交
609
    if (bs->read_only)
B
bellard 已提交
610
        return -EACCES;
611 612 613
    if (bdrv_check_request(bs, sector_num, nb_sectors))
        return -EIO;

614
    return drv->bdrv_write(bs, sector_num, buf, nb_sectors);
B
bellard 已提交
615 616
}

617 618
int bdrv_pread(BlockDriverState *bs, int64_t offset,
               void *buf, int count1)
B
bellard 已提交
619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660
{
    uint8_t tmp_buf[SECTOR_SIZE];
    int len, nb_sectors, count;
    int64_t sector_num;

    count = count1;
    /* first read to align to sector start */
    len = (SECTOR_SIZE - offset) & (SECTOR_SIZE - 1);
    if (len > count)
        len = count;
    sector_num = offset >> SECTOR_BITS;
    if (len > 0) {
        if (bdrv_read(bs, sector_num, tmp_buf, 1) < 0)
            return -EIO;
        memcpy(buf, tmp_buf + (offset & (SECTOR_SIZE - 1)), len);
        count -= len;
        if (count == 0)
            return count1;
        sector_num++;
        buf += len;
    }

    /* read the sectors "in place" */
    nb_sectors = count >> SECTOR_BITS;
    if (nb_sectors > 0) {
        if (bdrv_read(bs, sector_num, buf, nb_sectors) < 0)
            return -EIO;
        sector_num += nb_sectors;
        len = nb_sectors << SECTOR_BITS;
        buf += len;
        count -= len;
    }

    /* add data from the last sector */
    if (count > 0) {
        if (bdrv_read(bs, sector_num, tmp_buf, 1) < 0)
            return -EIO;
        memcpy(buf, tmp_buf, count);
    }
    return count1;
}

661 662
int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
                const void *buf, int count1)
B
bellard 已提交
663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715
{
    uint8_t tmp_buf[SECTOR_SIZE];
    int len, nb_sectors, count;
    int64_t sector_num;

    count = count1;
    /* first write to align to sector start */
    len = (SECTOR_SIZE - offset) & (SECTOR_SIZE - 1);
    if (len > count)
        len = count;
    sector_num = offset >> SECTOR_BITS;
    if (len > 0) {
        if (bdrv_read(bs, sector_num, tmp_buf, 1) < 0)
            return -EIO;
        memcpy(tmp_buf + (offset & (SECTOR_SIZE - 1)), buf, len);
        if (bdrv_write(bs, sector_num, tmp_buf, 1) < 0)
            return -EIO;
        count -= len;
        if (count == 0)
            return count1;
        sector_num++;
        buf += len;
    }

    /* write the sectors "in place" */
    nb_sectors = count >> SECTOR_BITS;
    if (nb_sectors > 0) {
        if (bdrv_write(bs, sector_num, buf, nb_sectors) < 0)
            return -EIO;
        sector_num += nb_sectors;
        len = nb_sectors << SECTOR_BITS;
        buf += len;
        count -= len;
    }

    /* add data from the last sector */
    if (count > 0) {
        if (bdrv_read(bs, sector_num, tmp_buf, 1) < 0)
            return -EIO;
        memcpy(tmp_buf, buf, count);
        if (bdrv_write(bs, sector_num, tmp_buf, 1) < 0)
            return -EIO;
    }
    return count1;
}

/**
 * Truncate file to 'offset' bytes (needed only for file protocols)
 */
int bdrv_truncate(BlockDriverState *bs, int64_t offset)
{
    BlockDriver *drv = bs->drv;
    if (!drv)
B
bellard 已提交
716
        return -ENOMEDIUM;
B
bellard 已提交
717 718 719 720 721 722 723 724 725 726 727 728
    if (!drv->bdrv_truncate)
        return -ENOTSUP;
    return drv->bdrv_truncate(bs, offset);
}

/**
 * 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 已提交
729
        return -ENOMEDIUM;
B
bellard 已提交
730 731 732 733 734
    if (!drv->bdrv_getlength) {
        /* legacy mode */
        return bs->total_sectors * SECTOR_SIZE;
    }
    return drv->bdrv_getlength(bs);
B
bellard 已提交
735 736
}

B
bellard 已提交
737
/* return 0 as number of sectors if no device present or error */
738
void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
B
bellard 已提交
739
{
B
bellard 已提交
740 741 742 743 744 745 746
    int64_t length;
    length = bdrv_getlength(bs);
    if (length < 0)
        length = 0;
    else
        length = length >> SECTOR_BITS;
    *nb_sectors_ptr = length;
B
bellard 已提交
747
}
B
bellard 已提交
748

749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769
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)
{
    uint8_t buf[512];
    int ret, i, heads, sectors, cylinders;
    struct partition *p;
    uint32_t nr_sects;
B
blueswir1 已提交
770
    uint64_t nb_sectors;
771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809

    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 已提交
810
    uint64_t nb_sectors;
811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864

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

865
void bdrv_set_geometry_hint(BlockDriverState *bs,
B
bellard 已提交
866 867 868 869 870 871 872 873 874 875 876 877 878 879
                            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 已提交
880 881 882 883 884
void bdrv_set_translation_hint(BlockDriverState *bs, int translation)
{
    bs->translation = translation;
}

885
void bdrv_get_geometry_hint(BlockDriverState *bs,
B
bellard 已提交
886 887 888 889 890 891 892 893 894 895 896 897
                            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 已提交
898 899 900 901 902
int bdrv_get_translation_hint(BlockDriverState *bs)
{
    return bs->translation;
}

B
bellard 已提交
903 904 905 906 907 908 909 910 911 912
int bdrv_is_removable(BlockDriverState *bs)
{
    return bs->removable;
}

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

913 914 915 916 917
int bdrv_is_sg(BlockDriverState *bs)
{
    return bs->sg;
}

B
bellard 已提交
918
/* XXX: no longer used */
919
void bdrv_set_change_cb(BlockDriverState *bs,
B
bellard 已提交
920 921 922 923 924 925
                        void (*change_cb)(void *opaque), void *opaque)
{
    bs->change_cb = change_cb;
    bs->change_opaque = opaque;
}

B
bellard 已提交
926 927 928 929 930 931 932
int bdrv_is_encrypted(BlockDriverState *bs)
{
    if (bs->backing_hd && bs->backing_hd->encrypted)
        return 1;
    return bs->encrypted;
}

933 934 935 936 937 938 939 940 941
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 已提交
942 943 944 945 946 947 948 949 950 951 952 953
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;
    }
    if (!bs->encrypted || !bs->drv || !bs->drv->bdrv_set_key)
        return -1;
954
    ret = bs->drv->bdrv_set_key(bs, key);
955 956 957 958 959 960 961 962 963
    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);
    }
964
    return ret;
B
bellard 已提交
965 966 967 968
}

void bdrv_get_format(BlockDriverState *bs, char *buf, int buf_size)
{
B
bellard 已提交
969
    if (!bs->drv) {
B
bellard 已提交
970 971 972 973 974 975
        buf[0] = '\0';
    } else {
        pstrcpy(buf, buf_size, bs->drv->format_name);
    }
}

976
void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
B
bellard 已提交
977 978 979 980 981 982 983 984 985
                         void *opaque)
{
    BlockDriver *drv;

    for (drv = first_drv; drv != NULL; drv = drv->next) {
        it(opaque, drv->format_name);
    }
}

B
bellard 已提交
986 987 988 989 990 991 992 993 994 995 996
BlockDriverState *bdrv_find(const char *name)
{
    BlockDriverState *bs;

    for (bs = bdrv_first; bs != NULL; bs = bs->next) {
        if (!strcmp(name, bs->device_name))
            return bs;
    }
    return NULL;
}

997
void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs), void *opaque)
B
bellard 已提交
998 999 1000 1001
{
    BlockDriverState *bs;

    for (bs = bdrv_first; bs != NULL; bs = bs->next) {
1002
        it(opaque, bs);
B
bellard 已提交
1003 1004 1005
    }
}

B
bellard 已提交
1006 1007 1008 1009 1010
const char *bdrv_get_device_name(BlockDriverState *bs)
{
    return bs->device_name;
}

P
pbrook 已提交
1011 1012 1013 1014 1015 1016 1017 1018
void bdrv_flush(BlockDriverState *bs)
{
    if (bs->drv->bdrv_flush)
        bs->drv->bdrv_flush(bs);
    if (bs->backing_hd)
        bdrv_flush(bs->backing_hd);
}

A
aliguori 已提交
1019 1020 1021 1022 1023 1024 1025 1026 1027 1028
void bdrv_flush_all(void)
{
    BlockDriverState *bs;

    for (bs = bdrv_first; bs != NULL; bs = bs->next)
        if (bs->drv && !bdrv_is_read_only(bs) && 
            (!bdrv_is_removable(bs) || bdrv_is_inserted(bs)))
            bdrv_flush(bs);
}

1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055
/*
 * 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);
}

A
aliguori 已提交
1056
void bdrv_info(Monitor *mon)
B
bellard 已提交
1057 1058 1059 1060
{
    BlockDriverState *bs;

    for (bs = bdrv_first; bs != NULL; bs = bs->next) {
A
aliguori 已提交
1061 1062
        monitor_printf(mon, "%s:", bs->device_name);
        monitor_printf(mon, " type=");
B
bellard 已提交
1063 1064
        switch(bs->type) {
        case BDRV_TYPE_HD:
A
aliguori 已提交
1065
            monitor_printf(mon, "hd");
B
bellard 已提交
1066 1067
            break;
        case BDRV_TYPE_CDROM:
A
aliguori 已提交
1068
            monitor_printf(mon, "cdrom");
B
bellard 已提交
1069 1070
            break;
        case BDRV_TYPE_FLOPPY:
A
aliguori 已提交
1071
            monitor_printf(mon, "floppy");
B
bellard 已提交
1072 1073
            break;
        }
A
aliguori 已提交
1074
        monitor_printf(mon, " removable=%d", bs->removable);
B
bellard 已提交
1075
        if (bs->removable) {
A
aliguori 已提交
1076
            monitor_printf(mon, " locked=%d", bs->locked);
B
bellard 已提交
1077
        }
B
bellard 已提交
1078
        if (bs->drv) {
A
aliguori 已提交
1079 1080
            monitor_printf(mon, " file=");
            monitor_print_filename(mon, bs->filename);
1081
            if (bs->backing_file[0] != '\0') {
A
aliguori 已提交
1082 1083 1084 1085 1086 1087
                monitor_printf(mon, " backing_file=");
                monitor_print_filename(mon, bs->backing_file);
            }
            monitor_printf(mon, " ro=%d", bs->read_only);
            monitor_printf(mon, " drv=%s", bs->drv->format_name);
            monitor_printf(mon, " encrypted=%d", bdrv_is_encrypted(bs));
B
bellard 已提交
1088
        } else {
A
aliguori 已提交
1089
            monitor_printf(mon, " [not inserted]");
B
bellard 已提交
1090
        }
A
aliguori 已提交
1091
        monitor_printf(mon, "\n");
B
bellard 已提交
1092 1093
    }
}
1094 1095

/* The "info blockstats" command. */
A
aliguori 已提交
1096
void bdrv_info_stats(Monitor *mon)
1097 1098 1099 1100
{
    BlockDriverState *bs;

    for (bs = bdrv_first; bs != NULL; bs = bs->next) {
A
aliguori 已提交
1101 1102 1103 1104 1105
        monitor_printf(mon, "%s:"
                       " rd_bytes=%" PRIu64
                       " wr_bytes=%" PRIu64
                       " rd_operations=%" PRIu64
                       " wr_operations=%" PRIu64
A
aliguori 已提交
1106
                       "\n",
A
aliguori 已提交
1107 1108 1109
                       bs->device_name,
                       bs->rd_bytes, bs->wr_bytes,
                       bs->rd_ops, bs->wr_ops);
1110 1111
    }
}
B
bellard 已提交
1112

1113 1114 1115 1116 1117 1118 1119 1120 1121 1122
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;
}

1123
void bdrv_get_backing_filename(BlockDriverState *bs,
B
bellard 已提交
1124 1125 1126 1127 1128 1129 1130 1131 1132
                               char *filename, int filename_size)
{
    if (!bs->backing_hd) {
        pstrcpy(filename, filename_size, "");
    } else {
        pstrcpy(filename, filename_size, bs->backing_file);
    }
}

1133
int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
B
bellard 已提交
1134 1135 1136 1137
                          const uint8_t *buf, int nb_sectors)
{
    BlockDriver *drv = bs->drv;
    if (!drv)
B
bellard 已提交
1138
        return -ENOMEDIUM;
B
bellard 已提交
1139 1140 1141 1142
    if (!drv->bdrv_write_compressed)
        return -ENOTSUP;
    return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);
}
1143

B
bellard 已提交
1144 1145 1146 1147
int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
{
    BlockDriver *drv = bs->drv;
    if (!drv)
B
bellard 已提交
1148
        return -ENOMEDIUM;
B
bellard 已提交
1149 1150 1151 1152 1153 1154 1155 1156 1157
    if (!drv->bdrv_get_info)
        return -ENOTSUP;
    memset(bdi, 0, sizeof(*bdi));
    return drv->bdrv_get_info(bs, bdi);
}

/**************************************************************/
/* handling of snapshots */

1158
int bdrv_snapshot_create(BlockDriverState *bs,
B
bellard 已提交
1159 1160 1161 1162
                         QEMUSnapshotInfo *sn_info)
{
    BlockDriver *drv = bs->drv;
    if (!drv)
B
bellard 已提交
1163
        return -ENOMEDIUM;
B
bellard 已提交
1164 1165 1166 1167 1168
    if (!drv->bdrv_snapshot_create)
        return -ENOTSUP;
    return drv->bdrv_snapshot_create(bs, sn_info);
}

1169
int bdrv_snapshot_goto(BlockDriverState *bs,
B
bellard 已提交
1170 1171 1172 1173
                       const char *snapshot_id)
{
    BlockDriver *drv = bs->drv;
    if (!drv)
B
bellard 已提交
1174
        return -ENOMEDIUM;
B
bellard 已提交
1175 1176 1177 1178 1179 1180 1181 1182 1183
    if (!drv->bdrv_snapshot_goto)
        return -ENOTSUP;
    return drv->bdrv_snapshot_goto(bs, snapshot_id);
}

int bdrv_snapshot_delete(BlockDriverState *bs, const char *snapshot_id)
{
    BlockDriver *drv = bs->drv;
    if (!drv)
B
bellard 已提交
1184
        return -ENOMEDIUM;
B
bellard 已提交
1185 1186 1187 1188 1189
    if (!drv->bdrv_snapshot_delete)
        return -ENOTSUP;
    return drv->bdrv_snapshot_delete(bs, snapshot_id);
}

1190
int bdrv_snapshot_list(BlockDriverState *bs,
B
bellard 已提交
1191 1192 1193 1194
                       QEMUSnapshotInfo **psn_info)
{
    BlockDriver *drv = bs->drv;
    if (!drv)
B
bellard 已提交
1195
        return -ENOMEDIUM;
B
bellard 已提交
1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214
    if (!drv->bdrv_snapshot_list)
        return -ENOTSUP;
    return drv->bdrv_snapshot_list(bs, psn_info);
}

#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)) {
1215
                snprintf(buf, buf_size, "%0.1f%c",
B
bellard 已提交
1216 1217 1218 1219
                         (double)size / base,
                         suffixes[i]);
                break;
            } else if (size < (1000 * base) || i == (NB_SUFFIXES - 1)) {
1220
                snprintf(buf, buf_size, "%" PRId64 "%c",
B
bellard 已提交
1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233
                         ((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];
1234 1235 1236
#ifdef _WIN32
    struct tm *ptm;
#else
B
bellard 已提交
1237
    struct tm tm;
1238
#endif
B
bellard 已提交
1239 1240 1241 1242
    time_t ti;
    int64_t secs;

    if (!sn) {
1243 1244
        snprintf(buf, buf_size,
                 "%-10s%-20s%7s%20s%15s",
B
bellard 已提交
1245 1246 1247
                 "ID", "TAG", "VM SIZE", "DATE", "VM CLOCK");
    } else {
        ti = sn->date_sec;
1248 1249 1250 1251 1252
#ifdef _WIN32
        ptm = localtime(&ti);
        strftime(date_buf, sizeof(date_buf),
                 "%Y-%m-%d %H:%M:%S", ptm);
#else
B
bellard 已提交
1253 1254 1255
        localtime_r(&ti, &tm);
        strftime(date_buf, sizeof(date_buf),
                 "%Y-%m-%d %H:%M:%S", &tm);
1256
#endif
B
bellard 已提交
1257 1258 1259 1260 1261
        secs = sn->vm_clock_nsec / 1000000000;
        snprintf(clock_buf, sizeof(clock_buf),
                 "%02d:%02d:%02d.%03d",
                 (int)(secs / 3600),
                 (int)((secs / 60) % 60),
1262
                 (int)(secs % 60),
B
bellard 已提交
1263 1264
                 (int)((sn->vm_clock_nsec / 1000000) % 1000));
        snprintf(buf, buf_size,
1265
                 "%-10s%-20s%7s%20s%15s",
B
bellard 已提交
1266 1267 1268 1269 1270 1271 1272 1273
                 sn->id_str, sn->name,
                 get_human_readable_size(buf1, sizeof(buf1), sn->vm_state_size),
                 date_buf,
                 clock_buf);
    }
    return buf;
}

B
bellard 已提交
1274

B
bellard 已提交
1275
/**************************************************************/
B
bellard 已提交
1276
/* async I/Os */
B
bellard 已提交
1277

1278 1279
typedef struct VectorTranslationAIOCB {
    BlockDriverAIOCB common;
1280 1281 1282 1283
    QEMUIOVector *iov;
    uint8_t *bounce;
    int is_write;
    BlockDriverAIOCB *aiocb;
1284
} VectorTranslationAIOCB;
1285

1286
static void bdrv_aio_cancel_vector(BlockDriverAIOCB *_acb)
1287
{
1288 1289
    VectorTranslationAIOCB *acb
        = container_of(_acb, VectorTranslationAIOCB, common);
1290

1291
    bdrv_aio_cancel(acb->aiocb);
1292 1293
}

1294 1295
static void bdrv_aio_rw_vector_cb(void *opaque, int ret)
{
1296
    VectorTranslationAIOCB *s = (VectorTranslationAIOCB *)opaque;
1297 1298

    if (!s->is_write) {
1299
        qemu_iovec_from_buffer(s->iov, s->bounce, s->iov->size);
1300
    }
A
aurel32 已提交
1301
    qemu_vfree(s->bounce);
1302 1303
    s->common.cb(s->common.opaque, ret);
    qemu_aio_release(s);
1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314
}

static BlockDriverAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs,
                                            int64_t sector_num,
                                            QEMUIOVector *iov,
                                            int nb_sectors,
                                            BlockDriverCompletionFunc *cb,
                                            void *opaque,
                                            int is_write)

{
1315 1316
    VectorTranslationAIOCB *s = qemu_aio_get_pool(&vectored_aio_pool, bs,
                                                  cb, opaque);
1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328

    s->iov = iov;
    s->bounce = qemu_memalign(512, nb_sectors * 512);
    s->is_write = is_write;
    if (is_write) {
        qemu_iovec_to_buffer(s->iov, s->bounce);
        s->aiocb = bdrv_aio_write(bs, sector_num, s->bounce, nb_sectors,
                                  bdrv_aio_rw_vector_cb, s);
    } else {
        s->aiocb = bdrv_aio_read(bs, sector_num, s->bounce, nb_sectors,
                                 bdrv_aio_rw_vector_cb, s);
    }
1329 1330 1331 1332 1333
    if (!s->aiocb) {
        qemu_vfree(s->bounce);
        qemu_aio_release(s);
        return NULL;
    }
1334
    return &s->common;
1335 1336 1337 1338 1339 1340
}

BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
                                 QEMUIOVector *iov, int nb_sectors,
                                 BlockDriverCompletionFunc *cb, void *opaque)
{
1341 1342 1343
    if (bdrv_check_request(bs, sector_num, nb_sectors))
        return NULL;

1344 1345 1346 1347 1348 1349 1350 1351
    return bdrv_aio_rw_vector(bs, sector_num, iov, nb_sectors,
                              cb, opaque, 0);
}

BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
                                  QEMUIOVector *iov, int nb_sectors,
                                  BlockDriverCompletionFunc *cb, void *opaque)
{
1352 1353 1354
    if (bdrv_check_request(bs, sector_num, nb_sectors))
        return NULL;

1355 1356 1357 1358
    return bdrv_aio_rw_vector(bs, sector_num, iov, nb_sectors,
                              cb, opaque, 1);
}

1359 1360 1361
BlockDriverAIOCB *bdrv_aio_read(BlockDriverState *bs, int64_t sector_num,
                                uint8_t *buf, int nb_sectors,
                                BlockDriverCompletionFunc *cb, void *opaque)
B
bellard 已提交
1362 1363
{
    BlockDriver *drv = bs->drv;
1364
    BlockDriverAIOCB *ret;
B
bellard 已提交
1365

B
bellard 已提交
1366
    if (!drv)
1367
        return NULL;
1368 1369
    if (bdrv_check_request(bs, sector_num, nb_sectors))
        return NULL;
1370

1371 1372 1373 1374 1375 1376 1377 1378 1379
    ret = drv->bdrv_aio_read(bs, sector_num, buf, nb_sectors, cb, opaque);

    if (ret) {
	/* Update stats even though technically transfer has not happened. */
	bs->rd_bytes += (unsigned) nb_sectors * SECTOR_SIZE;
	bs->rd_ops ++;
    }

    return ret;
B
bellard 已提交
1380 1381
}

1382 1383 1384
BlockDriverAIOCB *bdrv_aio_write(BlockDriverState *bs, int64_t sector_num,
                                 const uint8_t *buf, int nb_sectors,
                                 BlockDriverCompletionFunc *cb, void *opaque)
B
bellard 已提交
1385
{
B
bellard 已提交
1386
    BlockDriver *drv = bs->drv;
1387
    BlockDriverAIOCB *ret;
B
bellard 已提交
1388

B
bellard 已提交
1389
    if (!drv)
1390
        return NULL;
B
bellard 已提交
1391
    if (bs->read_only)
1392
        return NULL;
1393 1394
    if (bdrv_check_request(bs, sector_num, nb_sectors))
        return NULL;
B
bellard 已提交
1395

1396 1397 1398 1399 1400 1401 1402 1403 1404
    ret = drv->bdrv_aio_write(bs, sector_num, buf, nb_sectors, cb, opaque);

    if (ret) {
	/* Update stats even though technically transfer has not happened. */
	bs->wr_bytes += (unsigned) nb_sectors * SECTOR_SIZE;
	bs->wr_ops ++;
    }

    return ret;
B
bellard 已提交
1405 1406 1407 1408
}

void bdrv_aio_cancel(BlockDriverAIOCB *acb)
{
1409
    acb->pool->cancel(acb);
B
bellard 已提交
1410 1411
}

1412

B
bellard 已提交
1413 1414 1415
/**************************************************************/
/* async block device emulation */

1416
static void bdrv_aio_bh_cb(void *opaque)
B
bellard 已提交
1417
{
1418 1419 1420
    BlockDriverAIOCBSync *acb = opaque;
    acb->common.cb(acb->common.opaque, acb->ret);
    qemu_aio_release(acb);
B
bellard 已提交
1421
}
1422

1423 1424 1425
static BlockDriverAIOCB *bdrv_aio_read_em(BlockDriverState *bs,
        int64_t sector_num, uint8_t *buf, int nb_sectors,
        BlockDriverCompletionFunc *cb, void *opaque)
B
bellard 已提交
1426
{
1427
    BlockDriverAIOCBSync *acb;
B
bellard 已提交
1428
    int ret;
1429 1430 1431 1432 1433 1434 1435 1436

    acb = qemu_aio_get(bs, cb, opaque);
    if (!acb->bh)
        acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
    ret = bdrv_read(bs, sector_num, buf, nb_sectors);
    acb->ret = ret;
    qemu_bh_schedule(acb->bh);
    return &acb->common;
1437 1438
}

1439 1440 1441
static BlockDriverAIOCB *bdrv_aio_write_em(BlockDriverState *bs,
        int64_t sector_num, const uint8_t *buf, int nb_sectors,
        BlockDriverCompletionFunc *cb, void *opaque)
1442
{
1443
    BlockDriverAIOCBSync *acb;
B
bellard 已提交
1444 1445
    int ret;

1446 1447 1448 1449 1450 1451 1452
    acb = qemu_aio_get(bs, cb, opaque);
    if (!acb->bh)
        acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
    ret = bdrv_write(bs, sector_num, buf, nb_sectors);
    acb->ret = ret;
    qemu_bh_schedule(acb->bh);
    return &acb->common;
1453 1454
}

1455
static void bdrv_aio_cancel_em(BlockDriverAIOCB *blockacb)
B
bellard 已提交
1456
{
1457 1458 1459
    BlockDriverAIOCBSync *acb = (BlockDriverAIOCBSync *)blockacb;
    qemu_bh_cancel(acb->bh);
    qemu_aio_release(acb);
B
bellard 已提交
1460
}
B
bellard 已提交
1461

B
bellard 已提交
1462 1463
/**************************************************************/
/* sync block device emulation */
B
bellard 已提交
1464

B
bellard 已提交
1465 1466 1467
static void bdrv_rw_em_cb(void *opaque, int ret)
{
    *(int *)opaque = ret;
B
bellard 已提交
1468 1469
}

B
bellard 已提交
1470 1471
#define NOT_DONE 0x7fffffff

1472
static int bdrv_read_em(BlockDriverState *bs, int64_t sector_num,
B
bellard 已提交
1473
                        uint8_t *buf, int nb_sectors)
P
pbrook 已提交
1474
{
1475 1476
    int async_ret;
    BlockDriverAIOCB *acb;
B
bellard 已提交
1477 1478

    async_ret = NOT_DONE;
1479
    acb = bdrv_aio_read(bs, sector_num, buf, nb_sectors,
B
bellard 已提交
1480
                        bdrv_rw_em_cb, &async_ret);
1481
    if (acb == NULL)
1482
        return -1;
1483

B
bellard 已提交
1484 1485 1486
    while (async_ret == NOT_DONE) {
        qemu_aio_wait();
    }
1487

B
bellard 已提交
1488
    return async_ret;
P
pbrook 已提交
1489 1490
}

B
bellard 已提交
1491 1492 1493
static int bdrv_write_em(BlockDriverState *bs, int64_t sector_num,
                         const uint8_t *buf, int nb_sectors)
{
1494 1495
    int async_ret;
    BlockDriverAIOCB *acb;
B
bellard 已提交
1496 1497

    async_ret = NOT_DONE;
1498
    acb = bdrv_aio_write(bs, sector_num, buf, nb_sectors,
B
bellard 已提交
1499
                         bdrv_rw_em_cb, &async_ret);
1500
    if (acb == NULL)
1501
        return -1;
B
bellard 已提交
1502 1503 1504 1505 1506
    while (async_ret == NOT_DONE) {
        qemu_aio_wait();
    }
    return async_ret;
}
B
bellard 已提交
1507 1508 1509

void bdrv_init(void)
{
1510
    aio_pool_init(&vectored_aio_pool, sizeof(VectorTranslationAIOCB),
1511 1512
                  bdrv_aio_cancel_vector);

B
bellard 已提交
1513
    bdrv_register(&bdrv_raw);
B
bellard 已提交
1514
    bdrv_register(&bdrv_host_device);
B
bellard 已提交
1515 1516 1517 1518 1519
#ifndef _WIN32
    bdrv_register(&bdrv_cow);
#endif
    bdrv_register(&bdrv_qcow);
    bdrv_register(&bdrv_vmdk);
B
bellard 已提交
1520
    bdrv_register(&bdrv_cloop);
1521
    bdrv_register(&bdrv_dmg);
1522
    bdrv_register(&bdrv_bochs);
1523
    bdrv_register(&bdrv_vpc);
B
bellard 已提交
1524
    bdrv_register(&bdrv_vvfat);
B
bellard 已提交
1525
    bdrv_register(&bdrv_qcow2);
1526
    bdrv_register(&bdrv_parallels);
1527
    bdrv_register(&bdrv_nbd);
B
bellard 已提交
1528
}
1529

1530 1531 1532 1533 1534 1535 1536 1537 1538 1539
void aio_pool_init(AIOPool *pool, int aiocb_size,
                   void (*cancel)(BlockDriverAIOCB *acb))
{
    pool->aiocb_size = aiocb_size;
    pool->cancel = cancel;
    pool->free_aiocb = NULL;
}

void *qemu_aio_get_pool(AIOPool *pool, BlockDriverState *bs,
                        BlockDriverCompletionFunc *cb, void *opaque)
1540 1541 1542
{
    BlockDriverAIOCB *acb;

1543 1544 1545
    if (pool->free_aiocb) {
        acb = pool->free_aiocb;
        pool->free_aiocb = acb->next;
1546
    } else {
1547 1548
        acb = qemu_mallocz(pool->aiocb_size);
        acb->pool = pool;
1549 1550 1551 1552 1553 1554 1555
    }
    acb->bs = bs;
    acb->cb = cb;
    acb->opaque = opaque;
    return acb;
}

1556 1557 1558 1559 1560 1561
void *qemu_aio_get(BlockDriverState *bs, BlockDriverCompletionFunc *cb,
                   void *opaque)
{
    return qemu_aio_get_pool(&bs->drv->aio_pool, bs, cb, opaque);
}

1562 1563
void qemu_aio_release(void *p)
{
1564 1565 1566 1567
    BlockDriverAIOCB *acb = (BlockDriverAIOCB *)p;
    AIOPool *pool = acb->pool;
    acb->next = pool->free_aiocb;
    pool->free_aiocb = acb;
1568
}
B
bellard 已提交
1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589

/**************************************************************/
/* 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
1590
 * function. It is currently only used for floppy disks
B
bellard 已提交
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 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643
 */
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
 */
void bdrv_eject(BlockDriverState *bs, int eject_flag)
{
    BlockDriver *drv = bs->drv;
    int ret;

    if (!drv || !drv->bdrv_eject) {
        ret = -ENOTSUP;
    } else {
        ret = drv->bdrv_eject(bs, eject_flag);
    }
    if (ret == -ENOTSUP) {
        if (eject_flag)
            bdrv_close(bs);
    }
}

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);
    }
}
1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654

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

1656 1657 1658
BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
        unsigned long int req, void *buf,
        BlockDriverCompletionFunc *cb, void *opaque)
1659
{
1660
    BlockDriver *drv = bs->drv;
1661

1662 1663 1664
    if (drv && drv->bdrv_aio_ioctl)
        return drv->bdrv_aio_ioctl(bs, req, buf, cb, opaque);
    return NULL;
1665
}