Blame view

block.c 34.4 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;
bellard authored
194
    /* XXX: race condition possible */
bellard authored
195
196
197
198
    pstrcpy(filename, size, "/tmp/vl.XXXXXX");
    fd = mkstemp(filename);
    close(fd);
}
bellard authored
199
#endif
bellard authored
200
201
#ifdef _WIN32
bellard authored
202
203
204
205
206
207
static int is_windows_drive_prefix(const char *filename)
{
    return (((filename[0] >= 'a' && filename[0] <= 'z') ||
             (filename[0] >= 'A' && filename[0] <= 'Z')) &&
            filename[1] == ':');
}
208
209
210
static int is_windows_drive(const char *filename)
{
211
    if (is_windows_drive_prefix(filename) &&
bellard authored
212
        filename[2] == '\0')
213
214
215
216
217
218
219
220
        return 1;
    if (strstart(filename, "\\\\.\\", NULL) ||
        strstart(filename, "//./", NULL))
        return 1;
    return 0;
}
#endif
bellard authored
221
222
223
224
225
226
static BlockDriver *find_protocol(const char *filename)
{
    BlockDriver *drv1;
    char protocol[128];
    int len;
    const char *p;
227
228

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

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

    return 0;
bellard authored
425
426
427
428
}

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

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

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

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

/**
656
 * Read with byte offsets (needed only for file protocols)
bellard authored
657
 */
658
int bdrv_pread(BlockDriverState *bs, int64_t offset,
bellard authored
659
660
661
662
663
               void *buf1, int count1)
{
    BlockDriver *drv = bs->drv;

    if (!drv)
664
        return -ENOMEDIUM;
bellard authored
665
    if (!drv->bdrv_pread)
bellard authored
666
        return bdrv_pread_em(bs, offset, buf1, count1);
bellard authored
667
668
669
    return drv->bdrv_pread(bs, offset, buf1, count1);
}
670
671
/**
 * Write with byte offsets (needed only for file protocols)
bellard authored
672
 */
