Blame view

block.c 36.8 KB
bellard authored
1
2
/*
 * QEMU System Emulator block driver
3
 *
bellard authored
4
 * Copyright (c) 2003 Fabrice Bellard
5
 *
bellard authored
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.
 */
pbrook authored
24
#include "qemu-common.h"
pbrook authored
25
26
#ifndef QEMU_IMG
#include "console.h"
pbrook authored
27
#endif
bellard authored
28
#include "block_int.h"
bellard authored
29
bellard authored
30
31
32
33
34
35
36
37
#ifdef _BSD
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <sys/queue.h>
#include <sys/disk.h>
#endif
bellard authored
38
39
40
#define SECTOR_BITS 9
#define SECTOR_SIZE (1 << SECTOR_BITS)
bellard authored
41
42
43
44
45
46
typedef struct BlockDriverAIOCBSync {
    BlockDriverAIOCB common;
    QEMUBH *bh;
    int ret;
} BlockDriverAIOCBSync;
47
48
49
50
51
52
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);
bellard authored
53
static void bdrv_aio_cancel_em(BlockDriverAIOCB *acb);
54
static int bdrv_read_em(BlockDriverState *bs, int64_t sector_num,
bellard authored
55
56
57
                        uint8_t *buf, int nb_sectors);
static int bdrv_write_em(BlockDriverState *bs, int64_t sector_num,
                         const uint8_t *buf, int nb_sectors);
bellard authored
58
pbrook authored
59
BlockDriverState *bdrv_first;
bellard authored
60
61
static BlockDriver *first_drv;
bellard authored
62
int path_is_absolute(const char *path)
63
{
bellard authored
64
    const char *p;
65
66
67
68
69
#ifdef _WIN32
    /* specific case for names like: "\\.\d:" */
    if (*path == '/' || *path == '\\')
        return 1;
#endif
bellard authored
70
71
72
73
74
    p = strchr(path, ':');
    if (p)
        p++;
    else
        p = path;
75
76
77
78
79
#ifdef _WIN32
    return (*p == '/' || *p == '\\');
#else
    return (*p == '/');
#endif
80
81
}
bellard authored
82
83
84
85
86
87
/* 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)
88
{
bellard authored
89
90
91
92
93
94
95
96
97
98
99
100
101
    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;
102
103
104
105
106
107
108
109
110
        p1 = strrchr(base_path, '/');
#ifdef _WIN32
        {
            const char *p2;
            p2 = strrchr(base_path, '\\');
            if (!p1 || p2 > p1)
                p1 = p2;
        }
#endif
bellard authored
111
112
113
114
115
116
117
118
119
120
121
122
        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);
123
124
125
126
    }
}
127
static void bdrv_register(BlockDriver *bdrv)
bellard authored
128
{
129
    if (!bdrv->bdrv_aio_read) {
bellard authored
130
131
132
133
        /* 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;
bellard authored
134
        bdrv->aiocb_size = sizeof(BlockDriverAIOCBSync);
bellard authored
135
136
137
138
139
    } else if (!bdrv->bdrv_read && !bdrv->bdrv_pread) {
        /* add synchronous IO emulation layer */
        bdrv->bdrv_read = bdrv_read_em;
        bdrv->bdrv_write = bdrv_write_em;
    }
bellard authored
140
141
142
    bdrv->next = first_drv;
    first_drv = bdrv;
}
bellard authored
143
144
145
146
147
148
149
150
151
152

/* 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));
    if(!bs)
        return NULL;
    pstrcpy(bs->device_name, sizeof(bs->device_name), device_name);
bellard authored
153
154
155
156
157
158
159
    if (device_name[0] != '\0') {
        /* insert at the end */
        pbs = &bdrv_first;
        while (*pbs != NULL)
            pbs = &(*pbs)->next;
        *pbs = bs;
    }
