Statistics
| Branch: | Revision:

root / block.c @ bbf0a440

History | View | Annotate | Download (70.5 kB)

1
/*
2
 * QEMU System Emulator block driver
3
 *
4
 * Copyright (c) 2003 Fabrice Bellard
5
 *
6
 * Permission is hereby granted, free of charge, to any person obtaining a copy
7
 * of this software and associated documentation files (the "Software"), to deal
8
 * in the Software without restriction, including without limitation the rights
9
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10
 * copies of the Software, and to permit persons to whom the Software is
11
 * furnished to do so, subject to the following conditions:
12
 *
13
 * The above copyright notice and this permission notice shall be included in
14
 * all copies or substantial portions of the Software.
15
 *
16
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22
 * THE SOFTWARE.
23
 */
24
#include "config-host.h"
25
#include "qemu-common.h"
26
#include "trace.h"
27
#include "monitor.h"
28
#include "block_int.h"
29
#include "module.h"
30
#include "qemu-objects.h"
31

    
32
#ifdef CONFIG_BSD
33
#include <sys/types.h>
34
#include <sys/stat.h>
35
#include <sys/ioctl.h>
36
#include <sys/queue.h>
37
#ifndef __DragonFly__
38
#include <sys/disk.h>
39
#endif
40
#endif
41

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

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

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

    
64
static QLIST_HEAD(, BlockDriver) bdrv_drivers =
65
    QLIST_HEAD_INITIALIZER(bdrv_drivers);
66

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

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

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

    
93
/* if filename is absolute, just copy it to dest. Otherwise, build a
94
   path to it by considering it is relative to base_path. URL are
95
   supported. */
96
void path_combine(char *dest, int dest_size,
97
                  const char *base_path,
98
                  const char *filename)
99
{
100
    const char *p, *p1;
101
    int len;
102

    
103
    if (dest_size <= 0)
104
        return;
105
    if (path_is_absolute(filename)) {
106
        pstrcpy(dest, dest_size, filename);
107
    } else {
108
        p = strchr(base_path, ':');
109
        if (p)
110
            p++;
111
        else
112
            p = base_path;
113
        p1 = strrchr(base_path, '/');
114
#ifdef _WIN32
115
        {
116
            const char *p2;
117
            p2 = strrchr(base_path, '\\');
118
            if (!p1 || p2 > p1)
119
                p1 = p2;
120
        }
121
#endif
122
        if (p1)
123
            p1++;
124
        else
125
            p1 = base_path;
126
        if (p1 > p)
127
            p = p1;
128
        len = p - base_path;
129
        if (len > dest_size - 1)
130
            len = dest_size - 1;
131
        memcpy(dest, base_path, len);
132
        dest[len] = '\0';
133
        pstrcat(dest, dest_size, filename);
134
    }
135
}
136

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

    
149
    if (!bdrv->bdrv_aio_flush)
150
        bdrv->bdrv_aio_flush = bdrv_aio_flush_em;
151

    
152
    QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list);
153
}
154

    
155
/* create a new block device (by default it is empty) */
156
BlockDriverState *bdrv_new(const char *device_name)
157
{
158
    BlockDriverState *bs;
159

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

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

    
179
static int bdrv_is_whitelisted(BlockDriver *drv)
180
{
181
    static const char *whitelist[] = {
182
        CONFIG_BDRV_WHITELIST
183
    };
184
    const char **p;
185

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

    
189
    for (p = whitelist; *p; p++) {
190
        if (!strcmp(drv->format_name, *p)) {
191
            return 1;
192
        }
193
    }
194
    return 0;
195
}
196

    
197
BlockDriver *bdrv_find_whitelisted_format(const char *format_name)
198
{
199
    BlockDriver *drv = bdrv_find_format(format_name);
200
    return drv && bdrv_is_whitelisted(drv) ? drv : NULL;
201
}
202

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

    
209
    return drv->bdrv_create(filename, options);
210
}
211

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

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

    
221
    return bdrv_create(drv, filename, options);
222
}
223

    
224
#ifdef _WIN32
225
void get_tmp_filename(char *filename, int size)
226
{
227
    char temp_dir[MAX_PATH];
228

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

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

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

    
267
/*
268
 * Detect host devices. By convention, /dev/cdrom[N] is always
269
 * recognized as a host CDROM.
270
 */
271
static BlockDriver *find_hdev_driver(const char *filename)
272
{
273
    int score_max = 0, score;
274
    BlockDriver *drv = NULL, *d;
275

    
276
    QLIST_FOREACH(d, &bdrv_drivers, list) {
277
        if (d->bdrv_probe_device) {
278
            score = d->bdrv_probe_device(filename);
279
            if (score > score_max) {
280
                score_max = score;
281
                drv = d;
282
            }
283
        }
284
    }
285

    
286
    return drv;
287
}
288

    
289
BlockDriver *bdrv_find_protocol(const char *filename)
290
{
291
    BlockDriver *drv1;
292
    char protocol[128];
293
    int len;
294
    const char *p;
295

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

    
298
    /*
299
     * XXX(hch): we really should not let host device detection
300
     * override an explicit protocol specification, but moving this
301
     * later breaks access to device names with colons in them.
302
     * Thanks to the brain-dead persistent naming schemes on udev-
303
     * based Linux systems those actually are quite common.
304
     */
305
    drv1 = find_hdev_driver(filename);
306
    if (drv1) {
307
        return drv1;
308
    }
309

    
310
#ifdef _WIN32
311
     if (is_windows_drive(filename) ||
312
         is_windows_drive_prefix(filename))
313
         return bdrv_find_format("file");
314
#endif
315

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

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

    
341
    ret = bdrv_file_open(&bs, filename, 0);
342
    if (ret < 0) {
343
        *pdrv = NULL;
344
        return ret;
345
    }
346

    
347
    /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
348
    if (bs->sg || !bdrv_is_inserted(bs)) {
349
        bdrv_delete(bs);
350
        drv = bdrv_find_format("raw");
351
        if (!drv) {
352
            ret = -ENOENT;
353
        }
354
        *pdrv = drv;
355
        return ret;
356
    }
357

    
358
    ret = bdrv_pread(bs, 0, buf, sizeof(buf));
359
    bdrv_delete(bs);
360
    if (ret < 0) {
361
        *pdrv = NULL;
362
        return ret;
363
    }
364

    
365
    score_max = 0;
366
    drv = NULL;
367
    QLIST_FOREACH(drv1, &bdrv_drivers, list) {
368
        if (drv1->bdrv_probe) {
369
            score = drv1->bdrv_probe(buf, ret, filename);
370
            if (score > score_max) {
371
                score_max = score;
372
                drv = drv1;
373
            }
374
        }
375
    }
376
    if (!drv) {
377
        ret = -ENOENT;
378
    }
379
    *pdrv = drv;
380
    return ret;
381
}
382

    
383
/**
384
 * Set the current 'total_sectors' value
385
 */
386
static int refresh_total_sectors(BlockDriverState *bs, int64_t hint)
387
{
388
    BlockDriver *drv = bs->drv;
389

    
390
    /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
391
    if (bs->sg)
392
        return 0;
393

    
394
    /* query actual device if possible, otherwise just trust the hint */
395
    if (drv->bdrv_getlength) {
396
        int64_t length = drv->bdrv_getlength(bs);
397
        if (length < 0) {
398
            return length;
399
        }
400
        hint = length >> BDRV_SECTOR_BITS;
401
    }
402

    
403
    bs->total_sectors = hint;
404
    return 0;
405
}
406

    
407
/*
408
 * Common part for opening disk images and files
409
 */
410
static int bdrv_open_common(BlockDriverState *bs, const char *filename,
411
    int flags, BlockDriver *drv)
412
{
413
    int ret, open_flags;
414

    
415
    assert(drv != NULL);
416

    
417
    bs->file = NULL;
418
    bs->total_sectors = 0;
419
    bs->encrypted = 0;
420
    bs->valid_key = 0;
421
    bs->open_flags = flags;
422
    /* buffer_alignment defaulted to 512, drivers can change this value */
423
    bs->buffer_alignment = 512;
424

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

    
427
    if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv)) {
428
        return -ENOTSUP;
429
    }
430

    
431
    bs->drv = drv;
432
    bs->opaque = qemu_mallocz(drv->instance_size);
433

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

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

    
449
    /*
450
     * Snapshots should be writeable.
451
     */
452
    if (bs->is_temporary) {
453
        open_flags |= BDRV_O_RDWR;
454
    }
455

    
456
    /* Open the image, either directly or using a protocol */
457
    if (drv->bdrv_file_open) {
458
        ret = drv->bdrv_file_open(bs, filename, open_flags);
459
    } else {
460
        ret = bdrv_file_open(&bs->file, filename, open_flags);
461
        if (ret >= 0) {
462
            ret = drv->bdrv_open(bs, open_flags);
463
        }
464
    }
465

    
466
    if (ret < 0) {
467
        goto free_and_fail;
468
    }
469

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

    
472
    ret = refresh_total_sectors(bs, bs->total_sectors);
473
    if (ret < 0) {
474
        goto free_and_fail;
475
    }
476

    
477
#ifndef _WIN32
478
    if (bs->is_temporary) {
479
        unlink(filename);
480
    }
481
#endif
482
    return 0;
483

    
484
free_and_fail:
485
    if (bs->file) {
486
        bdrv_delete(bs->file);
487
        bs->file = NULL;
488
    }
489
    qemu_free(bs->opaque);
490
    bs->opaque = NULL;
491
    bs->drv = NULL;
492
    return ret;
493
}
494

    
495
/*
496
 * Opens a file using a protocol (file, host_device, nbd, ...)
497
 */
498
int bdrv_file_open(BlockDriverState **pbs, const char *filename, int flags)
499
{
500
    BlockDriverState *bs;
501
    BlockDriver *drv;
502
    int ret;
503

    
504
    drv = bdrv_find_protocol(filename);
505
    if (!drv) {
506
        return -ENOENT;
507
    }
508

    
509
    bs = bdrv_new("");
510
    ret = bdrv_open_common(bs, filename, flags, drv);
511
    if (ret < 0) {
512
        bdrv_delete(bs);
513
        return ret;
514
    }
515
    bs->growable = 1;
516
    *pbs = bs;
517
    return 0;
518
}
519

    
520
/*
521
 * Opens a disk image (raw, qcow2, vmdk, ...)
522
 */
