Blame view

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

/* 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
150
151
152
153
154
155
156
    if (device_name[0] != '\0') {
        /* insert at the end */
        pbs = &bdrv_first;
        while (*pbs != NULL)
            pbs = &(*pbs)->next;
        *pbs = bs;
    }
bellard authored
157
158
159
    return bs;
}
bellard authored
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
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;
}

int bdrv_create(BlockDriver *drv, 
                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
179
#ifdef _WIN32
180
void get_tmp_filename(char *filename, int size)
bellard authored
181
{
182
183
184
185
    char temp_dir[MAX_PATH];

    GetTempPath(MAX_PATH, temp_dir);
    GetTempFileName(temp_dir, "qem", 0, filename);
bellard authored
186
187
}
#else
188
void get_tmp_filename(char *filename, int size)
bellard authored
189
{
190
    int fd;
bellard authored
191
    /* XXX: race condition possible */
bellard authored
192
193
194
195
    pstrcpy(filename, size, "/tmp/vl.XXXXXX");
    fd = mkstemp(filename);
    close(fd);
}
bellard authored
196
#endif
bellard authored
197
198
#ifdef _WIN32
bellard authored
199
200
201
202
203
204
205
static int is_windows_drive_prefix(const char *filename)
{
    return (((filename[0] >= 'a' && filename[0] <= 'z') ||
             (filename[0] >= 'A' && filename[0] <= 'Z')) &&
            filename[1] == ':');
}
206
207
static int is_windows_drive(const char *filename)
{
bellard authored
208
209
    if (is_windows_drive_prefix(filename) && 
        filename[2] == '\0')
210
211
212
213
214
215
216
217
        return 1;
    if (strstart(filename, "\\\\.\\", NULL) ||
        strstart(filename, "//./", NULL))
        return 1;
    return 0;
}
#endif
bellard authored
218
219
220
221
222
223
static BlockDriver *find_protocol(const char *filename)
{
    BlockDriver *drv1;
    char protocol[128];
    int len;
    const char *p;
224
225

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

int bdrv_open(BlockDriverState *bs, const char *filename, int flags)
{
    return bdrv_open2(bs, filename, flags, NULL);
bellard authored
319
320
}
bellard authored
321
int bdrv_open2(BlockDriverState *bs, const char *filename, int flags,
bellard authored
322
323
               BlockDriver *drv)
{
bellard authored
324
    int ret, open_flags;
325
326
    char tmp_filename[PATH_MAX];
    char backing_filename[PATH_MAX];
bellard authored
327
328
329
330

    bs->read_only = 0;
    bs->is_temporary = 0;
    bs->encrypted = 0;
bellard authored
331
bellard authored
332
    if (flags & BDRV_O_SNAPSHOT) {
bellard authored
333
334
335
336
337
        BlockDriverState *bs1;
        int64_t total_size;

        /* if snapshot, we create a temporary backing file and open it
           instead of opening 'filename' directly */
338
bellard authored
339
340
341
        /* if there is a backing file, use it */
        bs1 = bdrv_new("");
        if (!bs1) {
bellard authored
342
            return -ENOMEM;
bellard authored
343
344
345
346
347
        }
        if (bdrv_open(bs1, filename, 0) < 0) {
            bdrv_delete(bs1);
            return -1;
        }
bellard authored
348
        total_size = bdrv_getlength(bs1) >> SECTOR_BITS;
bellard authored
349
350
351
        bdrv_delete(bs1);

        get_tmp_filename(tmp_filename, sizeof(tmp_filename));
352
        realpath(filename, backing_filename);
353
        if (bdrv_create(&bdrv_qcow2, tmp_filename, 
354
                        total_size, backing_filename, 0) < 0) {
bellard authored
355
356
357
358
359
            return -1;
        }
        filename = tmp_filename;
        bs->is_temporary = 1;
    }
bellard authored
360
bellard authored
361
    pstrcpy(bs->filename, sizeof(bs->filename), filename);
bellard authored
362
363
    if (flags & BDRV_O_FILE) {
        drv = find_protocol(filename);
bellard authored
364
        if (!drv)
bellard authored
365
366
367
368
369
370
371
            return -ENOENT;
    } else {
        if (!drv) {
            drv = find_image_format(filename);
            if (!drv)
                return -1;
        }
bellard authored
372
373
374
375
376
    }
    bs->drv = drv;
    bs->opaque = qemu_mallocz(drv->instance_size);
    if (bs->opaque == NULL && drv->instance_size > 0)
        return -1;
bellard authored
377
378
379
380
381
382
383
384
385
386
387
    /* Note: for compatibility, we open disk image files as RDWR, and
       RDONLY as fallback */
    if (!(flags & BDRV_O_FILE))
        open_flags = BDRV_O_RDWR;
    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
388
389
    if (ret < 0) {
        qemu_free(bs->opaque);
bellard authored
390
391
        bs->opaque = NULL;
        bs->drv = NULL;
bellard authored
392
        return ret;
393
    }
394
395
396
    if (drv->bdrv_getlength) {
        bs->total_sectors = bdrv_getlength(bs) >> SECTOR_BITS;
    }
397
#ifndef _WIN32
bellard authored
398
399
400
401
    if (bs->is_temporary) {
        unlink(filename);
    }
#endif
bellard authored
402
    if (bs->backing_file[0] != '\0') {
bellard authored
403
404
405
406
407
        /* if there is a backing file, use it */
        bs->backing_hd = bdrv_new("");
        if (!bs->backing_hd) {
        fail:
            bdrv_close(bs);
bellard authored
408
            return -ENOMEM;
409
        }
bellard authored
410
411
412
        path_combine(backing_filename, sizeof(backing_filename),
                     filename, bs->backing_file);
        if (bdrv_open(bs->backing_hd, backing_filename, 0) < 0)
413
414
415
            goto fail;
    }
bellard authored
416
    /* call the change callback */
417
    bs->media_changed = 1;
bellard authored
418
419
420
421
    if (bs->change_cb)
        bs->change_cb(bs->change_opaque);

    return 0;
bellard authored
422
423
424
425
}

void bdrv_close(BlockDriverState *bs)
{
426
    if (bs->drv) {
bellard authored
427
428
429
430
431
432
433
434
        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);
        }
435
#endif
bellard authored
436
437
        bs->opaque = NULL;
        bs->drv = NULL;
bellard authored
438
439

        /* call the change callback */
440
        bs->media_changed = 1;
bellard authored
441
442
443
444
445
446
447
        if (bs->change_cb)
            bs->change_cb(bs->change_opaque);
    }
}