bellard authored
160
161
162
    return bs;
}
bellard authored
163
164
165
166
167
168
169
170
171
172
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;
}
173
int bdrv_create(BlockDriver *drv,
bellard authored
174
175
176
177
178
179
180
181
                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);
}
bellard authored
182
#ifdef _WIN32
183
void get_tmp_filename(char *filename, int size)
bellard authored
184
{
185
    char temp_dir[MAX_PATH];
186
187
188
    GetTempPath(MAX_PATH, temp_dir);
    GetTempFileName(temp_dir, "qem", 0, filename);
bellard authored
189
190
}
#else
191
void get_tmp_filename(char *filename, int size)
bellard authored
192
{
193
    int fd;
194
    char *tmpdir;
bellard authored
195
    /* XXX: race condition possible */
196
197
198
199
    tmpdir = getenv("TMPDIR");
    if (!tmpdir)
        tmpdir = "/tmp";
    snprintf(filename, size, "%s/vl.XXXXXX", tmpdir);
bellard authored
200
201
202
    fd = mkstemp(filename);
    close(fd);
}
bellard authored
203
#endif
bellard authored
204
205
#ifdef _WIN32
bellard authored
206
207
208
209
210
211
static int is_windows_drive_prefix(const char *filename)
{
    return (((filename[0] >= 'a' && filename[0] <= 'z') ||
             (filename[0] >= 'A' && filename[0] <= 'Z')) &&
            filename[1] == ':');
}
212
213
214
static int is_windows_drive(const char *filename)
{
215
    if (is_windows_drive_prefix(filename) &&
bellard authored
216
        filename[2] == '\0')
217
218
219
220
221
222
223
224
        return 1;
    if (strstart(filename, "\\\\.\\", NULL) ||
        strstart(filename, "//./", NULL))
        return 1;
    return 0;
}
#endif
bellard authored
225
226
227
228
229
230
static BlockDriver *find_protocol(const char *filename)
{
    BlockDriver *drv1;
    char protocol[128];
    int len;
    const char *p;
231
232

#ifdef _WIN32
bellard authored
233
234
    if (is_windows_drive(filename) ||
        is_windows_drive_prefix(filename))
235
236
        return &bdrv_raw;
#endif
bellard authored
237
238
239
240
241
242
243
244
245
    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) {
246
        if (drv1->protocol_name &&
bellard authored
247
248
249
250
251
252
            !strcmp(drv1->protocol_name, protocol))
            return drv1;
    }
    return NULL;
}
bellard authored
253
254
/* XXX: force raw format if block or character device ? It would
   simplify the BSD case */
bellard authored
255
256
static BlockDriver *find_image_format(const char *filename)
{
bellard authored
257
    int ret, score, score_max;
bellard authored
258
    BlockDriver *drv1, *drv;
bellard authored
259
260
    uint8_t buf[2048];
    BlockDriverState *bs;
261
262
263
264
265
266
267
268
269
270
271
    /* 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;
272
        if (stat(filename, &st) >= 0 &&
273
274
275
276
277
            (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode))) {
            return &bdrv_host_device;
        }
    }
#endif
278
bellard authored
279
    drv = find_protocol(filename);
280
    /* no need to test disk image formats for vvfat */
bellard authored
281
282
    if (drv == &bdrv_vvfat)
        return drv;
283
bellard authored
284
285
286
287
288
289
290
291
292
    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;
    }
bellard authored
293
294
    score_max = 0;
    for(drv1 = first_drv; drv1 != NULL; drv1 = drv1->next) {
bellard authored
295
296
297
298
299
300
        if (drv1->bdrv_probe) {
            score = drv1->bdrv_probe(buf, ret, filename);
            if (score > score_max) {
                score_max = score;
                drv = drv1;
            }
bellard authored
301
        }
bellard authored
302
    }
bellard authored
303
304
305
    return drv;
}
bellard authored
306
int bdrv_file_open(BlockDriverState **pbs, const char *filename, int flags)
bellard authored
307
{
bellard authored
308
309
310
311
312
313
314
315
316
317
    BlockDriverState *bs;
    int ret;

    bs = bdrv_new("");
    if (!bs)
        return -ENOMEM;
    ret = bdrv_open2(bs, filename, flags | BDRV_O_FILE, NULL);
    if (ret < 0) {
        bdrv_delete(bs);
        return ret;
318
    }
bellard authored
319
320
321
322
323
324
325
    *pbs = bs;
    return 0;
}