523
int bdrv_open(BlockDriverState *bs, const char *filename, int flags,
524
              BlockDriver *drv)
525
{
526
    int ret;
527

    
528
    if (flags & BDRV_O_SNAPSHOT) {
529
        BlockDriverState *bs1;
530
        int64_t total_size;
531
        int is_protocol = 0;
532
        BlockDriver *bdrv_qcow2;
533
        QEMUOptionParameter *options;
534
        char tmp_filename[PATH_MAX];
535
        char backing_filename[PATH_MAX];
536

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

    
540
        /* if there is a backing file, use it */
541
        bs1 = bdrv_new("");
542
        ret = bdrv_open(bs1, filename, 0, drv);
543
        if (ret < 0) {
544
            bdrv_delete(bs1);
545
            return ret;
546
        }
547
        total_size = bdrv_getlength(bs1) & BDRV_SECTOR_MASK;
548

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

    
552
        bdrv_delete(bs1);
553

    
554
        get_tmp_filename(tmp_filename, sizeof(tmp_filename));
555

    
556
        /* Real path is meaningless for protocols */
557
        if (is_protocol)
558
            snprintf(backing_filename, sizeof(backing_filename),
559
                     "%s", filename);
560
        else if (!realpath(filename, backing_filename))
561
            return -errno;
562

    
563
        bdrv_qcow2 = bdrv_find_format("qcow2");
564
        options = parse_option_parameters("", bdrv_qcow2->create_options, NULL);
565

    
566
        set_option_parameter_int(options, BLOCK_OPT_SIZE, total_size);
567
        set_option_parameter(options, BLOCK_OPT_BACKING_FILE, backing_filename);
568
        if (drv) {
569
            set_option_parameter(options, BLOCK_OPT_BACKING_FMT,
570
                drv->format_name);
571
        }
572

    
573
        ret = bdrv_create(bdrv_qcow2, tmp_filename, options);
574
        free_option_parameters(options);
575
        if (ret < 0) {
576
            return ret;
577
        }
578

    
579
        filename = tmp_filename;
580
        drv = bdrv_qcow2;
581
        bs->is_temporary = 1;
582
    }
583

    
584
    /* Find the right image format driver */
585
    if (!drv) {
586
        ret = find_image_format(filename, &drv);
587
    }
588

    
589
    if (!drv) {
590
        goto unlink_and_fail;
591
    }
592

    
593
    /* Open the image */
594
    ret = bdrv_open_common(bs, filename, flags, drv);
595
    if (ret < 0) {
596
        goto unlink_and_fail;
597
    }
598

    
599
    /* If there is a backing file, use it */
600
    if ((flags & BDRV_O_NO_BACKING) == 0 && bs->backing_file[0] != '\0') {
601
        char backing_filename[PATH_MAX];
602
        int back_flags;
603
        BlockDriver *back_drv = NULL;
604

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

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

    
615
        ret = bdrv_open(bs->backing_hd, backing_filename, back_flags, back_drv);
616
        if (ret < 0) {
617
            bdrv_close(bs);
618
            return ret;
619
        }
620
        if (bs->is_temporary) {
621
            bs->backing_hd->keep_read_only = !(flags & BDRV_O_RDWR);
622
        } else {
623
            /* base image inherits from "parent" */
624
            bs->backing_hd->keep_read_only = bs->keep_read_only;
625
        }
626
    }
627

    
628
    if (!bdrv_key_required(bs)) {
629
        /* call the change callback */
630
        bs->media_changed = 1;
631
        if (bs->change_cb)
632
            bs->change_cb(bs->change_opaque);
633
    }
634

    
635
    return 0;
636

    
637
unlink_and_fail:
638
    if (bs->is_temporary) {
639
        unlink(filename);
640
    }
641
    return ret;
642
}
643

    
644
void bdrv_close(BlockDriverState *bs)
645
{
646
    if (bs->drv) {
647
        if (bs == bs_snapshots) {
648
            bs_snapshots = NULL;
649
        }
650
        if (bs->backing_hd) {
651
            bdrv_delete(bs->backing_hd);
652
            bs->backing_hd = NULL;
653
        }
654
        bs->drv->bdrv_close(bs);
655
        qemu_free(bs->opaque);
656
#ifdef _WIN32
657
        if (bs->is_temporary) {
658
            unlink(bs->filename);
659
        }
660
#endif
661
        bs->opaque = NULL;
662
        bs->drv = NULL;
663

    
664
        if (bs->file != NULL) {
665
            bdrv_close(bs->file);
666
        }
667

    
668
        /* call the change callback */
669
        bs->media_changed = 1;
670
        if (bs->change_cb)
671
            bs->change_cb(bs->change_opaque);
672
    }
673
}
674

    
675
void bdrv_close_all(void)
676
{
677
    BlockDriverState *bs;
678

    
679
    QTAILQ_FOREACH(bs, &bdrv_states, list) {
680
        bdrv_close(bs);
681
    }
682
}
683

    
684
void bdrv_delete(BlockDriverState *bs)
685
{
686
    assert(!bs->peer);
687

    
688
    /* remove from list, if necessary */
689
    if (bs->device_name[0] != '\0') {
690
        QTAILQ_REMOVE(&bdrv_states, bs, list);
691
    }
692

    
693
    bdrv_close(bs);
694
    if (bs->file != NULL) {
695
        bdrv_delete(bs->file);
696
    }
697

    
698
    assert(bs != bs_snapshots);
699
    qemu_free(bs);
700
}
701

    
702
int bdrv_attach(BlockDriverState *bs, DeviceState *qdev)
703
{
704
    if (bs->peer) {
705
        return -EBUSY;
706
    }
707
    bs->peer = qdev;
708
    return 0;
709
}
710

    
711
void bdrv_detach(BlockDriverState *bs, DeviceState *qdev)
712
{
713
    assert(bs->peer == qdev);
714
    bs->peer = NULL;
715
}
716

    
717
DeviceState *bdrv_get_attached(BlockDriverState *bs)
718
{
719
    return bs->peer;
720
}
721

    
722
/*
723
 * Run consistency checks on an image
724
 *
725
 * Returns 0 if the check could be completed (it doesn't mean that the image is
726
 * free of errors) or -errno when an internal error occured. The results of the
727
 * check are stored in res.
728
 */
729
int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res)
730
{
731
    if (bs->drv->bdrv_check == NULL) {
732
        return -ENOTSUP;
733
    }
734

    
735
    memset(res, 0, sizeof(*res));
736
    return bs->drv->bdrv_check(bs, res);
737
}
738

    
739
#define COMMIT_BUF_SECTORS 2048
740

    
741
/* commit COW file into the raw image */
742
int bdrv_commit(BlockDriverState *bs)
743
{
744
    BlockDriver *drv = bs->drv;
745
    BlockDriver *backing_drv;
746
    int64_t sector, total_sectors;
747
    int n, ro, open_flags;
748
    int ret = 0, rw_ret = 0;
749
    uint8_t *buf;
750
    char filename[1024];
751
    BlockDriverState *bs_rw, *bs_ro;
752

    
753
    if (!drv)
754
        return -ENOMEDIUM;
755
    
756
    if (!bs->backing_hd) {
757
        return -ENOTSUP;
758
    }
759

    
760
    if (bs->backing_hd->keep_read_only) {
761
        return -EACCES;
762
    }
763

    
764
    backing_drv = bs->backing_hd->drv;
765
    ro = bs->backing_hd->read_only;
766
    strncpy(filename, bs->backing_hd->filename, sizeof(filename));
767
    open_flags =  bs->backing_hd->open_flags;
768

    
769
    if (ro) {
770
        /* re-open as RW */
771
        bdrv_delete(bs->backing_hd);
772
        bs->backing_hd = NULL;
773
        bs_rw = bdrv_new("");
774
        rw_ret = bdrv_open(bs_rw, filename, open_flags | BDRV_O_RDWR,
775
            backing_drv);
776
        if (rw_ret < 0) {
777
            bdrv_delete(bs_rw);
778
            /* try to re-open read-only */
779
            bs_ro = bdrv_new("");
780
            ret = bdrv_open(bs_ro, filename, open_flags & ~BDRV_O_RDWR,
781
                backing_drv);
782
            if (ret < 0) {
783
                bdrv_delete(bs_ro);
784
                /* drive not functional anymore */
785
                bs->drv = NULL;
786
                return ret;
787
            }
788
            bs->backing_hd = bs_ro;
789
            return rw_ret;
790
        }
791
        bs->backing_hd = bs_rw;
792
    }
793

    
794
    total_sectors = bdrv_getlength(bs) >> BDRV_SECTOR_BITS;
795
    buf = qemu_malloc(COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE);
796

    
797
    for (sector = 0; sector < total_sectors; sector += n) {
798
        if (drv->bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n)) {
799

    
800
            if (bdrv_read(bs, sector, buf, n) != 0) {
801
                ret = -EIO;
802
                goto ro_cleanup;
803
            }
804

    
805
            if (bdrv_write(bs->backing_hd, sector, buf, n) != 0) {
806
                ret = -EIO;
807
                goto ro_cleanup;
808
            }
809
        }
810
    }
811

    
812
    if (drv->bdrv_make_empty) {
813
        ret = drv->bdrv_make_empty(bs);
814
        bdrv_flush(bs);
815
    }
816

    
817
    /*
818
     * Make sure all data we wrote to the backing device is actually
819
     * stable on disk.
820
     */
821
    if (bs->backing_hd)
822
        bdrv_flush(bs->backing_hd);
823

    
824
ro_cleanup:
825
    qemu_free(buf);
826

    
827
    if (ro) {
828
        /* re-open as RO */
829
        bdrv_delete(bs->backing_hd);
830
        bs->backing_hd = NULL;
831
        bs_ro = bdrv_new("");
832
        ret = bdrv_open(bs_ro, filename, open_flags & ~BDRV_O_RDWR,
833
            backing_drv);
834
        if (ret < 0) {
835
            bdrv_delete(bs_ro);
836
            /* drive not functional anymore */
837
            bs->drv = NULL;
838
            return ret;
839
        }
840
        bs->backing_hd = bs_ro;
841
        bs->backing_hd->keep_read_only = 0;
842
    }
843

    
844
    return ret;