void bdrv_delete(BlockDriverState *bs)
{
bellard authored
448
    /* XXX: remove the driver list */
bellard authored
449
450
    bdrv_close(bs);
    qemu_free(bs);
bellard authored
451
452
}
453
454
455
/* commit COW file into the raw image */
int bdrv_commit(BlockDriverState *bs)
{
456
    BlockDriver *drv = bs->drv;
bellard authored
457
    int64_t i, total_sectors;
bellard authored
458
459
    int n, j;
    unsigned char sector[512];
460
461
462
    if (!drv)
        return -ENOMEDIUM;
463
464

    if (bs->read_only) {
bellard authored
465
	return -EACCES;
466
467
    }
bellard authored
468
469
470
    if (!bs->backing_hd) {
	return -ENOTSUP;
    }
471
bellard authored
472
473
    total_sectors = bdrv_getlength(bs) >> SECTOR_BITS;
    for (i = 0; i < total_sectors;) {
474
        if (drv->bdrv_is_allocated(bs, i, 65536, &n)) {
bellard authored
475
476
477
478
479
480
481
482
483
            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++;
484
	    }
bellard authored
485
486
487
	} else {
            i += n;
        }
488
    }
489
490
491
    if (drv->bdrv_make_empty)
	return drv->bdrv_make_empty(bs);
492
493
494
495
    return 0;
}
496
/* return < 0 if error. See bdrv_write() for the return codes */
bellard authored
497
498
499
int bdrv_read(BlockDriverState *bs, int64_t sector_num, 
              uint8_t *buf, int nb_sectors)
{
bellard authored
500
501
    BlockDriver *drv = bs->drv;
502
503
    if (!drv)
        return -ENOMEDIUM;
bellard authored
504
bellard authored
505
    if (sector_num == 0 && bs->boot_sector_enabled && nb_sectors > 0) {
bellard authored
506
            memcpy(buf, bs->boot_sector_data, 512);
bellard authored
507
508
509
510
511
512
513
514
515
516
517
518
519
        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)
520
            return -EINVAL;
bellard authored
521
522
523
524
        else
            return 0;
    } else {
        return drv->bdrv_read(bs, sector_num, buf, nb_sectors);
525
    }