int bdrv_open(BlockDriverState *bs, const char *filename, int flags)
{
    return bdrv_open2(bs, filename, flags, NULL);
bellard authored
326
327
}
bellard authored
328
int bdrv_open2(BlockDriverState *bs, const char *filename, int flags,
bellard authored
329
330
               BlockDriver *drv)
{
bellard authored
331
    int ret, open_flags;
332
333
    char tmp_filename[PATH_MAX];
    char backing_filename[PATH_MAX];
334
bellard authored
335
336
337
    bs->read_only = 0;
    bs->is_temporary = 0;
    bs->encrypted = 0;
bellard authored
338
bellard authored
339
    if (flags & BDRV_O_SNAPSHOT) {
bellard authored
340
341
        BlockDriverState *bs1;
        int64_t total_size;
342
bellard authored
343
344
        /* if snapshot, we create a temporary backing file and open it
           instead of opening 'filename' directly */
345
bellard authored
346
347
348
        /* if there is a backing file, use it */
        bs1 = bdrv_new("");
        if (!bs1) {
bellard authored
349
            return -ENOMEM;
bellard authored
350
351
352
353
354
        }
        if (bdrv_open(bs1, filename, 0) < 0) {
            bdrv_delete(bs1);
            return -1;
        }
bellard authored
355
        total_size = bdrv_getlength(bs1) >> SECTOR_BITS;
bellard authored
356
        bdrv_delete(bs1);
357
bellard authored
358
        get_tmp_filename(tmp_filename, sizeof(tmp_filename));
359
        realpath(filename, backing_filename);
360
        if (bdrv_create(&bdrv_qcow2, tmp_filename,
361
                        total_size, backing_filename, 0) < 0) {
bellard authored
362
363
364
365
366
            return -1;
        }
        filename = tmp_filename;
        bs->is_temporary = 1;
    }
bellard authored
367
bellard authored
368
    pstrcpy(bs->filename, sizeof(bs->filename), filename);
bellard authored
369
370
    if (flags & BDRV_O_FILE) {
        drv = find_protocol(filename);
bellard authored
371
        if (!drv)
bellard authored
372
373
374
375
376
377
378
            return -ENOENT;
    } else {
        if (!drv) {
            drv = find_image_format(filename);
            if (!drv)
                return -1;
        }
bellard authored
379
380
381
382
383
    }
    bs->drv = drv;
    bs->opaque = qemu_mallocz(drv->instance_size);
    if (bs->opaque == NULL && drv->instance_size > 0)
        return -1;
bellard authored
384
385
386
    /* Note: for compatibility, we open disk image files as RDWR, and
       RDONLY as fallback */
    if (!(flags & BDRV_O_FILE))
387
        open_flags = BDRV_O_RDWR | (flags & BDRV_O_DIRECT);
bellard authored
388
389
390
391
392
393
394
    else
        open_flags = flags & ~(BDRV_O_FILE | BDRV_O_SNAPSHOT);
    ret = drv->bdrv_open(bs, filename, open_flags);
    if (ret == -EACCES && !(flags & BDRV_O_FILE)) {
        ret = drv->bdrv_open(bs, filename, BDRV_O_RDONLY);
        bs->read_only = 1;
    }
bellard authored
395
396
    if (ret < 0) {
        qemu_free(bs->opaque);
bellard authored
397
398
        bs->opaque = NULL;
        bs->drv = NULL;
bellard authored
399
        return ret;
400
    }
401
402
403
    if (drv->bdrv_getlength) {
        bs->total_sectors = bdrv_getlength(bs) >> SECTOR_BITS;
    }
404
#ifndef _WIN32
bellard authored
405
406
407
408
    if (bs->is_temporary) {
        unlink(filename);
    }
#endif
bellard authored
409
    if (bs->backing_file[0] != '\0') {
bellard authored
410
411
412
413
414
        /* if there is a backing file, use it */
        bs->backing_hd = bdrv_new("");
        if (!bs->backing_hd) {
        fail:
            bdrv_close(bs);
bellard authored
415
            return -ENOMEM;
416
        }
bellard authored
417
418
419
        path_combine(backing_filename, sizeof(backing_filename),
                     filename, bs->backing_file);
        if (bdrv_open(bs->backing_hd, backing_filename, 0) < 0)
420
421
422
            goto fail;
    }
bellard authored
423
    /* call the change callback */
424
    bs->media_changed = 1;
bellard authored
425
426
427
428
    if (bs->change_cb)
        bs->change_cb(bs->change_opaque);

    return 0;
bellard authored
429
430
431
432
}

void bdrv_close(BlockDriverState *bs)
{
433
    if (bs->drv) {
bellard authored
434
435
436
437
438
439
440
441
        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);
        }
442
#endif
bellard authored
443
444
        bs->opaque = NULL;
        bs->drv = NULL;
bellard authored
445
446

        /* call the change callback */
447
        bs->media_changed = 1;
bellard authored
448
449
450
451
452
453
454
        if (bs->change_cb)
            bs->change_cb(bs->change_opaque);
    }
}

void bdrv_delete(BlockDriverState *bs)
{
455
456
457
458
459
460
461
462
    BlockDriverState **pbs;

    pbs = &bdrv_first;
    while (*pbs != bs && *pbs != NULL)
        pbs = &(*pbs)->next;
    if (*pbs == bs)
        *pbs = bs->next;
bellard authored
463
464
    bdrv_close(bs);
    qemu_free(bs);
bellard authored
465
466
}
467
468
469
/* commit COW file into the raw image */
int bdrv_commit(BlockDriverState *bs)
{
470
    BlockDriver *drv = bs->drv;
bellard authored
471
    int64_t i, total_sectors;
bellard authored
472
473
    int n, j;
    unsigned char sector[512];
474
475
476
    if (!drv)
        return -ENOMEDIUM;
477
478

    if (bs->read_only) {
bellard authored
479
	return -EACCES;
480
481
    }
bellard authored
482
483
484
    if (!bs->backing_hd) {
	return -ENOTSUP;
    }
485
bellard authored
486
487
    total_sectors = bdrv_getlength(bs) >> SECTOR_BITS;
    for (i = 0; i < total_sectors;) {
488
        if (drv->bdrv_is_allocated(bs, i, 65536, &n)) {
bellard authored
489
490
491
492
493
494
495
496
497
            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++;
498
	    }
bellard authored
499
500
501
	} else {
            i += n;
        }
502
    }