845
}
846

    
847
void bdrv_commit_all(void)
848
{
849
    BlockDriverState *bs;
850

    
851
    QTAILQ_FOREACH(bs, &bdrv_states, list) {
852
        bdrv_commit(bs);
853
    }
854
}
855

    
856
/*
857
 * Return values:
858
 * 0        - success
859
 * -EINVAL  - backing format specified, but no file
860
 * -ENOSPC  - can't update the backing file because no space is left in the
861
 *            image file header
862
 * -ENOTSUP - format driver doesn't support changing the backing file
863
 */
864
int bdrv_change_backing_file(BlockDriverState *bs,
865
    const char *backing_file, const char *backing_fmt)
866
{
867
    BlockDriver *drv = bs->drv;
868

    
869
    if (drv->bdrv_change_backing_file != NULL) {
870
        return drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
871
    } else {
872
        return -ENOTSUP;
873
    }
874
}
875

    
876
static int bdrv_check_byte_request(BlockDriverState *bs, int64_t offset,
877
                                   size_t size)
878
{
879
    int64_t len;
880

    
881
    if (!bdrv_is_inserted(bs))
882
        return -ENOMEDIUM;
883

    
884
    if (bs->growable)
885
        return 0;
886

    
887
    len = bdrv_getlength(bs);
888

    
889
    if (offset < 0)
890
        return -EIO;
891

    
892
    if ((offset > len) || (len - offset < size))
893
        return -EIO;
894

    
895
    return 0;
896
}
897

    
898
static int bdrv_check_request(BlockDriverState *bs, int64_t sector_num,
899
                              int nb_sectors)
900
{
901
    return bdrv_check_byte_request(bs, sector_num * BDRV_SECTOR_SIZE,
902
                                   nb_sectors * BDRV_SECTOR_SIZE);
903
}
904

    
905
/* return < 0 if error. See bdrv_write() for the return codes */
906
int bdrv_read(BlockDriverState *bs, int64_t sector_num,
907
              uint8_t *buf, int nb_sectors)
908
{
909
    BlockDriver *drv = bs->drv;
910

    
911
    if (!drv)
912
        return -ENOMEDIUM;
913
    if (bdrv_check_request(bs, sector_num, nb_sectors))
914
        return -EIO;
915

    
916
    return drv->bdrv_read(bs, sector_num, buf, nb_sectors);
917
}
918

    
919
static void set_dirty_bitmap(BlockDriverState *bs, int64_t sector_num,
920
                             int nb_sectors, int dirty)
921
{
922
    int64_t start, end;
923
    unsigned long val, idx, bit;
924

    
925
    start = sector_num / BDRV_SECTORS_PER_DIRTY_CHUNK;
926
    end = (sector_num + nb_sectors - 1) / BDRV_SECTORS_PER_DIRTY_CHUNK;
927

    
928
    for (; start <= end; start++) {
929
        idx = start / (sizeof(unsigned long) * 8);
930
        bit = start % (sizeof(unsigned long) * 8);
931
        val = bs->dirty_bitmap[idx];
932
        if (dirty) {
933
            if (!(val & (1 << bit))) {
934
                bs->dirty_count++;
935
                val |= 1 << bit;
936
            }
937
        } else {
938
            if (val & (1 << bit)) {
939
                bs->dirty_count--;
940
                val &= ~(1 << bit);
941
            }
942
        }
943
        bs->dirty_bitmap[idx] = val;
944
    }
945
}
946

    
947
/* Return < 0 if error. Important errors are:
948
  -EIO         generic I/O error (may happen for all errors)
949
  -ENOMEDIUM   No media inserted.
950
  -EINVAL      Invalid sector number or nb_sectors
951
  -EACCES      Trying to write a read-only device
952
*/
953
int bdrv_write(BlockDriverState *bs, int64_t sector_num,
954
               const uint8_t *buf, int nb_sectors)
955
{
956
    BlockDriver *drv = bs->drv;
957
    if (!bs->drv)
958
        return -ENOMEDIUM;
959
    if (bs->read_only)
960
        return -EACCES;
961
    if (bdrv_check_request(bs, sector_num, nb_sectors))
962
        return -EIO;
963

    
964
    if (bs->dirty_bitmap) {
965
        set_dirty_bitmap(bs, sector_num, nb_sectors, 1);
966
    }
967

    
968
    if (bs->wr_highest_sector < sector_num + nb_sectors - 1) {
969
        bs->wr_highest_sector = sector_num + nb_sectors - 1;
970
    }
971

    
972
    return drv->bdrv_write(bs, sector_num, buf, nb_sectors);
973
}
974

    
975
int bdrv_pread(BlockDriverState *bs, int64_t offset,
976
               void *buf, int count1)
977
{
978
    uint8_t tmp_buf[BDRV_SECTOR_SIZE];
979
    int len, nb_sectors, count;
980
    int64_t sector_num;
981
    int ret;
982

    
983
    count = count1;
984
    /* first read to align to sector start */
985
    len = (BDRV_SECTOR_SIZE - offset) & (BDRV_SECTOR_SIZE - 1);
986
    if (len > count)
987
        len = count;
988
    sector_num = offset >> BDRV_SECTOR_BITS;
989
    if (len > 0) {
990
        if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
991
            return ret;
992
        memcpy(buf, tmp_buf + (offset & (BDRV_SECTOR_SIZE - 1)), len);
993
        count -= len;
994
        if (count == 0)
995
            return count1;
996
        sector_num++;
997
        buf += len;
998
    }
999

    
1000
    /* read the sectors "in place" */
1001
    nb_sectors = count >> BDRV_SECTOR_BITS;
1002
    if (nb_sectors > 0) {
1003
        if ((ret = bdrv_read(bs, sector_num, buf, nb_sectors)) < 0)
1004
            return ret;
1005
        sector_num += nb_sectors;
1006
        len = nb_sectors << BDRV_SECTOR_BITS;
1007
        buf += len;
1008
        count -= len;
1009
    }
1010

    
1011
    /* add data from the last sector */
1012
    if (count > 0) {
1013
        if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
1014
            return ret;
1015
        memcpy(buf, tmp_buf, count);
1016
    }
1017
    return count1;
1018
}
1019

    
1020
int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
1021
                const void *buf, int count1)
1022
{
1023
    uint8_t tmp_buf[BDRV_SECTOR_SIZE];
1024
    int len, nb_sectors, count;
1025
    int64_t sector_num;
1026
    int ret;
1027

    
1028
    count = count1;
1029
    /* first write to align to sector start */
1030
    len = (BDRV_SECTOR_SIZE - offset) & (BDRV_SECTOR_SIZE - 1);
1031
    if (len > count)
1032
        len = count;
1033
    sector_num = offset >> BDRV_SECTOR_BITS;
1034
    if (len > 0) {
1035
        if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
1036
            return ret;
1037
        memcpy(tmp_buf + (offset & (BDRV_SECTOR_SIZE - 1)), buf, len);
1038
        if ((ret = bdrv_write(bs, sector_num, tmp_buf, 1)) < 0)
1039
            return ret;
1040
        count -= len;
1041
        if (count == 0)
1042
            return count1;
1043
        sector_num++;
1044
        buf += len;
1045
    }
1046

    
1047
    /* write the sectors "in place" */
1048
    nb_sectors = count >> BDRV_SECTOR_BITS;
1049
    if (nb_sectors > 0) {
1050
        if ((ret = bdrv_write(bs, sector_num, buf, nb_sectors)) < 0)
1051
            return ret;
1052
        sector_num += nb_sectors;
1053
        len = nb_sectors << BDRV_SECTOR_BITS;
1054
        buf += len;
1055
        count -= len;
1056
    }
1057

    
1058
    /* add data from the last sector */
1059
    if (count > 0) {
1060
        if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
1061
            return ret;
1062
        memcpy(tmp_buf, buf, count);
1063
        if ((ret = bdrv_write(bs, sector_num, tmp_buf, 1)) < 0)
1064
            return ret;
1065
    }
1066
    return count1;
1067
}
1068

    
1069
/*
1070
 * Writes to the file and ensures that no writes are reordered across this
1071
 * request (acts as a barrier)
1072
 *
1073
 * Returns 0 on success, -errno in error cases.
1074
 */
1075
int bdrv_pwrite_sync(BlockDriverState *bs, int64_t offset,
1076
    const void *buf, int count)
1077
{
1078
    int ret;
1079

    
1080
    ret = bdrv_pwrite(bs, offset, buf, count);
1081
    if (ret < 0) {
1082
        return ret;
1083
    }
1084

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

    
1090
    return 0;
1091
}
1092

    
1093
/*
1094
 * Writes to the file and ensures that no writes are reordered across this
1095
 * request (acts as a barrier)
1096
 *
1097
 * Returns 0 on success, -errno in error cases.
1098
 */
1099
int bdrv_write_sync(BlockDriverState *bs, int64_t sector_num,
1100
    const uint8_t *buf, int nb_sectors)
1101
{
1102
    return bdrv_pwrite_sync(bs, BDRV_SECTOR_SIZE * sector_num,
1103
        buf, BDRV_SECTOR_SIZE * nb_sectors);
1104
}
1105

    
1106
/**
1107
 * Truncate file to 'offset' bytes (needed only for file protocols)
1108
 */
1109
int bdrv_truncate(BlockDriverState *bs, int64_t offset)
1110
{
1111
    BlockDriver *drv = bs->drv;
1112
    int ret;
1113
    if (!drv)
1114
        return -ENOMEDIUM;
1115
    if (!drv->bdrv_truncate)
1116
        return -ENOTSUP;
1117
    if (bs->read_only)
1118
        return -EACCES;
1119
    ret = drv->bdrv_truncate(bs, offset);
1120
    if (ret == 0) {
1121
        ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
1122
    }
1123
    return ret;
1124
}
1125

    
1126
/**
1127
 * Length of a file in bytes. Return < 0 if error or unknown.
1128
 */