673
int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
bellard authored
674
675
676
677
678
                const void *buf1, int count1)
{
    BlockDriver *drv = bs->drv;

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

/* 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
734
735
void bdrv_set_geometry_hint(BlockDriverState *bs,
bellard authored
736
737
738
739
740
741
742
743
744
745
746
747
748
749
                            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));
}
750
751
752
753
754
void bdrv_set_translation_hint(BlockDriverState *bs, int translation)
{
    bs->translation = translation;
}
755
void bdrv_get_geometry_hint(BlockDriverState *bs,
bellard authored
756
757
758
759
760
761
762
763
764
765
766
767
                            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;
}
768
769
770
771
772
int bdrv_get_translation_hint(BlockDriverState *bs)
{
    return bs->translation;
}
bellard authored
773
774
775
776
777
778
779
780
781
782
int bdrv_is_removable(BlockDriverState *bs)
{
    return bs->removable;
}

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

    for (drv = first_drv; drv != NULL; drv = drv->next) {
        it(opaque, drv->format_name);
    }
}
bellard authored
832
833
834
835
836
837
838
839
840
841
842
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
843
844
845
846
847
848
849
850
851
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
852
853
854
855
856
const char *bdrv_get_device_name(BlockDriverState *bs)
{
    return bs->device_name;
}
pbrook authored
857
858
859
860
861
862
863
864
void bdrv_flush(BlockDriverState *bs)
{
    if (bs->drv->bdrv_flush)
        bs->drv->bdrv_flush(bs);
    if (bs->backing_hd)
        bdrv_flush(bs->backing_hd);
}
pbrook authored
865
#ifndef QEMU_IMG
bellard authored
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
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);
        }
888
        if (bs->drv) {
889
890
891
892
893
894
            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
895
            term_printf(" ro=%d", bs->read_only);
bellard authored
896
897
898
            term_printf(" drv=%s", bs->drv->format_name);
            if (bs->encrypted)
                term_printf(" encrypted");
bellard authored
899
900
901
902
903
904
        } else {
            term_printf(" [not inserted]");
        }
        term_printf("\n");
    }
}
pbrook authored
905
#endif
bellard authored
906
907
void bdrv_get_backing_filename(BlockDriverState *bs,
bellard authored
908
909
910
911
912
913
914
915
916
                               char *filename, int filename_size)
{
    if (!bs->backing_hd) {
        pstrcpy(filename, filename_size, "");
    } else {
        pstrcpy(filename, filename_size, bs->backing_file);
    }
}
917
int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
bellard authored
918
919
920
921
                          const uint8_t *buf, int nb_sectors)
{
    BlockDriver *drv = bs->drv;
    if (!drv)
922
        return -ENOMEDIUM;
bellard authored
923
924
925
926
    if (!drv->bdrv_write_compressed)
        return -ENOTSUP;
    return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);
}
927
bellard authored
928
929
930
931
int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
{
    BlockDriver *drv = bs->drv;
    if (!drv)
932
        return -ENOMEDIUM;
bellard authored
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 */
942
int bdrv_snapshot_create(BlockDriverState *bs,
bellard authored
943
944
945
946
                         QEMUSnapshotInfo *sn_info)
{
    BlockDriver *drv = bs->drv;
    if (!drv)
947
        return -ENOMEDIUM;
bellard authored
948
949
950
951
952
    if (!drv->bdrv_snapshot_create)
        return -ENOTSUP;
    return drv->bdrv_snapshot_create(bs, sn_info);
}
953
int bdrv_snapshot_goto(BlockDriverState *bs,
bellard authored
954
955
956
957
                       const char *snapshot_id)
{
    BlockDriver *drv = bs->drv;
    if (!drv)
958
        return -ENOMEDIUM;
bellard authored
959
960
961
962
963
964
965
966
967
    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)
968
        return -ENOMEDIUM;
bellard authored
969
970
971
972
973
    if (!drv->bdrv_snapshot_delete)
        return -ENOTSUP;
    return drv->bdrv_snapshot_delete(bs, snapshot_id);
}
974
int bdrv_snapshot_list(BlockDriverState *bs,
bellard authored
975
976
977
978
                       QEMUSnapshotInfo **psn_info)
{
    BlockDriver *drv = bs->drv;
    if (!drv)
979
        return -ENOMEDIUM;
bellard authored
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
    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)) {
999
                snprintf(buf, buf_size, "%0.1f%c",
bellard authored
1000
1001
1002
1003
                         (double)size / base,
                         suffixes[i]);
                break;
            } else if (size < (1000 * base) || i == (NB_SUFFIXES - 1)) {
1004
                snprintf(buf, buf_size, "%" PRId64 "%c",
bellard authored
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
                         ((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];
1018
1019
1020
#ifdef _WIN32
    struct tm *ptm;
#else
bellard authored
1021
    struct tm tm;
1022
#endif
bellard authored
1023
1024
1025
1026
    time_t ti;
    int64_t secs;

    if (!sn) {
1027
1028
        snprintf(buf, buf_size,
                 "%-10s%-20s%7s%20s%15s",
bellard authored
1029
1030
1031
                 "ID", "TAG", "VM SIZE", "DATE", "VM CLOCK");
    } else {
        ti = sn->date_sec;
1032
1033
1034
1035
1036
#ifdef _WIN32
        ptm = localtime(&ti);
        strftime(date_buf, sizeof(date_buf),
                 "%Y-%m-%d %H:%M:%S", ptm);
#else
bellard authored
1037
1038
1039
        localtime_r(&ti, &tm);
        strftime(date_buf, sizeof(date_buf),
                 "%Y-%m-%d %H:%M:%S", &tm);
1040
#endif
bellard authored
1041
1042
1043
1044
1045
        secs = sn->vm_clock_nsec / 1000000000;
        snprintf(clock_buf, sizeof(clock_buf),
                 "%02d:%02d:%02d.%03d",
                 (int)(secs / 3600),
                 (int)((secs / 60) % 60),
1046
                 (int)(secs % 60),
bellard authored
1047
1048
                 (int)((sn->vm_clock_nsec / 1000000) % 1000));
        snprintf(buf, buf_size,
1049
                 "%-10s%-20s%7s%20s%15s",
bellard authored
1050
1051
1052
1053
1054
1055
1056
1057
                 sn->id_str, sn->name,
                 get_human_readable_size(buf1, sizeof(buf1), sn->vm_state_size),
                 date_buf,
                 clock_buf);
    }
    return buf;
}
bellard authored
1058
bellard authored
1059
/**************************************************************/
bellard authored
1060
/* async I/Os */
bellard authored
1061
1062
1063
1064
BlockDriverAIOCB *bdrv_aio_read(BlockDriverState *bs, int64_t sector_num,
                                uint8_t *buf, int nb_sectors,
                                BlockDriverCompletionFunc *cb, void *opaque)
bellard authored
1065
1066
1067
{
    BlockDriver *drv = bs->drv;
1068
    if (!drv)
1069
        return NULL;
1070
bellard authored
1071
1072
1073
1074
1075
1076
1077
1078
    /* 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;
    }
1079
    return drv->bdrv_aio_read(bs, sector_num, buf, nb_sectors, cb, opaque);
bellard authored
1080
1081
}
1082
1083
1084
BlockDriverAIOCB *bdrv_aio_write(BlockDriverState *bs, int64_t sector_num,
                                 const uint8_t *buf, int nb_sectors,
                                 BlockDriverCompletionFunc *cb, void *opaque)
bellard authored
1085
{
bellard authored
1086
    BlockDriver *drv = bs->drv;
bellard authored
1087
1088
    if (!drv)
1089
        return NULL;
bellard authored
1090
    if (bs->read_only)
1091
        return NULL;
bellard authored
1092
    if (sector_num == 0 && bs->boot_sector_enabled && nb_sectors > 0) {
1093
        memcpy(bs->boot_sector_data, buf, 512);
bellard authored
1094
    }
bellard authored
1095
1096
    return drv->bdrv_aio_write(bs, sector_num, buf, nb_sectors, cb, opaque);
bellard authored
1097
1098
1099
1100
}

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

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

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

    async_ret = NOT_DONE;
    qemu_aio_wait_start();
1221
    acb = bdrv_aio_write(bs, sector_num, buf, nb_sectors,
bellard authored
1222
                         bdrv_rw_em_cb, &async_ret);
1223
    if (acb == NULL) {
bellard authored
1224
        qemu_aio_wait_end();
1225
        return -1;
bellard authored
1226
1227
1228
1229
1230
1231
1232
    }
    while (async_ret == NOT_DONE) {
        qemu_aio_wait();
    }
    qemu_aio_wait_end();
    return async_ret;
}
bellard authored
1233
1234
1235
1236

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

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;
}
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300

/**************************************************************/
/* 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
1301
 * function. It is currently only used for floppy disks
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
1349
1350
1351
1352
1353
1354
 */
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);
    }
}