503
504
505
    if (drv->bdrv_make_empty)
	return drv->bdrv_make_empty(bs);
506
507
508
509
    return 0;
}
510
/* return < 0 if error. See bdrv_write() for the return codes */
511
int bdrv_read(BlockDriverState *bs, int64_t sector_num,
bellard authored
512
513
              uint8_t *buf, int nb_sectors)
{
bellard authored
514
515
    BlockDriver *drv = bs->drv;
516
517
    if (!drv)
        return -ENOMEDIUM;
bellard authored
518
bellard authored
519
    if (sector_num == 0 && bs->boot_sector_enabled && nb_sectors > 0) {
bellard authored
520
            memcpy(buf, bs->boot_sector_data, 512);
bellard authored
521
522
523
524
525
526
527
528
529
530
531
532
533
        sector_num++;
        nb_sectors--;
        buf += 512;
        if (nb_sectors == 0)
            return 0;
    }
    if (drv->bdrv_pread) {
        int ret, len;
        len = nb_sectors * 512;
        ret = drv->bdrv_pread(bs, sector_num * 512, buf, len);
        if (ret < 0)
            return ret;
        else if (ret != len)
534
            return -EINVAL;
535
536
537
        else {
	    bs->rd_bytes += (unsigned) len;
	    bs->rd_ops ++;
bellard authored
538
            return 0;
539
	}
bellard authored
540
541
    } else {
        return drv->bdrv_read(bs, sector_num, buf, nb_sectors);
542
    }
bellard authored
543
544
}
545
/* Return < 0 if error. Important errors are:
546
547
548
549
550
  -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
*/
551
int bdrv_write(BlockDriverState *bs, int64_t sector_num,
bellard authored
552
553
               const uint8_t *buf, int nb_sectors)
{
bellard authored
554
    BlockDriver *drv = bs->drv;
555
556
    if (!bs->drv)
        return -ENOMEDIUM;
bellard authored
557
    if (bs->read_only)
558
        return -EACCES;
559
    if (sector_num == 0 && bs->boot_sector_enabled && nb_sectors > 0) {
560
        memcpy(bs->boot_sector_data, buf, 512);
561
    }
bellard authored
562
563
564
565
566
567
568
569
    if (drv->bdrv_pwrite) {
        int ret, len;
        len = nb_sectors * 512;
        ret = drv->bdrv_pwrite(bs, sector_num * 512, buf, len);
        if (ret < 0)
            return ret;
        else if (ret != len)
            return -EIO;
570
571
572
        else {
	    bs->wr_bytes += (unsigned) len;
	    bs->wr_ops ++;
bellard authored
573
            return 0;
574
	}
bellard authored
575
576
577
578
579
    } else {
        return drv->bdrv_write(bs, sector_num, buf, nb_sectors);
    }
}
580
static int bdrv_pread_em(BlockDriverState *bs, int64_t offset,
bellard authored
581
                         uint8_t *buf, int count1)
bellard authored
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
{
    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;
}
624
static int bdrv_pwrite_em(BlockDriverState *bs, int64_t offset,
bellard authored
625
                          const uint8_t *buf, int count1)
bellard authored
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
661
662
663
664
665
666
667
668
669
670
671
672
{
    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;
}

/**
673
 * Read with byte offsets (needed only for file protocols)
bellard authored
674
 */
675
int bdrv_pread(BlockDriverState *bs, int64_t offset,
bellard authored
676
677
678
679
680
               void *buf1, int count1)
{
    BlockDriver *drv = bs->drv;

    if (!drv)
681
        return -ENOMEDIUM;
bellard authored
682
    if (!drv->bdrv_pread)
bellard authored
683
        return bdrv_pread_em(bs, offset, buf1, count1);
bellard authored
684
685
686
    return drv->bdrv_pread(bs, offset, buf1, count1);
}
687
688
/**
 * Write with byte offsets (needed only for file protocols)
bellard authored
689
 */
690
int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
bellard authored
691
692
693
694
695
                const void *buf1, int count1)
{
    BlockDriver *drv = bs->drv;

    if (!drv)
696
        return -ENOMEDIUM;
bellard authored
697
    if (!drv->bdrv_pwrite)
bellard authored
698
        return bdrv_pwrite_em(bs, offset, buf1, count1);
bellard authored
699
700
701
702
703
704
705
706
707
708
    return drv->bdrv_pwrite(bs, offset, buf1, 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)
709
        return -ENOMEDIUM;
bellard authored
710
711
712
713
714
715
716
717
718
719
720
721
    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)
722
        return -ENOMEDIUM;
bellard authored
723
724
725
726
727
    if (!drv->bdrv_getlength) {
        /* legacy mode */
        return bs->total_sectors * SECTOR_SIZE;
    }
    return drv->bdrv_getlength(bs);