1129
int64_t bdrv_getlength(BlockDriverState *bs)
1130
{
1131
    BlockDriver *drv = bs->drv;
1132
    if (!drv)
1133
        return -ENOMEDIUM;
1134

    
1135
    /* Fixed size devices use the total_sectors value for speed instead of
1136
       issuing a length query (like lseek) on each call.  Also, legacy block
1137
       drivers don't provide a bdrv_getlength function and must use
1138
       total_sectors. */
1139
    if (!bs->growable || !drv->bdrv_getlength) {
1140
        return bs->total_sectors * BDRV_SECTOR_SIZE;
1141
    }
1142
    return drv->bdrv_getlength(bs);
1143
}
1144

    
1145
/* return 0 as number of sectors if no device present or error */
1146
void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
1147
{
1148
    int64_t length;
1149
    length = bdrv_getlength(bs);
1150
    if (length < 0)
1151
        length = 0;
1152
    else
1153
        length = length >> BDRV_SECTOR_BITS;
1154
    *nb_sectors_ptr = length;
1155
}
1156

    
1157
struct partition {
1158
        uint8_t boot_ind;           /* 0x80 - active */
1159
        uint8_t head;               /* starting head */
1160
        uint8_t sector;             /* starting sector */
1161
        uint8_t cyl;                /* starting cylinder */
1162
        uint8_t sys_ind;            /* What partition type */
1163
        uint8_t end_head;           /* end head */
1164
        uint8_t end_sector;         /* end sector */
1165
        uint8_t end_cyl;            /* end cylinder */
1166
        uint32_t start_sect;        /* starting sector counting from 0 */
1167
        uint32_t nr_sects;          /* nr of sectors in partition */
1168
} __attribute__((packed));
1169

    
1170
/* try to guess the disk logical geometry from the MSDOS partition table. Return 0 if OK, -1 if could not guess */
1171
static int guess_disk_lchs(BlockDriverState *bs,
1172
                           int *pcylinders, int *pheads, int *psectors)
1173
{
1174
    uint8_t buf[BDRV_SECTOR_SIZE];
1175
    int ret, i, heads, sectors, cylinders;
1176
    struct partition *p;
1177
    uint32_t nr_sects;
1178
    uint64_t nb_sectors;
1179

    
1180
    bdrv_get_geometry(bs, &nb_sectors);
1181

    
1182
    ret = bdrv_read(bs, 0, buf, 1);
1183
    if (ret < 0)
1184
        return -1;
1185
    /* test msdos magic */
1186
    if (buf[510] != 0x55 || buf[511] != 0xaa)
1187
        return -1;
1188
    for(i = 0; i < 4; i++) {
1189
        p = ((struct partition *)(buf + 0x1be)) + i;
1190
        nr_sects = le32_to_cpu(p->nr_sects);
1191
        if (nr_sects && p->end_head) {
1192
            /* We make the assumption that the partition terminates on
1193
               a cylinder boundary */
1194
            heads = p->end_head + 1;
1195
            sectors = p->end_sector & 63;
1196
            if (sectors == 0)
1197
                continue;
1198
            cylinders = nb_sectors / (heads * sectors);
1199
            if (cylinders < 1 || cylinders > 16383)
1200
                continue;
1201
            *pheads = heads;
1202
            *psectors = sectors;
1203
            *pcylinders = cylinders;
1204
#if 0
1205
            printf("guessed geometry: LCHS=%d %d %d\n",
1206
                   cylinders, heads, sectors);
1207
#endif
1208
            return 0;
1209
        }
1210
    }
1211
    return -1;
1212
}
1213

    
1214
void bdrv_guess_geometry(BlockDriverState *bs, int *pcyls, int *pheads, int *psecs)
1215
{
1216
    int translation, lba_detected = 0;
1217
    int cylinders, heads, secs;
1218
    uint64_t nb_sectors;
1219

    
1220
    /* if a geometry hint is available, use it */
1221
    bdrv_get_geometry(bs, &nb_sectors);
1222
    bdrv_get_geometry_hint(bs, &cylinders, &heads, &secs);
1223
    translation = bdrv_get_translation_hint(bs);
1224
    if (cylinders != 0) {
1225
        *pcyls = cylinders;
1226
        *pheads = heads;
1227
        *psecs = secs;
1228
    } else {
1229
        if (guess_disk_lchs(bs, &cylinders, &heads, &secs) == 0) {
1230
            if (heads > 16) {
1231
                /* if heads > 16, it means that a BIOS LBA
1232
                   translation was active, so the default
1233
                   hardware geometry is OK */
1234
                lba_detected = 1;
1235
                goto default_geometry;
1236
            } else {
1237
                *pcyls = cylinders;
1238
                *pheads = heads;
1239
                *psecs = secs;
1240
                /* disable any translation to be in sync with
1241
                   the logical geometry */
1242
                if (translation == BIOS_ATA_TRANSLATION_AUTO) {
1243
                    bdrv_set_translation_hint(bs,
1244
                                              BIOS_ATA_TRANSLATION_NONE);
1245
                }
1246
            }
1247
        } else {
1248
        default_geometry:
1249
            /* if no geometry, use a standard physical disk geometry */
1250
            cylinders = nb_sectors / (16 * 63);
1251

    
1252
            if (cylinders > 16383)
1253
                cylinders = 16383;
1254
            else if (cylinders < 2)
1255
                cylinders = 2;
1256
            *pcyls = cylinders;
1257
            *pheads = 16;
1258
            *psecs = 63;
1259
            if ((lba_detected == 1) && (translation == BIOS_ATA_TRANSLATION_AUTO)) {
1260
                if ((*pcyls * *pheads) <= 131072) {
1261
                    bdrv_set_translation_hint(bs,
1262
                                              BIOS_ATA_TRANSLATION_LARGE);
1263
                } else {
1264
                    bdrv_set_translation_hint(bs,
1265
                                              BIOS_ATA_TRANSLATION_LBA);
1266
                }
1267
            }
1268
        }
1269
        bdrv_set_geometry_hint(bs, *pcyls, *pheads, *psecs);
1270
    }
1271
}
1272

    
1273
void bdrv_set_geometry_hint(BlockDriverState *bs,
1274
                            int cyls, int heads, int secs)
1275
{
1276
    bs->cyls = cyls;
1277
    bs->heads = heads;
1278
    bs->secs = secs;
1279
}
1280

    
1281
void bdrv_set_type_hint(BlockDriverState *bs, int type)
1282
{
1283
    bs->type = type;
1284
    bs->removable = ((type == BDRV_TYPE_CDROM ||
1285
                      type == BDRV_TYPE_FLOPPY));
1286
}
1287

    
1288
void bdrv_set_translation_hint(BlockDriverState *bs, int translation)
1289
{
1290
    bs->translation = translation;
1291
}
1292

    
1293
void bdrv_get_geometry_hint(BlockDriverState *bs,
1294
                            int *pcyls, int *pheads, int *psecs)
1295
{
1296
    *pcyls = bs->cyls;
1297
    *pheads = bs->heads;
1298
    *psecs = bs->secs;
1299
}
1300

    
1301
int bdrv_get_type_hint(BlockDriverState *bs)
1302
{
1303
    return bs->type;
1304
}
1305

    
1306
int bdrv_get_translation_hint(BlockDriverState *bs)
1307
{
1308
    return bs->translation;
1309
}
1310

    
1311
void bdrv_set_on_error(BlockDriverState *bs, BlockErrorAction on_read_error,
1312
                       BlockErrorAction on_write_error)
1313
{
1314
    bs->on_read_error = on_read_error;
1315
    bs->on_write_error = on_write_error;
1316
}
1317

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

    
1323
void bdrv_set_removable(BlockDriverState *bs, int removable)
1324
{
1325
    bs->removable = removable;
1326
    if (removable && bs == bs_snapshots) {
1327
        bs_snapshots = NULL;
1328
    }
1329
}
1330

    
1331
int bdrv_is_removable(BlockDriverState *bs)
1332
{
1333
    return bs->removable;
1334
}
1335

    
1336
int bdrv_is_read_only(BlockDriverState *bs)
1337
{
1338
    return bs->read_only;
1339
}
1340

    
1341
int bdrv_is_sg(BlockDriverState *bs)
1342
{
1343
    return bs->sg;
1344
}
1345

    
1346
int bdrv_enable_write_cache(BlockDriverState *bs)
1347
{
1348
    return bs->enable_write_cache;
1349
}
1350

    
1351
/* XXX: no longer used */
1352
void bdrv_set_change_cb(BlockDriverState *bs,
1353
                        void (*change_cb)(void *opaque), void *opaque)
1354
{
1355
    bs->change_cb = change_cb;
1356
    bs->change_opaque = opaque;
1357
}
1358

    
1359
int bdrv_is_encrypted(BlockDriverState *bs)
1360
{
1361
    if (bs->backing_hd && bs->backing_hd->encrypted)
1362
        return 1;
1363
    return bs->encrypted;
1364
}
1365

    
1366
int bdrv_key_required(BlockDriverState *bs)
1367
{
1368
    BlockDriverState *backing_hd = bs->backing_hd;
1369

    
1370
    if (backing_hd && backing_hd->encrypted && !backing_hd->valid_key)
1371
        return 1;
1372
    return (bs->encrypted && !bs->valid_key);
1373
}
1374

    
1375
int bdrv_set_key(BlockDriverState *bs, const char *key)
1376
{
1377
    int ret;
1378
    if (bs->backing_hd && bs->backing_hd->encrypted) {
1379
        ret = bdrv_set_key(bs->backing_hd, key);
1380
        if (ret < 0)
1381
            return ret;
1382
        if (!bs->encrypted)
1383
            return 0;
1384
    }
1385
    if (!bs->encrypted) {
1386
        return -EINVAL;
1387
    } else if (!bs->drv || !bs->drv->bdrv_set_key) {
1388
        return -ENOMEDIUM;
1389
    }
1390
    ret = bs->drv->bdrv_set_key(bs, key);
1391
    if (ret < 0) {
1392
        bs->valid_key = 0;
1393
    } else if (!bs->valid_key) {
1394
        bs->valid_key = 1;
1395
        /* call the change callback now, we skipped it on open */
1396
        bs->media_changed = 1;
1397
        if (bs->change_cb)
1398
            bs->change_cb(bs->change_opaque);
1399
    }
1400
    return ret;
1401
}
1402

    
1403
void bdrv_get_format(BlockDriverState *bs, char *buf, int buf_size)
1404
{
1405
    if (!bs->drv) {
1406
        buf[0] = '\0';
1407
    } else {
1408
        pstrcpy(buf, buf_size, bs->drv->format_name);
1409
    }
1410
}
1411

    
1412
void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
1413
                         void *opaque)