bellard authored
526
527
}
528
529
530
531
532
533
/* Return < 0 if error. Important errors are: 
  -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
*/
bellard authored
534
535
536
int bdrv_write(BlockDriverState *bs, int64_t sector_num, 
               const uint8_t *buf, int nb_sectors)
{
bellard authored
537
    BlockDriver *drv = bs->drv;
538
539
    if (!bs->drv)
        return -ENOMEDIUM;
bellard authored
540
    if (bs->read_only)
541
        return -EACCES;
542
543
544
    if (sector_num == 0 && bs->boot_sector_enabled && nb_sectors > 0) {
        memcpy(bs->boot_sector_data, buf, 512);   
    }
bellard authored
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
    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;
        else
            return 0;
    } else {
        return drv->bdrv_write(bs, sector_num, buf, nb_sectors);
    }
}

static int bdrv_pread_em(BlockDriverState *bs, int64_t offset, 
bellard authored
561
                         uint8_t *buf, int count1)
bellard authored
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
{
    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;
}

static int bdrv_pwrite_em(BlockDriverState *bs, int64_t offset, 
bellard authored
605
                          const uint8_t *buf, int count1)
bellard authored
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
{
    uint8_t tmp_buf[SECTOR_SIZE];
    int len, nb_sectors, count;
    int64_t sector_num;

    count = count1;
    /* first 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;
}

/**
 * Read with byte offsets (needed only for file protocols) 
 */
int bdrv_pread(BlockDriverState *bs, int64_t offset, 
               void *buf1, int count1)
{
    BlockDriver *drv = bs->drv;

    if (!drv)
661
        return -ENOMEDIUM;
bellard authored
662
    if (!drv->bdrv_pread)
bellard authored
663
        return bdrv_pread_em(bs, offset, buf1, count1);
bellard authored
664
665
666
667
668
669
670
671
672
673
674
675
    return drv->bdrv_pread(bs, offset, buf1, count1);
}

/** 
 * Write with byte offsets (needed only for file protocols) 
 */
int bdrv_pwrite(BlockDriverState *bs, int64_t offset, 
                const void *buf1, int count1)
{
    BlockDriver *drv = bs->drv;

    if (!drv)
676
        return -ENOMEDIUM;
bellard authored
677
    if (!drv->bdrv_pwrite)
bellard authored
678
        return bdrv_pwrite_em(bs, offset, buf1, count1);
bellard authored
679
680
681
682
683
684
685
686
687
688
    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)
689
        return -ENOMEDIUM;
bellard authored
690
691
692
693
694
695
696
697
698
699
700
701
    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)
702
        return -ENOMEDIUM;
bellard authored
703
704
705
706
707
    if (!drv->bdrv_getlength) {
        /* legacy mode */
        return bs->total_sectors * SECTOR_SIZE;
    }
    return drv->bdrv_getlength(bs);
bellard authored
708
709
}
710
/* return 0 as number of sectors if no device present or error */
bellard authored
711
712
void bdrv_get_geometry(BlockDriverState *bs, int64_t *nb_sectors_ptr)
{
713
714
715
716
717
718
719
    int64_t length;
    length = bdrv_getlength(bs);
    if (length < 0)
        length = 0;
    else
        length = length >> SECTOR_BITS;
    *nb_sectors_ptr = length;
bellard authored
720
}
bellard authored
721
722
723
724
725
726
727
728
729
730

/* 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
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746

void bdrv_set_geometry_hint(BlockDriverState *bs, 
                            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));
}
747
748
749
750
751
void bdrv_set_translation_hint(BlockDriverState *bs, int translation)
{
    bs->translation = translation;
}
bellard authored
752
753
754
755
756
757
758
759
760
761
762
763
764
void bdrv_get_geometry_hint(BlockDriverState *bs, 
                            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;
}
765
766
767
768
769
int bdrv_get_translation_hint(BlockDriverState *bs)
{
    return bs->translation;
}
bellard authored
770
771
772
773
774
775
776
777
778
779
int bdrv_is_removable(BlockDriverState *bs)
{
    return bs->removable;
}

int bdrv_is_read_only(BlockDriverState *bs)
{
    return bs->read_only;
}
780
/* XXX: no longer used */
bellard authored
781
782
783
784
785
786
787
void bdrv_set_change_cb(BlockDriverState *bs, 
                        void (*change_cb)(void *opaque), void *opaque)
{
    bs->change_cb = change_cb;
    bs->change_opaque = opaque;
}
bellard authored
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
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)
{
812
    if (!bs->drv) {
bellard authored
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
        buf[0] = '\0';
    } else {
        pstrcpy(buf, buf_size, bs->drv->format_name);
    }
}