bellard authored
728
729
}
730
/* return 0 as number of sectors if no device present or error */
731
void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
bellard authored
732
{
733
734
735
736
737
738
739
    int64_t length;
    length = bdrv_getlength(bs);
    if (length < 0)
        length = 0;
    else
        length = length >> SECTOR_BITS;
    *nb_sectors_ptr = length;
bellard authored
740
}
bellard authored
741
742
743
744
745
746
747
748
749
750

/* force a given boot sector. */
void bdrv_set_boot_sector(BlockDriverState *bs, const uint8_t *data, int size)
{
    bs->boot_sector_enabled = 1;
    if (size > 512)
        size = 512;
    memcpy(bs->boot_sector_data, data, size);
    memset(bs->boot_sector_data + size, 0, 512 - size);
}
bellard authored
751
752
void bdrv_set_geometry_hint(BlockDriverState *bs,
bellard authored
753
754
755
756
757
758
759
760
761
762
763
764
765
766
                            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));
}
767
768
769
770
771
void bdrv_set_translation_hint(BlockDriverState *bs, int translation)
{
    bs->translation = translation;
}
772
void bdrv_get_geometry_hint(BlockDriverState *bs,
bellard authored
773
774
775
776
777
778
779
780
781
782
783
784
                            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;
}
785
786
787
788
789
int bdrv_get_translation_hint(BlockDriverState *bs)
{
    return bs->translation;
}
bellard authored
790
791
792
793
794
795
796
797
798
799
int bdrv_is_removable(BlockDriverState *bs)
{
    return bs->removable;
}

int bdrv_is_read_only(BlockDriverState *bs)
{
    return bs->read_only;
}
800
801
802
803
804
int bdrv_is_sg(BlockDriverState *bs)
{
    return bs->sg;
}
805
/* XXX: no longer used */
806
void bdrv_set_change_cb(BlockDriverState *bs,
bellard authored
807
808
809
810
811
812
                        void (*change_cb)(void *opaque), void *opaque)
{
    bs->change_cb = change_cb;
    bs->change_opaque = opaque;
}
bellard authored
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
int bdrv_is_encrypted(BlockDriverState *bs)
{
    if (bs->backing_hd && bs->backing_hd->encrypted)
        return 1;
    return bs->encrypted;
}

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;
    return bs->drv->bdrv_set_key(bs, key);
}

void bdrv_get_format(BlockDriverState *bs, char *buf, int buf_size)
{
837
    if (!bs->drv) {
bellard authored
838
839
840
841
842
843
        buf[0] = '\0';
    } else {
        pstrcpy(buf, buf_size, bs->drv->format_name);
    }
}
844
void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
bellard authored
845
846
847
848
849
850
851
852
853
                         void *opaque)
{
    BlockDriver *drv;

    for (drv = first_drv; drv != NULL; drv = drv->next) {
        it(opaque, drv->format_name);
    }
}
bellard authored
854
855
856
857
858
859
860
861
862
863
864
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;
}
bellard authored
865
866
867
868
869
870
871
872
873
void bdrv_iterate(void (*it)(void *opaque, const char *name), void *opaque)
{
    BlockDriverState *bs;

    for (bs = bdrv_first; bs != NULL; bs = bs->next) {
        it(opaque, bs->device_name);
    }
}
bellard authored
874
875
876
877
878
const char *bdrv_get_device_name(BlockDriverState *bs)
{
    return bs->device_name;
}
pbrook authored
879
880
881
882
883
884
885
886
void bdrv_flush(BlockDriverState *bs)
{
    if (bs->drv->bdrv_flush)
        bs->drv->bdrv_flush(bs);
    if (bs->backing_hd)
        bdrv_flush(bs->backing_hd);
}
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
/*
 * 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);
}
pbrook authored
914
#ifndef QEMU_IMG
bellard authored
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
void bdrv_info(void)
{
    BlockDriverState *bs;

    for (bs = bdrv_first; bs != NULL; bs = bs->next) {
        term_printf("%s:", bs->device_name);
        term_printf(" type=");
        switch(bs->type) {
        case BDRV_TYPE_HD:
            term_printf("hd");
            break;
        case BDRV_TYPE_CDROM:
            term_printf("cdrom");
            break;
        case BDRV_TYPE_FLOPPY:
            term_printf("floppy");
            break;
        }
        term_printf(" removable=%d", bs->removable);
        if (bs->removable) {
            term_printf(" locked=%d", bs->locked);
        }
937
        if (bs->drv) {
938
939
940
941
942
943
            term_printf(" file=");
	    term_print_filename(bs->filename);
            if (bs->backing_file[0] != '\0') {
                term_printf(" backing_file=");
		term_print_filename(bs->backing_file);
	    }
bellard authored
944
            term_printf(" ro=%d", bs->read_only);
bellard authored
945
946
947
            term_printf(" drv=%s", bs->drv->format_name);
            if (bs->encrypted)
                term_printf(" encrypted");
bellard authored
948
949
950
951
952
953
        } else {
            term_printf(" [not inserted]");
        }
        term_printf("\n");
    }
}
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971

/* The "info blockstats" command. */
void bdrv_info_stats (void)
{
    BlockDriverState *bs;

    for (bs = bdrv_first; bs != NULL; bs = bs->next) {
	term_printf ("%s:"
		     " rd_bytes=%" PRIu64
		     " wr_bytes=%" PRIu64
		     " rd_operations=%" PRIu64
		     " wr_operations=%" PRIu64
		     "\n",
		     bs->device_name,
		     bs->rd_bytes, bs->wr_bytes,
		     bs->rd_ops, bs->wr_ops);
    }
}
pbrook authored
972
#endif
bellard authored
973
974
void bdrv_get_backing_filename(BlockDriverState *bs,
bellard authored
975
976
977
978
979
980
981
982
983
                               char *filename, int filename_size)
{
    if (!bs->backing_hd) {
        pstrcpy(filename, filename_size, "");
    } else {
        pstrcpy(filename, filename_size, bs->backing_file);
    }
}
984
int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
bellard authored
985
986
987
988
                          const uint8_t *buf, int nb_sectors)
{
    BlockDriver *drv = bs->drv;
    if (!drv)
989
        return -ENOMEDIUM;
bellard authored
990
991
992
993
    if (!drv->bdrv_write_compressed)
        return -ENOTSUP;
    return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);
}
994
bellard authored
995
996
997
998
int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
{
    BlockDriver *drv = bs->drv;
    if (!drv)
999
        return -ENOMEDIUM;
bellard authored
1000
1001
1002
1003
1004
1005
1006
1007
1008
    if (!drv->bdrv_get_info)
        return -ENOTSUP;
    memset(bdi, 0, sizeof(*bdi));
    return drv->bdrv_get_info(bs, bdi);
}