1414
{
1415
    BlockDriver *drv;
1416

    
1417
    QLIST_FOREACH(drv, &bdrv_drivers, list) {
1418
        it(opaque, drv->format_name);
1419
    }
1420
}
1421

    
1422
BlockDriverState *bdrv_find(const char *name)
1423
{
1424
    BlockDriverState *bs;
1425

    
1426
    QTAILQ_FOREACH(bs, &bdrv_states, list) {
1427
        if (!strcmp(name, bs->device_name)) {
1428
            return bs;
1429
        }
1430
    }
1431
    return NULL;
1432
}
1433

    
1434
BlockDriverState *bdrv_next(BlockDriverState *bs)
1435
{
1436
    if (!bs) {
1437
        return QTAILQ_FIRST(&bdrv_states);
1438
    }
1439
    return QTAILQ_NEXT(bs, list);
1440
}
1441

    
1442
void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs), void *opaque)
1443
{
1444
    BlockDriverState *bs;
1445

    
1446
    QTAILQ_FOREACH(bs, &bdrv_states, list) {
1447
        it(opaque, bs);
1448
    }
1449
}
1450

    
1451
const char *bdrv_get_device_name(BlockDriverState *bs)
1452
{
1453
    return bs->device_name;
1454
}
1455

    
1456
void bdrv_flush(BlockDriverState *bs)
1457
{
1458
    if (bs->open_flags & BDRV_O_NO_FLUSH) {
1459
        return;
1460
    }
1461

    
1462
    if (bs->drv && bs->drv->bdrv_flush)
1463
        bs->drv->bdrv_flush(bs);
1464
}
1465

    
1466
void bdrv_flush_all(void)
1467
{
1468
    BlockDriverState *bs;
1469

    
1470
    QTAILQ_FOREACH(bs, &bdrv_states, list) {
1471
        if (bs->drv && !bdrv_is_read_only(bs) &&
1472
            (!bdrv_is_removable(bs) || bdrv_is_inserted(bs))) {
1473
            bdrv_flush(bs);
1474
        }
1475
    }
1476
}
1477

    
1478
int bdrv_has_zero_init(BlockDriverState *bs)
1479
{
1480
    assert(bs->drv);
1481

    
1482
    if (bs->drv->bdrv_has_zero_init) {
1483
        return bs->drv->bdrv_has_zero_init(bs);
1484
    }
1485

    
1486
    return 1;
1487
}
1488

    
1489
/*
1490
 * Returns true iff the specified sector is present in the disk image. Drivers
1491
 * not implementing the functionality are assumed to not support backing files,
1492
 * hence all their sectors are reported as allocated.
1493
 *
1494
 * 'pnum' is set to the number of sectors (including and immediately following
1495
 * the specified sector) that are known to be in the same
1496
 * allocated/unallocated state.
1497
 *
1498
 * 'nb_sectors' is the max value 'pnum' should be set to.
1499
 */
1500
int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
1501
        int *pnum)
1502
{
1503
    int64_t n;
1504
    if (!bs->drv->bdrv_is_allocated) {
1505
        if (sector_num >= bs->total_sectors) {
1506
            *pnum = 0;
1507
            return 0;
1508
        }
1509
        n = bs->total_sectors - sector_num;
1510
        *pnum = (n < nb_sectors) ? (n) : (nb_sectors);
1511
        return 1;
1512
    }
1513
    return bs->drv->bdrv_is_allocated(bs, sector_num, nb_sectors, pnum);
1514
}
1515

    
1516
void bdrv_mon_event(const BlockDriverState *bdrv,
1517
                    BlockMonEventAction action, int is_read)
1518
{
1519
    QObject *data;
1520
    const char *action_str;
1521

    
1522
    switch (action) {
1523
    case BDRV_ACTION_REPORT:
1524
        action_str = "report";
1525
        break;
1526
    case BDRV_ACTION_IGNORE:
1527
        action_str = "ignore";
1528
        break;
1529
    case BDRV_ACTION_STOP:
1530
        action_str = "stop";
1531
        break;
1532
    default:
1533
        abort();
1534
    }
1535

    
1536
    data = qobject_from_jsonf("{ 'device': %s, 'action': %s, 'operation': %s }",
1537
                              bdrv->device_name,
1538
                              action_str,
1539
                              is_read ? "read" : "write");
1540
    monitor_protocol_event(QEVENT_BLOCK_IO_ERROR, data);
1541

    
1542
    qobject_decref(data);
1543
}
1544

    
1545
static void bdrv_print_dict(QObject *obj, void *opaque)
1546
{
1547
    QDict *bs_dict;
1548
    Monitor *mon = opaque;
1549

    
1550
    bs_dict = qobject_to_qdict(obj);
1551

    
1552
    monitor_printf(mon, "%s: type=%s removable=%d",
1553
                        qdict_get_str(bs_dict, "device"),
1554
                        qdict_get_str(bs_dict, "type"),
1555
                        qdict_get_bool(bs_dict, "removable"));
1556

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

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

    
1564
        monitor_printf(mon, " file=");
1565
        monitor_print_filename(mon, qdict_get_str(qdict, "file"));
1566
        if (qdict_haskey(qdict, "backing_file")) {
1567
            monitor_printf(mon, " backing_file=");
1568
            monitor_print_filename(mon, qdict_get_str(qdict, "backing_file"));
1569
        }
1570
        monitor_printf(mon, " ro=%d drv=%s encrypted=%d",
1571
                            qdict_get_bool(qdict, "ro"),
1572
                            qdict_get_str(qdict, "drv"),
1573
                            qdict_get_bool(qdict, "encrypted"));
1574
    } else {
1575
        monitor_printf(mon, " [not inserted]");
1576
    }
1577

    
1578
    monitor_printf(mon, "\n");
1579
}
1580

    
1581
void bdrv_info_print(Monitor *mon, const QObject *data)
1582
{
1583
    qlist_iter(qobject_to_qlist(data), bdrv_print_dict, mon);
1584
}
1585

    
1586
void bdrv_info(Monitor *mon, QObject **ret_data)
1587
{
1588
    QList *bs_list;
1589
    BlockDriverState *bs;
1590

    
1591
    bs_list = qlist_new();
1592

    
1593
    QTAILQ_FOREACH(bs, &bdrv_states, list) {
1594
        QObject *bs_obj;
1595
        const char *type = "unknown";
1596

    
1597
        switch(bs->type) {
1598
        case BDRV_TYPE_HD:
1599
            type = "hd";
1600
            break;
1601
        case BDRV_TYPE_CDROM:
1602
            type = "cdrom";
1603
            break;
1604
        case BDRV_TYPE_FLOPPY:
1605
            type = "floppy";
1606
            break;
1607
        }
1608

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

    
1614
        if (bs->drv) {
1615
            QObject *obj;
1616
            QDict *bs_dict = qobject_to_qdict(bs_obj);
1617

    
1618
            obj = qobject_from_jsonf("{ 'file': %s, 'ro': %i, 'drv': %s, "
1619
                                     "'encrypted': %i }",
1620
                                     bs->filename, bs->read_only,
1621
                                     bs->drv->format_name,
1622
                                     bdrv_is_encrypted(bs));
1623
            if (bs->backing_file[0] != '\0') {
1624
                QDict *qdict = qobject_to_qdict(obj);
1625
                qdict_put(qdict, "backing_file",
1626
                          qstring_from_str(bs->backing_file));
1627
            }
1628

    
1629
            qdict_put_obj(bs_dict, "inserted", obj);
1630
        }
1631
        qlist_append_obj(bs_list, bs_obj);
1632
    }
1633

    
1634
    *ret_data = QOBJECT(bs_list);
1635
}
1636

    
1637
static void bdrv_stats_iter(QObject *data, void *opaque)
1638
{
1639
    QDict *qdict;
1640
    Monitor *mon = opaque;
1641

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

    
1645
    qdict = qobject_to_qdict(qdict_get(qdict, "stats"));
1646
    monitor_printf(mon, " rd_bytes=%" PRId64
1647
                        " wr_bytes=%" PRId64
1648
                        " rd_operations=%" PRId64
1649
                        " wr_operations=%" PRId64
1650
                        "\n",
1651
                        qdict_get_int(qdict, "rd_bytes"),
1652
                        qdict_get_int(qdict, "wr_bytes"),
1653
                        qdict_get_int(qdict, "rd_operations"),
1654
                        qdict_get_int(qdict, "wr_operations"));
1655
}
1656

    
1657
void bdrv_stats_print(Monitor *mon, const QObject *data)
1658
{
1659
    qlist_iter(qobject_to_qlist(data), bdrv_stats_iter, mon);
1660
}
1661

    
1662
static QObject* bdrv_info_stats_bs(BlockDriverState *bs)
1663
{
1664
    QObject *res;
1665
    QDict *dict;
1666

    
1667
    res = qobject_from_jsonf("{ 'stats': {"
1668
                             "'rd_bytes': %" PRId64 ","
1669
                             "'wr_bytes': %" PRId64 ","
1670
                             "'rd_operations': %" PRId64 ","
1671
                             "'wr_operations': %" PRId64 ","
1672
                             "'wr_highest_offset': %" PRId64
1673
                             "} }",
1674
                             bs->rd_bytes, bs->wr_bytes,
1675
                             bs->rd_ops, bs->wr_ops,
1676
                             bs->wr_highest_sector *
1677
                             (uint64_t)BDRV_SECTOR_SIZE);
1678
    dict  = qobject_to_qdict(res);
1679

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

    
1684
    if (bs->file) {
1685
        QObject *parent = bdrv_info_stats_bs(bs->file);
1686
        qdict_put_obj(dict, "parent", parent);
1687
    }
1688

    
1689
    return res;
1690
}
1691

    
1692
void bdrv_info_stats(Monitor *mon, QObject **ret_data)
1693
{
1694
    QObject *obj;
1695
    QList *devices;
1696
    BlockDriverState *bs;
1697

    
1698
    devices = qlist_new();
1699

    
1700
    QTAILQ_FOREACH(bs, &bdrv_states, list) {
1701
        obj = bdrv_info_stats_bs(bs);
1702
        qlist_append_obj(devices, obj);
1703
    }
1704

    
1705
    *ret_data = QOBJECT(devices);
1706
}
1707

    
1708
const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
1709
{
1710
    if (bs->backing_hd && bs->backing_hd->encrypted)
1711
        return bs->backing_file;
1712
    else if (bs->encrypted)
1713
        return bs->filename;
1714
    else
1715
        return NULL;
1716
}
1717

    
1718
void bdrv_get_backing_filename(BlockDriverState *bs,
1719
                               char *filename, int filename_size)