void bdrv_iterate_format(void (*it)(void *opaque, const char *name), 
                         void *opaque)
{
    BlockDriver *drv;

    for (drv = first_drv; drv != NULL; drv = drv->next) {
        it(opaque, drv->format_name);
    }
}
bellard authored
829
830
831
832
833
834
835
836
837
838
839
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
840
841
842
843
844
845
846
847
848
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
849
850
851
852
853
const char *bdrv_get_device_name(BlockDriverState *bs)
{
    return bs->device_name;
}
pbrook authored
854
855
856
857
858
859
860
861
void bdrv_flush(BlockDriverState *bs)
{
    if (bs->drv->bdrv_flush)
        bs->drv->bdrv_flush(bs);
    if (bs->backing_hd)
        bdrv_flush(bs->backing_hd);
}
bellard authored
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
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);
        }
884
        if (bs->drv) {
885
886
887
888
889
890
            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
891
            term_printf(" ro=%d", bs->read_only);
bellard authored
892
893
894
            term_printf(" drv=%s", bs->drv->format_name);
            if (bs->encrypted)
                term_printf(" encrypted");
bellard authored
895
896
897
898
899
900
        } else {
            term_printf(" [not inserted]");
        }
        term_printf("\n");
    }
}
bellard authored
901
bellard authored
902
903
904
905
906
907
908
909
910
911
void bdrv_get_backing_filename(BlockDriverState *bs, 
                               char *filename, int filename_size)
{
    if (!bs->backing_hd) {
        pstrcpy(filename, filename_size, "");
    } else {
        pstrcpy(filename, filename_size, bs->backing_file);
    }
}
bellard authored
912
913
914
915
916
int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num, 
                          const uint8_t *buf, int nb_sectors)
{
    BlockDriver *drv = bs->drv;
    if (!drv)
917
        return -ENOMEDIUM;
bellard authored
918
919
920
921
922
923
924
925
926
    if (!drv->bdrv_write_compressed)
        return -ENOTSUP;
    return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);
}

int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
{
    BlockDriver *drv = bs->drv;
    if (!drv)
927
        return -ENOMEDIUM;
bellard authored
928
929
930
931
932
933
934
935
936
937
938
939
940
941
    if (!drv->bdrv_get_info)
        return -ENOTSUP;
    memset(bdi, 0, sizeof(*bdi));
    return drv->bdrv_get_info(bs, bdi);
}

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

int bdrv_snapshot_create(BlockDriverState *bs, 
                         QEMUSnapshotInfo *sn_info)
{
    BlockDriver *drv = bs->drv;
    if (!drv)
942
        return -ENOMEDIUM;
bellard authored
943
944
945
946
947
948
949
950
951
952
    if (!drv->bdrv_snapshot_create)
        return -ENOTSUP;
    return drv->bdrv_snapshot_create(bs, sn_info);
}

int bdrv_snapshot_goto(BlockDriverState *bs, 
                       const char *snapshot_id)
{
    BlockDriver *drv = bs->drv;
    if (!drv)
953
        return -ENOMEDIUM;
bellard authored
954
955
956
957
958
959
960
961
962
    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)
963
        return -ENOMEDIUM;
bellard authored
964
965
966
967
968
969
970
971
972
973
    if (!drv->bdrv_snapshot_delete)
        return -ENOTSUP;
    return drv->bdrv_snapshot_delete(bs, snapshot_id);
}