/**************************************************************/
/* handling of snapshots */
1009
int bdrv_snapshot_create(BlockDriverState *bs,
bellard authored
1010
1011
1012
1013
                         QEMUSnapshotInfo *sn_info)
{
    BlockDriver *drv = bs->drv;
    if (!drv)
1014
        return -ENOMEDIUM;
bellard authored
1015
1016
1017
1018
1019
    if (!drv->bdrv_snapshot_create)
        return -ENOTSUP;
    return drv->bdrv_snapshot_create(bs, sn_info);
}
1020
int bdrv_snapshot_goto(BlockDriverState *bs,
bellard authored
1021
1022
1023
1024
                       const char *snapshot_id)
{
    BlockDriver *drv = bs->drv;
    if (!drv)
1025
        return -ENOMEDIUM;
bellard authored
1026
1027
1028
1029
1030
1031
1032
1033
1034
    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)
1035
        return -ENOMEDIUM;
bellard authored
1036
1037
1038
1039
1040
    if (!drv->bdrv_snapshot_delete)
        return -ENOTSUP;
    return drv->bdrv_snapshot_delete(bs, snapshot_id);
}
1041
int bdrv_snapshot_list(BlockDriverState *bs,
bellard authored
1042
1043
1044
1045
                       QEMUSnapshotInfo **psn_info)
{
    BlockDriver *drv = bs->drv;
    if (!drv)
1046
        return -ENOMEDIUM;
bellard authored
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
    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)) {
1066
                snprintf(buf, buf_size, "%0.1f%c",
bellard authored
1067
1068
1069
1070
                         (double)size / base,
                         suffixes[i]);
                break;
            } else if (size < (1000 * base) || i == (NB_SUFFIXES - 1)) {
1071
                snprintf(buf, buf_size, "%" PRId64 "%c",
bellard authored
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
                         ((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];
1085
1086
1087
#ifdef _WIN32
    struct tm *ptm;
#else
bellard authored
1088
    struct tm tm;
1089
#endif
bellard authored
1090
1091
1092
1093
    time_t ti;
    int64_t secs;

    if (!sn) {
1094
1095
        snprintf(buf, buf_size,
                 "%-10s%-20s%7s%20s%15s",
bellard authored
1096
1097
1098
                 "ID", "TAG", "VM SIZE", "DATE", "VM CLOCK");
    } else {
        ti = sn->date_sec;
1099
1100
1101
1102
1103
#ifdef _WIN32
        ptm = localtime(&ti);
        strftime(date_buf, sizeof(date_buf),
                 "%Y-%m-%d %H:%M:%S", ptm);
#else
bellard authored
1104
1105
1106
        localtime_r(&ti, &tm);
        strftime(date_buf, sizeof(date_buf),
                 "%Y-%m-%d %H:%M:%S", &tm);
1107
#endif
bellard authored
1108
1109
1110
1111
1112
        secs = sn->vm_clock_nsec / 1000000000;
        snprintf(clock_buf, sizeof(clock_buf),
                 "%02d:%02d:%02d.%03d",
                 (int)(secs / 3600),
                 (int)((secs / 60) % 60),
1113
                 (int)(secs % 60),
bellard authored
1114
1115
                 (int)((sn->vm_clock_nsec / 1000000) % 1000));
        snprintf(buf, buf_size,
1116
                 "%-10s%-20s%7s%20s%15s",
bellard authored
1117
1118
1119
1120
1121
1122
1123
1124
                 sn->id_str, sn->name,
                 get_human_readable_size(buf1, sizeof(buf1), sn->vm_state_size),
                 date_buf,
                 clock_buf);
    }
    return buf;
}
bellard authored
1125
bellard authored
1126
/**************************************************************/
bellard authored
1127
/* async I/Os */
bellard authored
1128
1129
1130
1131
BlockDriverAIOCB *bdrv_aio_read(BlockDriverState *bs, int64_t sector_num,
                                uint8_t *buf, int nb_sectors,
                                BlockDriverCompletionFunc *cb, void *opaque)
bellard authored
1132
1133
{
    BlockDriver *drv = bs->drv;
1134
    BlockDriverAIOCB *ret;
bellard authored
1135
1136
    if (!drv)
1137
        return NULL;
1138
bellard authored
1139
1140
1141
1142
1143
1144
1145
1146
    /* XXX: we assume that nb_sectors == 0 is suppored by the async read */
    if (sector_num == 0 && bs->boot_sector_enabled && nb_sectors > 0) {
        memcpy(buf, bs->boot_sector_data, 512);
        sector_num++;
        nb_sectors--;
        buf += 512;
    }
1147
1148
1149
1150
1151
1152
1153
1154
1155
    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;
bellard authored
1156
1157
}
1158
1159
1160
BlockDriverAIOCB *bdrv_aio_write(BlockDriverState *bs, int64_t sector_num,
                                 const uint8_t *buf, int nb_sectors,
                                 BlockDriverCompletionFunc *cb, void *opaque)
bellard authored
1161
{
bellard authored
1162
    BlockDriver *drv = bs->drv;
1163
    BlockDriverAIOCB *ret;
bellard authored
1164
1165
    if (!drv)
1166
        return NULL;
bellard authored
1167
    if (bs->read_only)
1168
        return NULL;
bellard authored
1169
    if (sector_num == 0 && bs->boot_sector_enabled && nb_sectors > 0) {
1170
        memcpy(bs->boot_sector_data, buf, 512);
bellard authored
1171
    }
bellard authored
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
    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;
bellard authored
1182
1183
1184
1185
}

void bdrv_aio_cancel(BlockDriverAIOCB *acb)
{
1186
    BlockDriver *drv = acb->bs->drv;
bellard authored
1187
1188
    drv->bdrv_aio_cancel(acb);
bellard authored
1189
1190
}
1191
bellard authored
1192
1193
1194
/**************************************************************/
/* async block device emulation */
pbrook authored
1195
#ifdef QEMU_IMG
1196
1197
1198
static BlockDriverAIOCB *bdrv_aio_read_em(BlockDriverState *bs,
        int64_t sector_num, uint8_t *buf, int nb_sectors,
        BlockDriverCompletionFunc *cb, void *opaque)
bellard authored
1199
1200
{
    int ret;
1201
1202
1203
    ret = bdrv_read(bs, sector_num, buf, nb_sectors);
    cb(opaque, ret);
    return NULL;
bellard authored
1204
1205
}
1206
1207
1208
static BlockDriverAIOCB *bdrv_aio_write_em(BlockDriverState *bs,
        int64_t sector_num, const uint8_t *buf, int nb_sectors,
        BlockDriverCompletionFunc *cb, void *opaque)
bellard authored
1209
1210
{
    int ret;
1211
1212
1213
    ret = bdrv_write(bs, sector_num, buf, nb_sectors);
    cb(opaque, ret);
    return NULL;
bellard authored
1214
1215
}
bellard authored
1216
static void bdrv_aio_cancel_em(BlockDriverAIOCB *acb)
bellard authored
1217
1218
{
}
bellard authored
1219
#else
1220
static void bdrv_aio_bh_cb(void *opaque)
bellard authored
1221
{
1222
1223
1224
    BlockDriverAIOCBSync *acb = opaque;
    acb->common.cb(acb->common.opaque, acb->ret);
    qemu_aio_release(acb);
bellard authored
1225
}
1226
1227
1228
1229
static BlockDriverAIOCB *bdrv_aio_read_em(BlockDriverState *bs,
        int64_t sector_num, uint8_t *buf, int nb_sectors,
        BlockDriverCompletionFunc *cb, void *opaque)
bellard authored
1230
{
1231
    BlockDriverAIOCBSync *acb;
bellard authored
1232
    int ret;
1233
1234
1235
1236
1237
1238
1239
1240

    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;
1241
1242
}
1243
1244
1245
static BlockDriverAIOCB *bdrv_aio_write_em(BlockDriverState *bs,
        int64_t sector_num, const uint8_t *buf, int nb_sectors,
        BlockDriverCompletionFunc *cb, void *opaque)
1246
{
1247
    BlockDriverAIOCBSync *acb;
bellard authored
1248
1249
    int ret;
1250
1251
1252
1253
1254
1255
1256
    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;
1257
1258
}
1259
static void bdrv_aio_cancel_em(BlockDriverAIOCB *blockacb)
bellard authored
1260
{
1261
1262
1263
    BlockDriverAIOCBSync *acb = (BlockDriverAIOCBSync *)blockacb;
    qemu_bh_cancel(acb->bh);
    qemu_aio_release(acb);
bellard authored
1264
}
pbrook authored
1265
#endif /* !QEMU_IMG */
bellard authored
1266
bellard authored
1267
1268
/**************************************************************/
/* sync block device emulation */
bellard authored
1269
bellard authored
1270
1271
1272
static void bdrv_rw_em_cb(void *opaque, int ret)
{
    *(int *)opaque = ret;
bellard authored
1273
1274
}
bellard authored
1275
1276
#define NOT_DONE 0x7fffffff
1277
static int bdrv_read_em(BlockDriverState *bs, int64_t sector_num,
bellard authored
1278
                        uint8_t *buf, int nb_sectors)
pbrook authored
1279
{
1280
1281
    int async_ret;
    BlockDriverAIOCB *acb;
bellard authored
1282
1283
1284

    async_ret = NOT_DONE;
    qemu_aio_wait_start();
1285
    acb = bdrv_aio_read(bs, sector_num, buf, nb_sectors,
bellard authored
1286
                        bdrv_rw_em_cb, &async_ret);
1287
    if (acb == NULL) {
bellard authored
1288
        qemu_aio_wait_end();
1289
        return -1;
bellard authored
1290
1291
1292
1293
1294
1295
    }
    while (async_ret == NOT_DONE) {
        qemu_aio_wait();
    }
    qemu_aio_wait_end();
    return async_ret;
pbrook authored
1296
1297
}
bellard authored
1298
1299
1300
static int bdrv_write_em(BlockDriverState *bs, int64_t sector_num,
                         const uint8_t *buf, int nb_sectors)
{
1301
1302
    int async_ret;
    BlockDriverAIOCB *acb;
bellard authored
1303
1304
1305

    async_ret = NOT_DONE;
    qemu_aio_wait_start();
1306
    acb = bdrv_aio_write(bs, sector_num, buf, nb_sectors,
bellard authored
1307
                         bdrv_rw_em_cb, &async_ret);
1308
    if (acb == NULL) {
bellard authored
1309
        qemu_aio_wait_end();
1310
        return -1;
bellard authored
1311
1312
1313
1314
1315
1316
1317
    }
    while (async_ret == NOT_DONE) {
        qemu_aio_wait();
    }
    qemu_aio_wait_end();
    return async_ret;
}
bellard authored
1318
1319
1320
1321

void bdrv_init(void)
{
    bdrv_register(&bdrv_raw);
1322
    bdrv_register(&bdrv_host_device);
bellard authored
1323
1324
1325
1326
1327
#ifndef _WIN32
    bdrv_register(&bdrv_cow);
#endif
    bdrv_register(&bdrv_qcow);
    bdrv_register(&bdrv_vmdk);
1328
    bdrv_register(&bdrv_cloop);
1329
    bdrv_register(&bdrv_dmg);
1330
    bdrv_register(&bdrv_bochs);
1331
    bdrv_register(&bdrv_vpc);
bellard authored
1332
    bdrv_register(&bdrv_vvfat);
bellard authored
1333
    bdrv_register(&bdrv_qcow2);
1334
    bdrv_register(&bdrv_parallels);
bellard authored
1335
}
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364

void *qemu_aio_get(BlockDriverState *bs, BlockDriverCompletionFunc *cb,
                   void *opaque)
{
    BlockDriver *drv;
    BlockDriverAIOCB *acb;

    drv = bs->drv;
    if (drv->free_aiocb) {
        acb = drv->free_aiocb;
        drv->free_aiocb = acb->next;
    } else {
        acb = qemu_mallocz(drv->aiocb_size);
        if (!acb)
            return NULL;
    }
    acb->bs = bs;
    acb->cb = cb;
    acb->opaque = opaque;
    return acb;
}

void qemu_aio_release(void *p)
{
    BlockDriverAIOCB *acb = p;
    BlockDriver *drv = acb->bs->drv;
    acb->next = drv->free_aiocb;
    drv->free_aiocb = acb;
}
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385

/**************************************************************/
/* 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
1386
 * function. It is currently only used for floppy disks
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
 */
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);
    }
}
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450

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