1720
{
1721
    if (!bs->backing_file) {
1722
        pstrcpy(filename, filename_size, "");
1723
    } else {
1724
        pstrcpy(filename, filename_size, bs->backing_file);
1725
    }
1726
}
1727

    
1728
int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
1729
                          const uint8_t *buf, int nb_sectors)
1730
{
1731
    BlockDriver *drv = bs->drv;
1732
    if (!drv)
1733
        return -ENOMEDIUM;
1734
    if (!drv->bdrv_write_compressed)
1735
        return -ENOTSUP;
1736
    if (bdrv_check_request(bs, sector_num, nb_sectors))
1737
        return -EIO;
1738

    
1739
    if (bs->dirty_bitmap) {
1740
        set_dirty_bitmap(bs, sector_num, nb_sectors, 1);
1741
    }
1742

    
1743
    return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);
1744
}
1745

    
1746
int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
1747
{
1748
    BlockDriver *drv = bs->drv;
1749
    if (!drv)
1750
        return -ENOMEDIUM;
1751
    if (!drv->bdrv_get_info)
1752
        return -ENOTSUP;
1753
    memset(bdi, 0, sizeof(*bdi));
1754
    return drv->bdrv_get_info(bs, bdi);
1755
}
1756

    
1757
int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
1758
                      int64_t pos, int size)
1759
{
1760
    BlockDriver *drv = bs->drv;
1761
    if (!drv)
1762
        return -ENOMEDIUM;
1763
    if (drv->bdrv_save_vmstate)
1764
        return drv->bdrv_save_vmstate(bs, buf, pos, size);
1765
    if (bs->file)
1766
        return bdrv_save_vmstate(bs->file, buf, pos, size);
1767
    return -ENOTSUP;
1768
}
1769

    
1770
int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
1771
                      int64_t pos, int size)
1772
{
1773
    BlockDriver *drv = bs->drv;
1774
    if (!drv)
1775
        return -ENOMEDIUM;
1776
    if (drv->bdrv_load_vmstate)
1777
        return drv->bdrv_load_vmstate(bs, buf, pos, size);
1778
    if (bs->file)
1779
        return bdrv_load_vmstate(bs->file, buf, pos, size);
1780
    return -ENOTSUP;
1781
}
1782

    
1783
void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event)
1784
{
1785
    BlockDriver *drv = bs->drv;
1786

    
1787
    if (!drv || !drv->bdrv_debug_event) {
1788
        return;
1789
    }
1790

    
1791
    return drv->bdrv_debug_event(bs, event);
1792

    
1793
}
1794

    
1795
/**************************************************************/
1796
/* handling of snapshots */
1797

    
1798
int bdrv_can_snapshot(BlockDriverState *bs)
1799
{
1800
    BlockDriver *drv = bs->drv;
1801
    if (!drv || bdrv_is_removable(bs) || bdrv_is_read_only(bs)) {
1802
        return 0;
1803
    }
1804

    
1805
    if (!drv->bdrv_snapshot_create) {
1806
        if (bs->file != NULL) {
1807
            return bdrv_can_snapshot(bs->file);
1808
        }
1809
        return 0;
1810
    }
1811

    
1812
    return 1;
1813
}
1814

    
1815
int bdrv_is_snapshot(BlockDriverState *bs)
1816
{
1817
    return !!(bs->open_flags & BDRV_O_SNAPSHOT);
1818
}
1819

    
1820
BlockDriverState *bdrv_snapshots(void)
1821
{
1822
    BlockDriverState *bs;
1823

    
1824
    if (bs_snapshots) {
1825
        return bs_snapshots;
1826
    }
1827

    
1828
    bs = NULL;
1829
    while ((bs = bdrv_next(bs))) {
1830
        if (bdrv_can_snapshot(bs)) {
1831
            bs_snapshots = bs;
1832
            return bs;
1833
        }
1834
    }
1835
    return NULL;
1836
}
1837

    
1838
int bdrv_snapshot_create(BlockDriverState *bs,
1839
                         QEMUSnapshotInfo *sn_info)
1840
{
1841
    BlockDriver *drv = bs->drv;
1842
    if (!drv)
1843
        return -ENOMEDIUM;
1844
    if (drv->bdrv_snapshot_create)
1845
        return drv->bdrv_snapshot_create(bs, sn_info);
1846
    if (bs->file)
1847
        return bdrv_snapshot_create(bs->file, sn_info);
1848
    return -ENOTSUP;
1849
}
1850

    
1851
int bdrv_snapshot_goto(BlockDriverState *bs,
1852
                       const char *snapshot_id)
1853
{
1854
    BlockDriver *drv = bs->drv;
1855
    int ret, open_ret;
1856

    
1857
    if (!drv)
1858
        return -ENOMEDIUM;
1859
    if (drv->bdrv_snapshot_goto)
1860
        return drv->bdrv_snapshot_goto(bs, snapshot_id);
1861

    
1862
    if (bs->file) {
1863
        drv->bdrv_close(bs);
1864
        ret = bdrv_snapshot_goto(bs->file, snapshot_id);
1865
        open_ret = drv->bdrv_open(bs, bs->open_flags);
1866
        if (open_ret < 0) {
1867
            bdrv_delete(bs->file);
1868
            bs->drv = NULL;
1869
            return open_ret;
1870
        }
1871
        return ret;
1872
    }
1873

    
1874
    return -ENOTSUP;
1875
}
1876

    
1877
int bdrv_snapshot_delete(BlockDriverState *bs, const char *snapshot_id)
1878
{
1879
    BlockDriver *drv = bs->drv;
1880
    if (!drv)
1881
        return -ENOMEDIUM;
1882
    if (drv->bdrv_snapshot_delete)
1883
        return drv->bdrv_snapshot_delete(bs, snapshot_id);
1884
    if (bs->file)
1885
        return bdrv_snapshot_delete(bs->file, snapshot_id);
1886
    return -ENOTSUP;
1887
}
1888

    
1889
int bdrv_snapshot_list(BlockDriverState *bs,
1890
                       QEMUSnapshotInfo **psn_info)
1891
{
1892
    BlockDriver *drv = bs->drv;
1893
    if (!drv)
1894
        return -ENOMEDIUM;
1895
    if (drv->bdrv_snapshot_list)
1896
        return drv->bdrv_snapshot_list(bs, psn_info);
1897
    if (bs->file)
1898
        return bdrv_snapshot_list(bs->file, psn_info);
1899
    return -ENOTSUP;
1900
}
1901

    
1902
#define NB_SUFFIXES 4
1903

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

    
1910
    if (size <= 999) {
1911
        snprintf(buf, buf_size, "%" PRId64, size);
1912
    } else {
1913
        base = 1024;
1914
        for(i = 0; i < NB_SUFFIXES; i++) {
1915
            if (size < (10 * base)) {
1916
                snprintf(buf, buf_size, "%0.1f%c",
1917
                         (double)size / base,
1918
                         suffixes[i]);
1919
                break;
1920
            } else if (size < (1000 * base) || i == (NB_SUFFIXES - 1)) {
1921
                snprintf(buf, buf_size, "%" PRId64 "%c",
1922
                         ((size + (base >> 1)) / base),
1923
                         suffixes[i]);
1924
                break;
1925
            }
1926
            base = base * 1024;
1927
        }
1928
    }
1929
    return buf;
1930
}
1931

    
1932
char *bdrv_snapshot_dump(char *buf, int buf_size, QEMUSnapshotInfo *sn)
1933
{
1934
    char buf1[128], date_buf[128], clock_buf[128];
1935
#ifdef _WIN32
1936
    struct tm *ptm;
1937
#else
1938
    struct tm tm;
1939
#endif
1940
    time_t ti;
1941
    int64_t secs;
1942

    
1943
    if (!sn) {
1944
        snprintf(buf, buf_size,
1945
                 "%-10s%-20s%7s%20s%15s",
1946
                 "ID", "TAG", "VM SIZE", "DATE", "VM CLOCK");
1947
    } else {
1948
        ti = sn->date_sec;
1949
#ifdef _WIN32
1950
        ptm = localtime(&ti);
1951
        strftime(date_buf, sizeof(date_buf),
1952
                 "%Y-%m-%d %H:%M:%S", ptm);
1953
#else
1954
        localtime_r(&ti, &tm);
1955
        strftime(date_buf, sizeof(date_buf),
1956
                 "%Y-%m-%d %H:%M:%S", &tm);
1957
#endif
1958
        secs = sn->vm_clock_nsec / 1000000000;
1959
        snprintf(clock_buf, sizeof(clock_buf),
1960
                 "%02d:%02d:%02d.%03d",
1961
                 (int)(secs / 3600),
1962
                 (int)((secs / 60) % 60),
1963
                 (int)(secs % 60),
1964
                 (int)((sn->vm_clock_nsec / 1000000) % 1000));
1965
        snprintf(buf, buf_size,
1966
                 "%-10s%-20s%7s%20s%15s",
1967
                 sn->id_str, sn->name,
1968
                 get_human_readable_size(buf1, sizeof(buf1), sn->vm_state_size),
1969
                 date_buf,
1970
                 clock_buf);
1971
    }
1972
    return buf;
1973
}
1974

    
1975

    
1976
/**************************************************************/
1977
/* async I/Os */
1978

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

    
1986
    trace_bdrv_aio_readv(bs, sector_num, nb_sectors, opaque);
1987

    
1988
    if (!drv)
1989
        return NULL;
1990
    if (bdrv_check_request(bs, sector_num, nb_sectors))
1991
        return NULL;
1992

    
1993
    ret = drv->bdrv_aio_readv(bs, sector_num, qiov, nb_sectors,
1994
                              cb, opaque);
1995

    
1996
    if (ret) {
1997
        /* Update stats even though technically transfer has not happened. */
1998
        bs->rd_bytes += (unsigned) nb_sectors * BDRV_SECTOR_SIZE;
1999
        bs->rd_ops ++;
2000
    }
2001

    
2002
    return ret;
2003
}
2004

    
2005
BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
2006
                                  QEMUIOVector *qiov, int nb_sectors,
2007
                                  BlockDriverCompletionFunc *cb, void *opaque)