int bdrv_snapshot_list(BlockDriverState *bs, 
                       QEMUSnapshotInfo **psn_info)
{
    BlockDriver *drv = bs->drv;
    if (!drv)
974
        return -ENOMEDIUM;
bellard authored
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
    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)) {
                snprintf(buf, buf_size, "%0.1f%c", 
                         (double)size / base,
                         suffixes[i]);
                break;
            } else if (size < (1000 * base) || i == (NB_SUFFIXES - 1)) {
                snprintf(buf, buf_size, "%" PRId64 "%c", 
                         ((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];
1013
1014
1015
#ifdef _WIN32
    struct tm *ptm;
#else
bellard authored
1016
    struct tm tm;
1017
#endif
bellard authored
1018
1019
1020
1021
1022
1023
1024
1025
1026
    time_t ti;
    int64_t secs;

    if (!sn) {
        snprintf(buf, buf_size, 
                 "%-10s%-20s%7s%20s%15s", 
                 "ID", "TAG", "VM SIZE", "DATE", "VM CLOCK");
    } else {
        ti = sn->date_sec;
1027
1028
1029
1030
1031
#ifdef _WIN32
        ptm = localtime(&ti);
        strftime(date_buf, sizeof(date_buf),
                 "%Y-%m-%d %H:%M:%S", ptm);
#else
bellard authored
1032
1033
1034
        localtime_r(&ti, &tm);
        strftime(date_buf, sizeof(date_buf),
                 "%Y-%m-%d %H:%M:%S", &tm);
1035
#endif
bellard authored
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
        secs = sn->vm_clock_nsec / 1000000000;
        snprintf(clock_buf, sizeof(clock_buf),
                 "%02d:%02d:%02d.%03d",
                 (int)(secs / 3600),
                 (int)((secs / 60) % 60),
                 (int)(secs % 60), 
                 (int)((sn->vm_clock_nsec / 1000000) % 1000));
        snprintf(buf, buf_size,
                 "%-10s%-20s%7s%20s%15s", 
                 sn->id_str, sn->name,
                 get_human_readable_size(buf1, sizeof(buf1), sn->vm_state_size),
                 date_buf,
                 clock_buf);
    }
    return buf;
}
bellard authored
1053
bellard authored
1054
/**************************************************************/
bellard authored
1055
/* async I/Os */
bellard authored
1056
1057
1058
1059
BlockDriverAIOCB *bdrv_aio_read(BlockDriverState *bs, int64_t sector_num,
                                uint8_t *buf, int nb_sectors,
                                BlockDriverCompletionFunc *cb, void *opaque)
bellard authored
1060
1061
1062
{
    BlockDriver *drv = bs->drv;
1063
    if (!drv)
1064
        return NULL;
bellard authored
1065
1066
1067
1068
1069
1070
1071
1072
1073

    /* 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;
    }
1074
    return drv->bdrv_aio_read(bs, sector_num, buf, nb_sectors, cb, opaque);
bellard authored
1075
1076
}
1077
1078
1079
BlockDriverAIOCB *bdrv_aio_write(BlockDriverState *bs, int64_t sector_num,
                                 const uint8_t *buf, int nb_sectors,
                                 BlockDriverCompletionFunc *cb, void *opaque)
bellard authored
1080
{
bellard authored
1081
    BlockDriver *drv = bs->drv;
bellard authored
1082
1083
    if (!drv)
1084
        return NULL;
bellard authored
1085
    if (bs->read_only)
1086
        return NULL;
bellard authored
1087
1088
    if (sector_num == 0 && bs->boot_sector_enabled && nb_sectors > 0) {
        memcpy(bs->boot_sector_data, buf, 512);   
bellard authored
1089
    }
bellard authored
1090
1091
    return drv->bdrv_aio_write(bs, sector_num, buf, nb_sectors, cb, opaque);
bellard authored
1092
1093
1094
1095
}

void bdrv_aio_cancel(BlockDriverAIOCB *acb)
{
1096
    BlockDriver *drv = acb->bs->drv;
bellard authored
1097
1098
    drv->bdrv_aio_cancel(acb);
bellard authored
1099
1100
}
1101
bellard authored
1102
1103
1104
1105
/**************************************************************/
/* async block device emulation */

#ifdef QEMU_TOOL
1106
1107
1108
static BlockDriverAIOCB *bdrv_aio_read_em(BlockDriverState *bs,
        int64_t sector_num, uint8_t *buf, int nb_sectors,
        BlockDriverCompletionFunc *cb, void *opaque)
bellard authored
1109
1110
{
    int ret;
1111
1112
1113
    ret = bdrv_read(bs, sector_num, buf, nb_sectors);
    cb(opaque, ret);
    return NULL;
bellard authored
1114
1115
}
1116
1117
1118
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
1119
1120
{
    int ret;
1121
1122
1123
    ret = bdrv_write(bs, sector_num, buf, nb_sectors);
    cb(opaque, ret);
    return NULL;
bellard authored
1124
1125
}
bellard authored
1126
static void bdrv_aio_cancel_em(BlockDriverAIOCB *acb)
bellard authored
1127
1128
{
}
bellard authored
1129
#else
1130
static void bdrv_aio_bh_cb(void *opaque)
bellard authored
1131
{
1132
1133
1134
    BlockDriverAIOCBSync *acb = opaque;
    acb->common.cb(acb->common.opaque, acb->ret);
    qemu_aio_release(acb);
bellard authored
1135
}
1136
1137
1138
1139
static BlockDriverAIOCB *bdrv_aio_read_em(BlockDriverState *bs,
        int64_t sector_num, uint8_t *buf, int nb_sectors,
        BlockDriverCompletionFunc *cb, void *opaque)
bellard authored
1140
{
1141
    BlockDriverAIOCBSync *acb;
bellard authored
1142
    int ret;
1143
1144
1145
1146
1147
1148
1149
1150

    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;
1151
1152
}
1153
1154
1155
static BlockDriverAIOCB *bdrv_aio_write_em(BlockDriverState *bs,
        int64_t sector_num, const uint8_t *buf, int nb_sectors,
        BlockDriverCompletionFunc *cb, void *opaque)
1156
{
1157
    BlockDriverAIOCBSync *acb;
bellard authored
1158
1159
    int ret;
1160
1161
1162
1163
1164
1165
1166
    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;
1167
1168
}
1169
static void bdrv_aio_cancel_em(BlockDriverAIOCB *blockacb)
bellard authored
1170
{
1171
1172
1173
    BlockDriverAIOCBSync *acb = (BlockDriverAIOCBSync *)blockacb;
    qemu_bh_cancel(acb->bh);
    qemu_aio_release(acb);
bellard authored
1174
1175
}
#endif /* !QEMU_TOOL */
bellard authored
1176
bellard authored
1177
1178
/**************************************************************/
/* sync block device emulation */
bellard authored
1179
bellard authored
1180
1181
1182
static void bdrv_rw_em_cb(void *opaque, int ret)
{
    *(int *)opaque = ret;
bellard authored
1183
1184
}
bellard authored
1185
1186
1187
1188
#define NOT_DONE 0x7fffffff

static int bdrv_read_em(BlockDriverState *bs, int64_t sector_num, 
                        uint8_t *buf, int nb_sectors)
pbrook authored
1189
{
1190
1191
    int async_ret;
    BlockDriverAIOCB *acb;
bellard authored
1192
1193
1194

    async_ret = NOT_DONE;
    qemu_aio_wait_start();
1195
    acb = bdrv_aio_read(bs, sector_num, buf, nb_sectors, 
bellard authored
1196
                        bdrv_rw_em_cb, &async_ret);
1197
    if (acb == NULL) {
bellard authored
1198
        qemu_aio_wait_end();
1199
        return -1;
bellard authored
1200
1201
1202
1203
1204
1205
    }
    while (async_ret == NOT_DONE) {
        qemu_aio_wait();
    }
    qemu_aio_wait_end();
    return async_ret;
pbrook authored
1206
1207
}
bellard authored
1208
1209
1210
static int bdrv_write_em(BlockDriverState *bs, int64_t sector_num,
                         const uint8_t *buf, int nb_sectors)
{
1211
1212
    int async_ret;
    BlockDriverAIOCB *acb;
bellard authored
1213
1214
1215

    async_ret = NOT_DONE;
    qemu_aio_wait_start();
1216
    acb = bdrv_aio_write(bs, sector_num, buf, nb_sectors, 
bellard authored
1217
                         bdrv_rw_em_cb, &async_ret);
1218
    if (acb == NULL) {
bellard authored
1219
        qemu_aio_wait_end();
1220
        return -1;
bellard authored
1221
1222
1223
1224
1225
1226
1227
    }
    while (async_ret == NOT_DONE) {
        qemu_aio_wait();
    }
    qemu_aio_wait_end();
    return async_ret;
}
bellard authored
1228
1229
1230
1231

void bdrv_init(void)
{
    bdrv_register(&bdrv_raw);
1232
    bdrv_register(&bdrv_host_device);
bellard authored
1233
1234
1235
1236
1237
#ifndef _WIN32
    bdrv_register(&bdrv_cow);
#endif
    bdrv_register(&bdrv_qcow);
    bdrv_register(&bdrv_vmdk);
1238
    bdrv_register(&bdrv_cloop);
1239
    bdrv_register(&bdrv_dmg);
1240
    bdrv_register(&bdrv_bochs);
1241
    bdrv_register(&bdrv_vpc);
bellard authored
1242
    bdrv_register(&bdrv_vvfat);
bellard authored
1243
    bdrv_register(&bdrv_qcow2);
bellard authored
1244
}
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273

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;
}
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348

/**************************************************************/
/* 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
 * function. It is currently only used for floppy disks 
 */
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);
    }
}