2008
{
2009
    BlockDriver *drv = bs->drv;
2010
    BlockDriverAIOCB *ret;
2011

    
2012
    trace_bdrv_aio_writev(bs, sector_num, nb_sectors, opaque);
2013

    
2014
    if (!drv)
2015
        return NULL;
2016
    if (bs->read_only)
2017
        return NULL;
2018
    if (bdrv_check_request(bs, sector_num, nb_sectors))
2019
        return NULL;
2020

    
2021
    if (bs->dirty_bitmap) {
2022
        set_dirty_bitmap(bs, sector_num, nb_sectors, 1);
2023
    }
2024

    
2025
    ret = drv->bdrv_aio_writev(bs, sector_num, qiov, nb_sectors,
2026
                               cb, opaque);
2027

    
2028
    if (ret) {
2029
        /* Update stats even though technically transfer has not happened. */
2030
        bs->wr_bytes += (unsigned) nb_sectors * BDRV_SECTOR_SIZE;
2031
        bs->wr_ops ++;
2032
        if (bs->wr_highest_sector < sector_num + nb_sectors - 1) {
2033
            bs->wr_highest_sector = sector_num + nb_sectors - 1;
2034
        }
2035
    }
2036

    
2037
    return ret;
2038
}
2039

    
2040

    
2041
typedef struct MultiwriteCB {
2042
    int error;
2043
    int num_requests;
2044
    int num_callbacks;
2045
    struct {
2046
        BlockDriverCompletionFunc *cb;
2047
        void *opaque;
2048
        QEMUIOVector *free_qiov;
2049
        void *free_buf;
2050
    } callbacks[];
2051
} MultiwriteCB;
2052

    
2053
static void multiwrite_user_cb(MultiwriteCB *mcb)
2054
{
2055
    int i;
2056

    
2057
    for (i = 0; i < mcb->num_callbacks; i++) {
2058
        mcb->callbacks[i].cb(mcb->callbacks[i].opaque, mcb->error);
2059
        if (mcb->callbacks[i].free_qiov) {
2060
            qemu_iovec_destroy(mcb->callbacks[i].free_qiov);
2061
        }
2062
        qemu_free(mcb->callbacks[i].free_qiov);
2063
        qemu_vfree(mcb->callbacks[i].free_buf);
2064
    }
2065
}
2066

    
2067
static void multiwrite_cb(void *opaque, int ret)
2068
{
2069
    MultiwriteCB *mcb = opaque;
2070

    
2071
    trace_multiwrite_cb(mcb, ret);
2072

    
2073
    if (ret < 0 && !mcb->error) {
2074
        mcb->error = ret;
2075
    }
2076

    
2077
    mcb->num_requests--;
2078
    if (mcb->num_requests == 0) {
2079
        multiwrite_user_cb(mcb);
2080
        qemu_free(mcb);
2081
    }
2082
}
2083

    
2084
static int multiwrite_req_compare(const void *a, const void *b)
2085
{
2086
    const BlockRequest *req1 = a, *req2 = b;
2087

    
2088
    /*
2089
     * Note that we can't simply subtract req2->sector from req1->sector
2090
     * here as that could overflow the return value.
2091
     */
2092
    if (req1->sector > req2->sector) {
2093
        return 1;
2094
    } else if (req1->sector < req2->sector) {
2095
        return -1;
2096
    } else {
2097
        return 0;
2098
    }
2099
}
2100

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

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

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

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

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

    
2134
        if (reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1 > IOV_MAX) {
2135
            merge = 0;
2136
        }
2137

    
2138
        if (merge) {
2139
            size_t size;
2140
            QEMUIOVector *qiov = qemu_mallocz(sizeof(*qiov));
2141
            qemu_iovec_init(qiov,
2142
                reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1);
2143

    
2144
            // Add the first request to the merged one. If the requests are
2145
            // overlapping, drop the last sectors of the first request.
2146
            size = (reqs[i].sector - reqs[outidx].sector) << 9;
2147
            qemu_iovec_concat(qiov, reqs[outidx].qiov, size);
2148

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

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

    
2161
            reqs[outidx].nb_sectors = qiov->size >> 9;
2162
            reqs[outidx].qiov = qiov;
2163

    
2164
            mcb->callbacks[i].free_qiov = reqs[outidx].qiov;
2165
        } else {
2166
            outidx++;
2167
            reqs[outidx].sector     = reqs[i].sector;
2168
            reqs[outidx].nb_sectors = reqs[i].nb_sectors;
2169
            reqs[outidx].qiov       = reqs[i].qiov;
2170
        }
2171
    }
2172

    
2173
    return outidx + 1;
2174
}
2175

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

    
2196
    if (num_reqs == 0) {
2197
        return 0;
2198
    }
2199

    
2200
    // Create MultiwriteCB structure
2201
    mcb = qemu_mallocz(sizeof(*mcb) + num_reqs * sizeof(*mcb->callbacks));
2202
    mcb->num_requests = 0;
2203
    mcb->num_callbacks = num_reqs;
2204

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

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

    
2213
    trace_bdrv_aio_multiwrite(mcb, mcb->num_callbacks, num_reqs);
2214

    
2215
    /*
2216
     * Run the aio requests. As soon as one request can't be submitted
2217
     * successfully, fail all requests that are not yet submitted (we must
2218
     * return failure for all requests anyway)
2219
     *
2220
     * num_requests cannot be set to the right value immediately: If
2221
     * bdrv_aio_writev fails for some request, num_requests would be too high
2222
     * and therefore multiwrite_cb() would never recognize the multiwrite
2223
     * request as completed. We also cannot use the loop variable i to set it
2224
     * when the first request fails because the callback may already have been
2225
     * called for previously submitted requests. Thus, num_requests must be
2226
     * incremented for each request that is submitted.
2227
     *
2228
     * The problem that callbacks may be called early also means that we need
2229
     * to take care that num_requests doesn't become 0 before all requests are
2230
     * submitted - multiwrite_cb() would consider the multiwrite request
2231
     * completed. A dummy request that is "completed" by a manual call to
2232
     * multiwrite_cb() takes care of this.
2233
     */
2234
    mcb->num_requests = 1;
2235

    
2236
    // Run the aio requests
2237
    for (i = 0; i < num_reqs; i++) {
2238
        mcb->num_requests++;
2239
        acb = bdrv_aio_writev(bs, reqs[i].sector, reqs[i].qiov,
2240
            reqs[i].nb_sectors, multiwrite_cb, mcb);
2241

    
2242
        if (acb == NULL) {
2243
            // We can only fail the whole thing if no request has been
2244
            // submitted yet. Otherwise we'll wait for the submitted AIOs to
2245
            // complete and report the error in the callback.
2246
            if (i == 0) {
2247
                trace_bdrv_aio_multiwrite_earlyfail(mcb);
2248
                goto fail;
2249
            } else {
2250
                trace_bdrv_aio_multiwrite_latefail(mcb, i);
2251
                multiwrite_cb(mcb, -EIO);
2252
                break;
2253
            }
2254
        }
2255
    }
2256

    
2257
    /* Complete the dummy request */
2258
    multiwrite_cb(mcb, 0);
2259

    
2260
    return 0;
2261

    
2262
fail:
2263
    for (i = 0; i < mcb->num_callbacks; i++) {
2264
        reqs[i].error = -EIO;
2265
    }
2266
    qemu_free(mcb);
2267
    return -1;
2268
}
2269

    
2270
BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs,
2271
        BlockDriverCompletionFunc *cb, void *opaque)
2272
{
2273
    BlockDriver *drv = bs->drv;
2274

    
2275
    if (bs->open_flags & BDRV_O_NO_FLUSH) {
2276
        return bdrv_aio_noop_em(bs, cb, opaque);
2277
    }
2278

    
2279
    if (!drv)
2280
        return NULL;
2281
    return drv->bdrv_aio_flush(bs, cb, opaque);
2282
}
2283

    
2284
void bdrv_aio_cancel(BlockDriverAIOCB *acb)
2285
{
2286
    acb->pool->cancel(acb);
2287
}
2288

    
2289

    
2290
/**************************************************************/
2291
/* async block device emulation */
2292

    
2293
typedef struct BlockDriverAIOCBSync {
2294
    BlockDriverAIOCB common;
2295
    QEMUBH *bh;
2296
    int ret;
2297
    /* vector translation state */
2298
    QEMUIOVector *qiov;
2299
    uint8_t *bounce;
2300
    int is_write;
2301
} BlockDriverAIOCBSync;
2302

    
2303
static void bdrv_aio_cancel_em(BlockDriverAIOCB *blockacb)
2304
{
2305
    BlockDriverAIOCBSync *acb =
2306
        container_of(blockacb, BlockDriverAIOCBSync, common);
2307
    qemu_bh_delete(acb->bh);
2308
    acb->bh = NULL;
2309
    qemu_aio_release(acb);
2310
}
2311

    
2312
static AIOPool bdrv_em_aio_pool = {
2313
    .aiocb_size         = sizeof(BlockDriverAIOCBSync),
2314
    .cancel             = bdrv_aio_cancel_em,
2315
};
2316

    
2317
static void bdrv_aio_bh_cb(void *opaque)
2318
{
2319
    BlockDriverAIOCBSync *acb = opaque;
2320

    
2321
    if (!acb->is_write)
2322
        qemu_iovec_from_buffer(acb->qiov, acb->bounce, acb->qiov->size);
2323
    qemu_vfree(acb->bounce);
2324
    acb->common.cb(acb->common.opaque, acb->ret);
2325
    qemu_bh_delete(acb->bh);
2326
    acb->bh = NULL;
2327
    qemu_aio_release(acb);
2328
}
2329

    
2330
static BlockDriverAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs,
2331
                                            int64_t sector_num,
2332
                                            QEMUIOVector *qiov,
2333
                                            int nb_sectors,
2334
                                            BlockDriverCompletionFunc *cb,
2335
                                            void *opaque,
2336
                                            int is_write)
2337

    
2338
{
2339
    BlockDriverAIOCBSync *acb;
2340

    
2341
    acb = qemu_aio_get(&bdrv_em_aio_pool, bs, cb, opaque);
2342
    acb->is_write = is_write;
2343
    acb->qiov = qiov;
2344
    acb->bounce = qemu_blockalign(bs, qiov->size);
2345

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

    
2349
    if (is_write) {
2350
        qemu_iovec_to_buffer(acb->qiov, acb->bounce);
2351
        acb->ret = bdrv_write(bs, sector_num, acb->bounce, nb_sectors);
2352
    } else {
2353
        acb->ret = bdrv_read(bs, sector_num, acb->bounce, nb_sectors);
2354
    }
2355

    
2356
    qemu_bh_schedule(acb->bh);
2357

    
2358
    return &acb->common;
2359
}
2360

    
2361
static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
2362
        int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
2363
        BlockDriverCompletionFunc *cb, void *opaque)
2364
{
2365
    return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 0);
2366
}
2367

    
2368
static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
2369
        int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
2370
        BlockDriverCompletionFunc *cb, void *opaque)
2371
{
2372
    return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 1);
2373
}
2374

    
2375
static BlockDriverAIOCB *bdrv_aio_flush_em(BlockDriverState *bs,
2376
        BlockDriverCompletionFunc *cb, void *opaque)
2377
{
2378
    BlockDriverAIOCBSync *acb;
2379

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

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

    
2389
    bdrv_flush(bs);
2390
    qemu_bh_schedule(acb->bh);
2391
    return &acb->common;
2392
}
2393

    
2394
static BlockDriverAIOCB *bdrv_aio_noop_em(BlockDriverState *bs,
2395
        BlockDriverCompletionFunc *cb, void *opaque)
2396
{
2397
    BlockDriverAIOCBSync *acb;
2398

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

    
2405
    if (!acb->bh) {
2406
        acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
2407
    }
2408

    
2409
    qemu_bh_schedule(acb->bh);
2410
    return &acb->common;
2411
}
2412

    
2413
/**************************************************************/
2414
/* sync block device emulation */
2415

    
2416
static void bdrv_rw_em_cb(void *opaque, int ret)
2417
{
2418
    *(int *)opaque = ret;
2419
}
2420

    
2421
#define NOT_DONE 0x7fffffff
2422

    
2423
static int bdrv_read_em(BlockDriverState *bs, int64_t sector_num,
2424
                        uint8_t *buf, int nb_sectors)
2425
{
2426
    int async_ret;
2427
    BlockDriverAIOCB *acb;
2428
    struct iovec iov;
2429
    QEMUIOVector qiov;
2430

    
2431
    async_context_push();
2432

    
2433
    async_ret = NOT_DONE;
2434
    iov.iov_base = (void *)buf;
2435
    iov.iov_len = nb_sectors * BDRV_SECTOR_SIZE;
2436
    qemu_iovec_init_external(&qiov, &iov, 1);
2437
    acb = bdrv_aio_readv(bs, sector_num, &qiov, nb_sectors,
2438
        bdrv_rw_em_cb, &async_ret);
2439
    if (acb == NULL) {
2440
        async_ret = -1;
2441
        goto fail;
2442
    }
2443

    
2444
    while (async_ret == NOT_DONE) {
2445
        qemu_aio_wait();
2446
    }
2447

    
2448

    
2449
fail:
2450
    async_context_pop();
2451
    return async_ret;
2452
}
2453

    
2454
static int bdrv_write_em(BlockDriverState *bs, int64_t sector_num,
2455
                         const uint8_t *buf, int nb_sectors)
2456
{
2457
    int async_ret;
2458
    BlockDriverAIOCB *acb;
2459
    struct iovec iov;
2460
    QEMUIOVector qiov;
2461

    
2462
    async_context_push();
2463

    
2464
    async_ret = NOT_DONE;
2465
    iov.iov_base = (void *)buf;
2466
    iov.iov_len = nb_sectors * BDRV_SECTOR_SIZE;
2467
    qemu_iovec_init_external(&qiov, &iov, 1);
2468
    acb = bdrv_aio_writev(bs, sector_num, &qiov, nb_sectors,
2469
        bdrv_rw_em_cb, &async_ret);
2470
    if (acb == NULL) {
2471
        async_ret = -1;
2472
        goto fail;
2473
    }
2474
    while (async_ret == NOT_DONE) {
2475
        qemu_aio_wait();
2476
    }
2477

    
2478
fail:
2479
    async_context_pop();
2480
    return async_ret;
2481
}
2482

    
2483
void bdrv_init(void)
2484
{
2485
    module_call_init(MODULE_INIT_BLOCK);
2486
}
2487

    
2488
void bdrv_init_with_whitelist(void)
2489
{
2490
    use_bdrv_whitelist = 1;
2491
    bdrv_init();
2492
}
2493

    
2494
void *qemu_aio_get(AIOPool *pool, BlockDriverState *bs,
2495
                   BlockDriverCompletionFunc *cb, void *opaque)
2496
{
2497
    BlockDriverAIOCB *acb;
2498

    
2499
    if (pool->free_aiocb) {
2500
        acb = pool->free_aiocb;
2501
        pool->free_aiocb = acb->next;
2502
    } else {
2503
        acb = qemu_mallocz(pool->aiocb_size);
2504
        acb->pool = pool;
2505
    }
2506
    acb->bs = bs;
2507
    acb->cb = cb;
2508
    acb->opaque = opaque;
2509
    return acb;
2510
}
2511

    
2512
void qemu_aio_release(void *p)
2513
{
2514
    BlockDriverAIOCB *acb = (BlockDriverAIOCB *)p;
2515
    AIOPool *pool = acb->pool;
2516
    acb->next = pool->free_aiocb;
2517
    pool->free_aiocb = acb;
2518
}
2519

    
2520
/**************************************************************/
2521
/* removable device support */
2522

    
2523
/**
2524
 * Return TRUE if the media is present
2525
 */
2526
int bdrv_is_inserted(BlockDriverState *bs)
2527
{
2528
    BlockDriver *drv = bs->drv;
2529
    int ret;
2530
    if (!drv)
2531
        return 0;
2532
    if (!drv->bdrv_is_inserted)
2533
        return !bs->tray_open;
2534
    ret = drv->bdrv_is_inserted(bs);
2535
    return ret;
2536
}
2537

    
2538
/**
2539
 * Return TRUE if the media changed since the last call to this
2540
 * function. It is currently only used for floppy disks
2541
 */
2542
int bdrv_media_changed(BlockDriverState *bs)
2543
{
2544
    BlockDriver *drv = bs->drv;
2545
    int ret;
2546

    
2547
    if (!drv || !drv->bdrv_media_changed)
2548
        ret = -ENOTSUP;
2549
    else
2550
        ret = drv->bdrv_media_changed(bs);
2551
    if (ret == -ENOTSUP)
2552
        ret = bs->media_changed;
2553
    bs->media_changed = 0;
2554
    return ret;
2555
}
2556

    
2557
/**
2558
 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
2559
 */
2560
int bdrv_eject(BlockDriverState *bs, int eject_flag)
2561
{
2562
    BlockDriver *drv = bs->drv;
2563
    int ret;
2564

    
2565
    if (bs->locked) {
2566
        return -EBUSY;
2567
    }
2568

    
2569
    if (!drv || !drv->bdrv_eject) {
2570
        ret = -ENOTSUP;
2571
    } else {
2572
        ret = drv->bdrv_eject(bs, eject_flag);
2573
    }
2574
    if (ret == -ENOTSUP) {
2575
        ret = 0;
2576
    }
2577
    if (ret >= 0) {
2578
        bs->tray_open = eject_flag;
2579
    }
2580

    
2581
    return ret;
2582
}
2583

    
2584
int bdrv_is_locked(BlockDriverState *bs)
2585
{
2586
    return bs->locked;
2587
}
2588

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

    
2597
    bs->locked = locked;
2598
    if (drv && drv->bdrv_set_locked) {
2599
        drv->bdrv_set_locked(bs, locked);
2600
    }
2601
}
2602

    
2603
/* needed for generic scsi interface */
2604

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

    
2609
    if (drv && drv->bdrv_ioctl)
2610
        return drv->bdrv_ioctl(bs, req, buf);
2611
    return -ENOTSUP;
2612
}
2613

    
2614
BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
2615
        unsigned long int req, void *buf,
2616
        BlockDriverCompletionFunc *cb, void *opaque)
2617
{
2618
    BlockDriver *drv = bs->drv;
2619

    
2620
    if (drv && drv->bdrv_aio_ioctl)
2621
        return drv->bdrv_aio_ioctl(bs, req, buf, cb, opaque);
2622
    return NULL;
2623
}
2624

    
2625

    
2626

    
2627
void *qemu_blockalign(BlockDriverState *bs, size_t size)
2628
{
2629
    return qemu_memalign((bs && bs->buffer_alignment) ? bs->buffer_alignment : 512, size);
2630
}
2631

    
2632
void bdrv_set_dirty_tracking(BlockDriverState *bs, int enable)
2633
{
2634
    int64_t bitmap_size;
2635

    
2636
    bs->dirty_count = 0;
2637
    if (enable) {
2638
        if (!bs->dirty_bitmap) {
2639
            bitmap_size = (bdrv_getlength(bs) >> BDRV_SECTOR_BITS) +
2640
                    BDRV_SECTORS_PER_DIRTY_CHUNK * 8 - 1;
2641
            bitmap_size /= BDRV_SECTORS_PER_DIRTY_CHUNK * 8;
2642

    
2643
            bs->dirty_bitmap = qemu_mallocz(bitmap_size);
2644
        }
2645
    } else {
2646
        if (bs->dirty_bitmap) {
2647
            qemu_free(bs->dirty_bitmap);
2648
            bs->dirty_bitmap = NULL;
2649
        }
2650
    }
2651
}
2652

    
2653
int bdrv_get_dirty(BlockDriverState *bs, int64_t sector)
2654
{
2655
    int64_t chunk = sector / (int64_t)BDRV_SECTORS_PER_DIRTY_CHUNK;
2656

    
2657
    if (bs->dirty_bitmap &&
2658
        (sector << BDRV_SECTOR_BITS) < bdrv_getlength(bs)) {
2659
        return bs->dirty_bitmap[chunk / (sizeof(unsigned long) * 8)] &
2660
            (1 << (chunk % (sizeof(unsigned long) * 8)));
2661
    } else {
2662
        return 0;
2663
    }
2664
}
2665

    
2666
void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector,
2667
                      int nr_sectors)
2668
{
2669
    set_dirty_bitmap(bs, cur_sector, nr_sectors, 0);
2670
}
2671

    
2672
int64_t bdrv_get_dirty_count(BlockDriverState *bs)
2673
{
2674
    return bs->dirty_count;
2675
}