Statistics
| Branch: | Revision:

root / block.c @ a76bab49

History | View | Annotate | Download (36.2 kB)

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

    
28
#ifdef _BSD
29
#include <sys/types.h>
30
#include <sys/stat.h>
31
#include <sys/ioctl.h>
32
#include <sys/queue.h>
33
#include <sys/disk.h>
34
#endif
35

    
36
#define SECTOR_BITS 9
37
#define SECTOR_SIZE (1 << SECTOR_BITS)
38

    
39
typedef struct BlockDriverAIOCBSync {
40
    BlockDriverAIOCB common;
41
    QEMUBH *bh;
42
    int ret;
43
} BlockDriverAIOCBSync;
44

    
45
static BlockDriverAIOCB *bdrv_aio_read_em(BlockDriverState *bs,
46
        int64_t sector_num, uint8_t *buf, int nb_sectors,
47
        BlockDriverCompletionFunc *cb, void *opaque);
48
static BlockDriverAIOCB *bdrv_aio_write_em(BlockDriverState *bs,
49
        int64_t sector_num, const uint8_t *buf, int nb_sectors,
50
        BlockDriverCompletionFunc *cb, void *opaque);
51
static void bdrv_aio_cancel_em(BlockDriverAIOCB *acb);
52
static int bdrv_read_em(BlockDriverState *bs, int64_t sector_num,
53
                        uint8_t *buf, int nb_sectors);
54
static int bdrv_write_em(BlockDriverState *bs, int64_t sector_num,
55
                         const uint8_t *buf, int nb_sectors);
56

    
57
BlockDriverState *bdrv_first;
58

    
59
static BlockDriver *first_drv;
60

    
61
int path_is_absolute(const char *path)
62
{
63
    const char *p;
64
#ifdef _WIN32
65
    /* specific case for names like: "\\.\d:" */
66
    if (*path == '/' || *path == '\\')
67
        return 1;
68
#endif
69
    p = strchr(path, ':');
70
    if (p)
71
        p++;
72
    else
73
        p = path;
74
#ifdef _WIN32
75
    return (*p == '/' || *p == '\\');
76
#else
77
    return (*p == '/');
78
#endif
79
}
80

    
81
/* if filename is absolute, just copy it to dest. Otherwise, build a
82
   path to it by considering it is relative to base_path. URL are
83
   supported. */
84
void path_combine(char *dest, int dest_size,
85
                  const char *base_path,
86
                  const char *filename)
87
{
88
    const char *p, *p1;
89
    int len;
90

    
91
    if (dest_size <= 0)
92
        return;
93
    if (path_is_absolute(filename)) {
94
        pstrcpy(dest, dest_size, filename);
95
    } else {
96
        p = strchr(base_path, ':');
97
        if (p)
98
            p++;
99
        else
100
            p = base_path;
101
        p1 = strrchr(base_path, '/');
102
#ifdef _WIN32
103
        {
104
            const char *p2;
105
            p2 = strrchr(base_path, '\\');
106
            if (!p1 || p2 > p1)
107
                p1 = p2;
108
        }
109
#endif
110
        if (p1)
111
            p1++;
112
        else
113
            p1 = base_path;
114
        if (p1 > p)
115
            p = p1;
116
        len = p - base_path;
117
        if (len > dest_size - 1)
118
            len = dest_size - 1;
119
        memcpy(dest, base_path, len);
120
        dest[len] = '\0';
121
        pstrcat(dest, dest_size, filename);
122
    }
123
}
124

    
125

    
126
static void bdrv_register(BlockDriver *bdrv)
127
{
128
    if (!bdrv->bdrv_aio_read) {
129
        /* add AIO emulation layer */
130
        bdrv->bdrv_aio_read = bdrv_aio_read_em;
131
        bdrv->bdrv_aio_write = bdrv_aio_write_em;
132
        bdrv->bdrv_aio_cancel = bdrv_aio_cancel_em;
133
        bdrv->aiocb_size = sizeof(BlockDriverAIOCBSync);
134
    } else if (!bdrv->bdrv_read && !bdrv->bdrv_pread) {
135
        /* add synchronous IO emulation layer */
136
        bdrv->bdrv_read = bdrv_read_em;
137
        bdrv->bdrv_write = bdrv_write_em;
138
    }
139
    bdrv->next = first_drv;
140
    first_drv = bdrv;
141
}
142

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

    
148
    bs = qemu_mallocz(sizeof(BlockDriverState));
149
    if(!bs)
150
        return NULL;
151
    pstrcpy(bs->device_name, sizeof(bs->device_name), device_name);
152
    if (device_name[0] != '\0') {
153
        /* insert at the end */
154
        pbs = &bdrv_first;
155
        while (*pbs != NULL)
156
            pbs = &(*pbs)->next;
157
        *pbs = bs;
158
    }
159
    return bs;
160
}
161

    
162
BlockDriver *bdrv_find_format(const char *format_name)
163
{
164
    BlockDriver *drv1;
165
    for(drv1 = first_drv; drv1 != NULL; drv1 = drv1->next) {
166
        if (!strcmp(drv1->format_name, format_name))
167
            return drv1;
168
    }
169
    return NULL;
170
}
171

    
172
int bdrv_create(BlockDriver *drv,
173
                const char *filename, int64_t size_in_sectors,
174
                const char *backing_file, int flags)
175
{
176
    if (!drv->bdrv_create)
177
        return -ENOTSUP;
178
    return drv->bdrv_create(filename, size_in_sectors, backing_file, flags);
179
}
180

    
181
#ifdef _WIN32
182
void get_tmp_filename(char *filename, int size)
183
{
184
    char temp_dir[MAX_PATH];
185

    
186
    GetTempPath(MAX_PATH, temp_dir);
187
    GetTempFileName(temp_dir, "qem", 0, filename);
188
}
189
#else
190
void get_tmp_filename(char *filename, int size)
191
{
192
    int fd;
193
    const char *tmpdir;
194
    /* XXX: race condition possible */
195
    tmpdir = getenv("TMPDIR");
196
    if (!tmpdir)
197
        tmpdir = "/tmp";
198
    snprintf(filename, size, "%s/vl.XXXXXX", tmpdir);
199
    fd = mkstemp(filename);
200
    close(fd);
201
}
202
#endif
203

    
204
#ifdef _WIN32
205
static int is_windows_drive_prefix(const char *filename)
206
{
207
    return (((filename[0] >= 'a' && filename[0] <= 'z') ||
208
             (filename[0] >= 'A' && filename[0] <= 'Z')) &&
209
            filename[1] == ':');
210
}
211

    
212
static int is_windows_drive(const char *filename)
213
{
214
    if (is_windows_drive_prefix(filename) &&
215
        filename[2] == '\0')
216
        return 1;
217
    if (strstart(filename, "\\\\.\\", NULL) ||
218
        strstart(filename, "//./", NULL))
219
        return 1;
220
    return 0;
221
}
222
#endif
223

    
224
static BlockDriver *find_protocol(const char *filename)
225
{
226
    BlockDriver *drv1;
227
    char protocol[128];
228
    int len;
229
    const char *p;
230

    
231
#ifdef _WIN32
232
    if (is_windows_drive(filename) ||
233
        is_windows_drive_prefix(filename))
234
        return &bdrv_raw;
235
#endif
236
    p = strchr(filename, ':');
237
    if (!p)
238
        return &bdrv_raw;
239
    len = p - filename;
240
    if (len > sizeof(protocol) - 1)
241
        len = sizeof(protocol) - 1;
242
    memcpy(protocol, filename, len);
243
    protocol[len] = '\0';
244
    for(drv1 = first_drv; drv1 != NULL; drv1 = drv1->next) {
245
        if (drv1->protocol_name &&
246
            !strcmp(drv1->protocol_name, protocol))
247
            return drv1;
248
    }
249
    return NULL;
250
}
251

    
252
/* XXX: force raw format if block or character device ? It would
253
   simplify the BSD case */
254
static BlockDriver *find_image_format(const char *filename)
255
{
256
    int ret, score, score_max;
257
    BlockDriver *drv1, *drv;
258
    uint8_t buf[2048];
259
    BlockDriverState *bs;
260

    
261
    /* detect host devices. By convention, /dev/cdrom[N] is always
262
       recognized as a host CDROM */
263
    if (strstart(filename, "/dev/cdrom", NULL))
264
        return &bdrv_host_device;
265
#ifdef _WIN32
266
    if (is_windows_drive(filename))
267
        return &bdrv_host_device;
268
#else
269
    {
270
        struct stat st;
271
        if (stat(filename, &st) >= 0 &&
272
            (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode))) {
273
            return &bdrv_host_device;
274
        }
275
    }
276
#endif
277

    
278
    drv = find_protocol(filename);
279
    /* no need to test disk image formats for vvfat */
280
    if (drv == &bdrv_vvfat)
281
        return drv;
282

    
283
    ret = bdrv_file_open(&bs, filename, BDRV_O_RDONLY);
284
    if (ret < 0)
285
        return NULL;
286
    ret = bdrv_pread(bs, 0, buf, sizeof(buf));
287
    bdrv_delete(bs);
288
    if (ret < 0) {
289
        return NULL;
290
    }
291

    
292
    score_max = 0;
293
    for(drv1 = first_drv; drv1 != NULL; drv1 = drv1->next) {
294
        if (drv1->bdrv_probe) {
295
            score = drv1->bdrv_probe(buf, ret, filename);
296
            if (score > score_max) {
297
                score_max = score;
298
                drv = drv1;
299
            }
300
        }
301
    }
302
    return drv;
303
}
304

    
305
int bdrv_file_open(BlockDriverState **pbs, const char *filename, int flags)
306
{
307
    BlockDriverState *bs;
308
    int ret;
309

    
310
    bs = bdrv_new("");
311
    if (!bs)
312
        return -ENOMEM;
313
    ret = bdrv_open2(bs, filename, flags | BDRV_O_FILE, NULL);
314
    if (ret < 0) {
315
        bdrv_delete(bs);
316
        return ret;
317
    }
318
    *pbs = bs;
319
    return 0;
320
}
321

    
322
int bdrv_open(BlockDriverState *bs, const char *filename, int flags)
323
{
324
    return bdrv_open2(bs, filename, flags, NULL);
325
}
326

    
327
int bdrv_open2(BlockDriverState *bs, const char *filename, int flags,
328
               BlockDriver *drv)
329
{
330
    int ret, open_flags;
331
    char tmp_filename[PATH_MAX];
332
    char backing_filename[PATH_MAX];
333

    
334
    bs->read_only = 0;
335
    bs->is_temporary = 0;
336
    bs->encrypted = 0;
337

    
338
    if (flags & BDRV_O_SNAPSHOT) {
339
        BlockDriverState *bs1;
340
        int64_t total_size;
341
        int is_protocol = 0;
342

    
343
        /* if snapshot, we create a temporary backing file and open it
344
           instead of opening 'filename' directly */
345

    
346
        /* if there is a backing file, use it */
347
        bs1 = bdrv_new("");
348
        if (!bs1) {
349
            return -ENOMEM;
350
        }
351
        if (bdrv_open(bs1, filename, 0) < 0) {
352
            bdrv_delete(bs1);
353
            return -1;
354
        }
355
        total_size = bdrv_getlength(bs1) >> SECTOR_BITS;
356

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

    
360
        bdrv_delete(bs1);
361

    
362
        get_tmp_filename(tmp_filename, sizeof(tmp_filename));
363

    
364
        /* Real path is meaningless for protocols */
365
        if (is_protocol)
366
            snprintf(backing_filename, sizeof(backing_filename),
367
                     "%s", filename);
368
        else
369
            realpath(filename, backing_filename);
370

    
371
        if (bdrv_create(&bdrv_qcow2, tmp_filename,
372
                        total_size, backing_filename, 0) < 0) {
373
            return -1;
374
        }
375
        filename = tmp_filename;
376
        bs->is_temporary = 1;
377
    }
378

    
379
    pstrcpy(bs->filename, sizeof(bs->filename), filename);
380
    if (flags & BDRV_O_FILE) {
381
        drv = find_protocol(filename);
382
        if (!drv)
383
            return -ENOENT;
384
    } else {
385
        if (!drv) {
386
            drv = find_image_format(filename);
387
            if (!drv)
388
                return -1;
389
        }
390
    }
391
    bs->drv = drv;
392
    bs->opaque = qemu_mallocz(drv->instance_size);
393
    if (bs->opaque == NULL && drv->instance_size > 0)
394
        return -1;
395
    /* Note: for compatibility, we open disk image files as RDWR, and
396
       RDONLY as fallback */
397
    if (!(flags & BDRV_O_FILE))
398
        open_flags = BDRV_O_RDWR | (flags & BDRV_O_DIRECT);
399
    else
400
        open_flags = flags & ~(BDRV_O_FILE | BDRV_O_SNAPSHOT);
401
    ret = drv->bdrv_open(bs, filename, open_flags);
402
    if (ret == -EACCES && !(flags & BDRV_O_FILE)) {
403
        ret = drv->bdrv_open(bs, filename, BDRV_O_RDONLY);
404
        bs->read_only = 1;
405
    }
406
    if (ret < 0) {
407
        qemu_free(bs->opaque);
408
        bs->opaque = NULL;
409
        bs->drv = NULL;
410
        return ret;
411
    }
412
    if (drv->bdrv_getlength) {
413
        bs->total_sectors = bdrv_getlength(bs) >> SECTOR_BITS;
414
    }
415
#ifndef _WIN32
416
    if (bs->is_temporary) {
417
        unlink(filename);
418
    }
419
#endif
420
    if (bs->backing_file[0] != '\0') {
421
        /* if there is a backing file, use it */
422
        bs->backing_hd = bdrv_new("");
423
        if (!bs->backing_hd) {
424
        fail:
425
            bdrv_close(bs);
426
            return -ENOMEM;
427
        }
428
        path_combine(backing_filename, sizeof(backing_filename),
429
                     filename, bs->backing_file);
430
        if (bdrv_open(bs->backing_hd, backing_filename, 0) < 0)
431
            goto fail;
432
    }
433

    
434
    /* call the change callback */
435
    bs->media_changed = 1;
436
    if (bs->change_cb)
437
        bs->change_cb(bs->change_opaque);
438

    
439
    return 0;
440
}
441

    
442
void bdrv_close(BlockDriverState *bs)
443
{
444
    if (bs->drv) {
445
        if (bs->backing_hd)
446
            bdrv_delete(bs->backing_hd);
447
        bs->drv->bdrv_close(bs);
448
        qemu_free(bs->opaque);
449
#ifdef _WIN32
450
        if (bs->is_temporary) {
451
            unlink(bs->filename);
452
        }
453
#endif
454
        bs->opaque = NULL;
455
        bs->drv = NULL;
456

    
457
        /* call the change callback */
458
        bs->media_changed = 1;
459
        if (bs->change_cb)
460
            bs->change_cb(bs->change_opaque);
461
    }
462
}
463

    
464
void bdrv_delete(BlockDriverState *bs)
465
{
466
    BlockDriverState **pbs;
467

    
468
    pbs = &bdrv_first;
469
    while (*pbs != bs && *pbs != NULL)
470
        pbs = &(*pbs)->next;
471
    if (*pbs == bs)
472
        *pbs = bs->next;
473

    
474
    bdrv_close(bs);
475
    qemu_free(bs);
476
}
477

    
478
/* commit COW file into the raw image */
479
int bdrv_commit(BlockDriverState *bs)
480
{
481
    BlockDriver *drv = bs->drv;
482
    int64_t i, total_sectors;
483
    int n, j;
484
    unsigned char sector[512];
485

    
486
    if (!drv)
487
        return -ENOMEDIUM;
488

    
489
    if (bs->read_only) {
490
        return -EACCES;
491
    }
492

    
493
    if (!bs->backing_hd) {
494
        return -ENOTSUP;
495
    }
496

    
497
    total_sectors = bdrv_getlength(bs) >> SECTOR_BITS;
498
    for (i = 0; i < total_sectors;) {
499
        if (drv->bdrv_is_allocated(bs, i, 65536, &n)) {
500
            for(j = 0; j < n; j++) {
501
                if (bdrv_read(bs, i, sector, 1) != 0) {
502
                    return -EIO;
503
                }
504

    
505
                if (bdrv_write(bs->backing_hd, i, sector, 1) != 0) {
506
                    return -EIO;
507
                }
508
                i++;
509
            }
510
        } else {
511
            i += n;
512
        }
513
    }
514

    
515
    if (drv->bdrv_make_empty)
516
        return drv->bdrv_make_empty(bs);
517

    
518
    return 0;
519
}
520

    
521
/* return < 0 if error. See bdrv_write() for the return codes */
522
int bdrv_read(BlockDriverState *bs, int64_t sector_num,
523
              uint8_t *buf, int nb_sectors)
524
{
525
    BlockDriver *drv = bs->drv;
526

    
527
    if (!drv)
528
        return -ENOMEDIUM;
529

    
530
    if (sector_num == 0 && bs->boot_sector_enabled && nb_sectors > 0) {
531
            memcpy(buf, bs->boot_sector_data, 512);
532
        sector_num++;
533
        nb_sectors--;
534
        buf += 512;
535
        if (nb_sectors == 0)
536
            return 0;
537
    }
538
    if (drv->bdrv_pread) {
539
        int ret, len;
540
        len = nb_sectors * 512;
541
        ret = drv->bdrv_pread(bs, sector_num * 512, buf, len);
542
        if (ret < 0)
543
            return ret;
544
        else if (ret != len)
545
            return -EINVAL;
546
        else {
547
            bs->rd_bytes += (unsigned) len;
548
            bs->rd_ops ++;
549
            return 0;
550
        }
551
    } else {
552
        return drv->bdrv_read(bs, sector_num, buf, nb_sectors);
553
    }
554
}
555

    
556
/* Return < 0 if error. Important errors are:
557
  -EIO         generic I/O error (may happen for all errors)
558
  -ENOMEDIUM   No media inserted.
559
  -EINVAL      Invalid sector number or nb_sectors
560
  -EACCES      Trying to write a read-only device
561
*/
562
int bdrv_write(BlockDriverState *bs, int64_t sector_num,
563
               const uint8_t *buf, int nb_sectors)
564
{
565
    BlockDriver *drv = bs->drv;
566
    if (!bs->drv)
567
        return -ENOMEDIUM;
568
    if (bs->read_only)
569
        return -EACCES;
570
    if (sector_num == 0 && bs->boot_sector_enabled && nb_sectors > 0) {
571
        memcpy(bs->boot_sector_data, buf, 512);
572
    }
573
    if (drv->bdrv_pwrite) {
574
        int ret, len;
575
        len = nb_sectors * 512;
576
        ret = drv->bdrv_pwrite(bs, sector_num * 512, buf, len);
577
        if (ret < 0)
578
            return ret;
579
        else if (ret != len)
580
            return -EIO;
581
        else {
582
            bs->wr_bytes += (unsigned) len;
583
            bs->wr_ops ++;
584
            return 0;
585
        }
586
    } else {
587
        return drv->bdrv_write(bs, sector_num, buf, nb_sectors);
588
    }
589
}
590

    
591
static int bdrv_pread_em(BlockDriverState *bs, int64_t offset,
592
                         uint8_t *buf, int count1)
593
{
594
    uint8_t tmp_buf[SECTOR_SIZE];
595
    int len, nb_sectors, count;
596
    int64_t sector_num;
597

    
598
    count = count1;
599
    /* first read to align to sector start */
600
    len = (SECTOR_SIZE - offset) & (SECTOR_SIZE - 1);
601
    if (len > count)
602
        len = count;
603
    sector_num = offset >> SECTOR_BITS;
604
    if (len > 0) {
605
        if (bdrv_read(bs, sector_num, tmp_buf, 1) < 0)
606
            return -EIO;
607
        memcpy(buf, tmp_buf + (offset & (SECTOR_SIZE - 1)), len);
608
        count -= len;
609
        if (count == 0)
610
            return count1;
611
        sector_num++;
612
        buf += len;
613
    }
614

    
615
    /* read the sectors "in place" */
616
    nb_sectors = count >> SECTOR_BITS;
617
    if (nb_sectors > 0) {
618
        if (bdrv_read(bs, sector_num, buf, nb_sectors) < 0)
619
            return -EIO;
620
        sector_num += nb_sectors;
621
        len = nb_sectors << SECTOR_BITS;
622
        buf += len;
623
        count -= len;
624
    }
625

    
626
    /* add data from the last sector */
627
    if (count > 0) {
628
        if (bdrv_read(bs, sector_num, tmp_buf, 1) < 0)
629
            return -EIO;
630
        memcpy(buf, tmp_buf, count);
631
    }
632
    return count1;
633
}
634

    
635
static int bdrv_pwrite_em(BlockDriverState *bs, int64_t offset,
636
                          const uint8_t *buf, int count1)
637
{
638
    uint8_t tmp_buf[SECTOR_SIZE];
639
    int len, nb_sectors, count;
640
    int64_t sector_num;
641

    
642
    count = count1;
643
    /* first write to align to sector start */
644
    len = (SECTOR_SIZE - offset) & (SECTOR_SIZE - 1);
645
    if (len > count)
646
        len = count;
647
    sector_num = offset >> SECTOR_BITS;
648
    if (len > 0) {
649
        if (bdrv_read(bs, sector_num, tmp_buf, 1) < 0)
650
            return -EIO;
651
        memcpy(tmp_buf + (offset & (SECTOR_SIZE - 1)), buf, len);
652
        if (bdrv_write(bs, sector_num, tmp_buf, 1) < 0)
653
            return -EIO;
654
        count -= len;
655
        if (count == 0)
656
            return count1;
657
        sector_num++;
658
        buf += len;
659
    }
660

    
661
    /* write the sectors "in place" */
662
    nb_sectors = count >> SECTOR_BITS;
663
    if (nb_sectors > 0) {
664
        if (bdrv_write(bs, sector_num, buf, nb_sectors) < 0)
665
            return -EIO;
666
        sector_num += nb_sectors;
667
        len = nb_sectors << SECTOR_BITS;
668
        buf += len;
669
        count -= len;
670
    }
671

    
672
    /* add data from the last sector */
673
    if (count > 0) {
674
        if (bdrv_read(bs, sector_num, tmp_buf, 1) < 0)
675
            return -EIO;
676
        memcpy(tmp_buf, buf, count);
677
        if (bdrv_write(bs, sector_num, tmp_buf, 1) < 0)
678
            return -EIO;
679
    }
680
    return count1;
681
}
682

    
683
/**
684
 * Read with byte offsets (needed only for file protocols)
685
 */
686
int bdrv_pread(BlockDriverState *bs, int64_t offset,
687
               void *buf1, int count1)
688
{
689
    BlockDriver *drv = bs->drv;
690

    
691
    if (!drv)
692
        return -ENOMEDIUM;
693
    if (!drv->bdrv_pread)
694
        return bdrv_pread_em(bs, offset, buf1, count1);
695
    return drv->bdrv_pread(bs, offset, buf1, count1);
696
}
697

    
698
/**
699
 * Write with byte offsets (needed only for file protocols)
700
 */
701
int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
702
                const void *buf1, int count1)
703
{
704
    BlockDriver *drv = bs->drv;
705

    
706
    if (!drv)
707
        return -ENOMEDIUM;
708
    if (!drv->bdrv_pwrite)
709
        return bdrv_pwrite_em(bs, offset, buf1, count1);
710
    return drv->bdrv_pwrite(bs, offset, buf1, count1);
711
}
712

    
713
/**
714
 * Truncate file to 'offset' bytes (needed only for file protocols)
715
 */
716
int bdrv_truncate(BlockDriverState *bs, int64_t offset)
717
{
718
    BlockDriver *drv = bs->drv;
719
    if (!drv)
720
        return -ENOMEDIUM;
721
    if (!drv->bdrv_truncate)
722
        return -ENOTSUP;
723
    return drv->bdrv_truncate(bs, offset);
724
}
725

    
726
/**
727
 * Length of a file in bytes. Return < 0 if error or unknown.
728
 */
729
int64_t bdrv_getlength(BlockDriverState *bs)
730
{
731
    BlockDriver *drv = bs->drv;
732
    if (!drv)
733
        return -ENOMEDIUM;
734
    if (!drv->bdrv_getlength) {
735
        /* legacy mode */
736
        return bs->total_sectors * SECTOR_SIZE;
737
    }
738
    return drv->bdrv_getlength(bs);
739
}
740

    
741
/* return 0 as number of sectors if no device present or error */
742
void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
743
{
744
    int64_t length;
745
    length = bdrv_getlength(bs);
746
    if (length < 0)
747
        length = 0;
748
    else
749
        length = length >> SECTOR_BITS;
750
    *nb_sectors_ptr = length;
751
}
752

    
753
/* force a given boot sector. */
754
void bdrv_set_boot_sector(BlockDriverState *bs, const uint8_t *data, int size)
755
{
756
    bs->boot_sector_enabled = 1;
757
    if (size > 512)
758
        size = 512;
759
    memcpy(bs->boot_sector_data, data, size);
760
    memset(bs->boot_sector_data + size, 0, 512 - size);
761
}
762

    
763
void bdrv_set_geometry_hint(BlockDriverState *bs,
764
                            int cyls, int heads, int secs)
765
{
766
    bs->cyls = cyls;
767
    bs->heads = heads;
768
    bs->secs = secs;
769
}
770

    
771
void bdrv_set_type_hint(BlockDriverState *bs, int type)
772
{
773
    bs->type = type;
774
    bs->removable = ((type == BDRV_TYPE_CDROM ||
775
                      type == BDRV_TYPE_FLOPPY));
776
}
777

    
778
void bdrv_set_translation_hint(BlockDriverState *bs, int translation)
779
{
780
    bs->translation = translation;
781
}
782

    
783
void bdrv_get_geometry_hint(BlockDriverState *bs,
784
                            int *pcyls, int *pheads, int *psecs)
785
{
786
    *pcyls = bs->cyls;
787
    *pheads = bs->heads;
788
    *psecs = bs->secs;
789
}
790

    
791
int bdrv_get_type_hint(BlockDriverState *bs)
792
{
793
    return bs->type;
794
}
795

    
796
int bdrv_get_translation_hint(BlockDriverState *bs)
797
{
798
    return bs->translation;
799
}
800

    
801
int bdrv_is_removable(BlockDriverState *bs)
802
{
803
    return bs->removable;
804
}
805

    
806
int bdrv_is_read_only(BlockDriverState *bs)
807
{
808
    return bs->read_only;
809
}
810

    
811
int bdrv_is_sg(BlockDriverState *bs)
812
{
813
    return bs->sg;
814
}
815

    
816
/* XXX: no longer used */
817
void bdrv_set_change_cb(BlockDriverState *bs,
818
                        void (*change_cb)(void *opaque), void *opaque)
819
{
820
    bs->change_cb = change_cb;
821
    bs->change_opaque = opaque;
822
}
823

    
824
int bdrv_is_encrypted(BlockDriverState *bs)
825
{
826
    if (bs->backing_hd && bs->backing_hd->encrypted)
827
        return 1;
828
    return bs->encrypted;
829
}
830

    
831
int bdrv_set_key(BlockDriverState *bs, const char *key)
832
{
833
    int ret;
834
    if (bs->backing_hd && bs->backing_hd->encrypted) {
835
        ret = bdrv_set_key(bs->backing_hd, key);
836
        if (ret < 0)
837
            return ret;
838
        if (!bs->encrypted)
839
            return 0;
840
    }
841
    if (!bs->encrypted || !bs->drv || !bs->drv->bdrv_set_key)
842
        return -1;
843
    return bs->drv->bdrv_set_key(bs, key);
844
}
845

    
846
void bdrv_get_format(BlockDriverState *bs, char *buf, int buf_size)
847
{
848
    if (!bs->drv) {
849
        buf[0] = '\0';
850
    } else {
851
        pstrcpy(buf, buf_size, bs->drv->format_name);
852
    }
853
}
854

    
855
void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
856
                         void *opaque)
857
{
858
    BlockDriver *drv;
859

    
860
    for (drv = first_drv; drv != NULL; drv = drv->next) {
861
        it(opaque, drv->format_name);
862
    }
863
}
864

    
865
BlockDriverState *bdrv_find(const char *name)
866
{
867
    BlockDriverState *bs;
868

    
869
    for (bs = bdrv_first; bs != NULL; bs = bs->next) {
870
        if (!strcmp(name, bs->device_name))
871
            return bs;
872
    }
873
    return NULL;
874
}
875

    
876
void bdrv_iterate(void (*it)(void *opaque, const char *name), void *opaque)
877
{
878
    BlockDriverState *bs;
879

    
880
    for (bs = bdrv_first; bs != NULL; bs = bs->next) {
881
        it(opaque, bs->device_name);
882
    }
883
}
884

    
885
const char *bdrv_get_device_name(BlockDriverState *bs)
886
{
887
    return bs->device_name;
888
}
889

    
890
void bdrv_flush(BlockDriverState *bs)
891
{
892
    if (bs->drv->bdrv_flush)
893
        bs->drv->bdrv_flush(bs);
894
    if (bs->backing_hd)
895
        bdrv_flush(bs->backing_hd);
896
}
897

    
898
/*
899
 * Returns true iff the specified sector is present in the disk image. Drivers
900
 * not implementing the functionality are assumed to not support backing files,
901
 * hence all their sectors are reported as allocated.
902
 *
903
 * 'pnum' is set to the number of sectors (including and immediately following
904
 * the specified sector) that are known to be in the same
905
 * allocated/unallocated state.
906
 *
907
 * 'nb_sectors' is the max value 'pnum' should be set to.
908
 */
909
int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
910
        int *pnum)
911
{
912
    int64_t n;
913
    if (!bs->drv->bdrv_is_allocated) {
914
        if (sector_num >= bs->total_sectors) {
915
            *pnum = 0;
916
            return 0;
917
        }
918
        n = bs->total_sectors - sector_num;
919
        *pnum = (n < nb_sectors) ? (n) : (nb_sectors);
920
        return 1;
921
    }
922
    return bs->drv->bdrv_is_allocated(bs, sector_num, nb_sectors, pnum);
923
}
924

    
925
void bdrv_info(void)
926
{
927
    BlockDriverState *bs;
928

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

    
965
/* The "info blockstats" command. */
966
void bdrv_info_stats (void)
967
{
968
    BlockDriverState *bs;
969

    
970
    for (bs = bdrv_first; bs != NULL; bs = bs->next) {
971
        term_printf ("%s:"
972
                     " rd_bytes=%" PRIu64
973
                     " wr_bytes=%" PRIu64
974
                     " rd_operations=%" PRIu64
975
                     " wr_operations=%" PRIu64
976
                     "\n",
977
                     bs->device_name,
978
                     bs->rd_bytes, bs->wr_bytes,
979
                     bs->rd_ops, bs->wr_ops);
980
    }
981
}
982

    
983
void bdrv_get_backing_filename(BlockDriverState *bs,
984
                               char *filename, int filename_size)
985
{
986
    if (!bs->backing_hd) {
987
        pstrcpy(filename, filename_size, "");
988
    } else {
989
        pstrcpy(filename, filename_size, bs->backing_file);
990
    }
991
}
992

    
993
int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
994
                          const uint8_t *buf, int nb_sectors)
995
{
996
    BlockDriver *drv = bs->drv;
997
    if (!drv)
998
        return -ENOMEDIUM;
999
    if (!drv->bdrv_write_compressed)
1000
        return -ENOTSUP;
1001
    return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);
1002
}
1003

    
1004
int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
1005
{
1006
    BlockDriver *drv = bs->drv;
1007
    if (!drv)
1008
        return -ENOMEDIUM;
1009
    if (!drv->bdrv_get_info)
1010
        return -ENOTSUP;
1011
    memset(bdi, 0, sizeof(*bdi));
1012
    return drv->bdrv_get_info(bs, bdi);
1013
}
1014

    
1015
/**************************************************************/
1016
/* handling of snapshots */
1017

    
1018
int bdrv_snapshot_create(BlockDriverState *bs,
1019
                         QEMUSnapshotInfo *sn_info)
1020
{
1021
    BlockDriver *drv = bs->drv;
1022
    if (!drv)
1023
        return -ENOMEDIUM;
1024
    if (!drv->bdrv_snapshot_create)
1025
        return -ENOTSUP;
1026
    return drv->bdrv_snapshot_create(bs, sn_info);
1027
}
1028

    
1029
int bdrv_snapshot_goto(BlockDriverState *bs,
1030
                       const char *snapshot_id)
1031
{
1032
    BlockDriver *drv = bs->drv;
1033
    if (!drv)
1034
        return -ENOMEDIUM;
1035
    if (!drv->bdrv_snapshot_goto)
1036
        return -ENOTSUP;
1037
    return drv->bdrv_snapshot_goto(bs, snapshot_id);
1038
}
1039

    
1040
int bdrv_snapshot_delete(BlockDriverState *bs, const char *snapshot_id)
1041
{
1042
    BlockDriver *drv = bs->drv;
1043
    if (!drv)
1044
        return -ENOMEDIUM;
1045
    if (!drv->bdrv_snapshot_delete)
1046
        return -ENOTSUP;
1047
    return drv->bdrv_snapshot_delete(bs, snapshot_id);
1048
}
1049

    
1050
int bdrv_snapshot_list(BlockDriverState *bs,
1051
                       QEMUSnapshotInfo **psn_info)
1052
{
1053
    BlockDriver *drv = bs->drv;
1054
    if (!drv)
1055
        return -ENOMEDIUM;
1056
    if (!drv->bdrv_snapshot_list)
1057
        return -ENOTSUP;
1058
    return drv->bdrv_snapshot_list(bs, psn_info);
1059
}
1060

    
1061
#define NB_SUFFIXES 4
1062

    
1063
char *get_human_readable_size(char *buf, int buf_size, int64_t size)
1064
{
1065
    static const char suffixes[NB_SUFFIXES] = "KMGT";
1066
    int64_t base;
1067
    int i;
1068

    
1069
    if (size <= 999) {
1070
        snprintf(buf, buf_size, "%" PRId64, size);
1071
    } else {
1072
        base = 1024;
1073
        for(i = 0; i < NB_SUFFIXES; i++) {
1074
            if (size < (10 * base)) {
1075
                snprintf(buf, buf_size, "%0.1f%c",
1076
                         (double)size / base,
1077
                         suffixes[i]);
1078
                break;
1079
            } else if (size < (1000 * base) || i == (NB_SUFFIXES - 1)) {
1080
                snprintf(buf, buf_size, "%" PRId64 "%c",
1081
                         ((size + (base >> 1)) / base),
1082
                         suffixes[i]);
1083
                break;
1084
            }
1085
            base = base * 1024;
1086
        }
1087
    }
1088
    return buf;
1089
}
1090

    
1091
char *bdrv_snapshot_dump(char *buf, int buf_size, QEMUSnapshotInfo *sn)
1092
{
1093
    char buf1[128], date_buf[128], clock_buf[128];
1094
#ifdef _WIN32
1095
    struct tm *ptm;
1096
#else
1097
    struct tm tm;
1098
#endif
1099
    time_t ti;
1100
    int64_t secs;
1101

    
1102
    if (!sn) {
1103
        snprintf(buf, buf_size,
1104
                 "%-10s%-20s%7s%20s%15s",
1105
                 "ID", "TAG", "VM SIZE", "DATE", "VM CLOCK");
1106
    } else {
1107
        ti = sn->date_sec;
1108
#ifdef _WIN32
1109
        ptm = localtime(&ti);
1110
        strftime(date_buf, sizeof(date_buf),
1111
                 "%Y-%m-%d %H:%M:%S", ptm);
1112
#else
1113
        localtime_r(&ti, &tm);
1114
        strftime(date_buf, sizeof(date_buf),
1115
                 "%Y-%m-%d %H:%M:%S", &tm);
1116
#endif
1117
        secs = sn->vm_clock_nsec / 1000000000;
1118
        snprintf(clock_buf, sizeof(clock_buf),
1119
                 "%02d:%02d:%02d.%03d",
1120
                 (int)(secs / 3600),
1121
                 (int)((secs / 60) % 60),
1122
                 (int)(secs % 60),
1123
                 (int)((sn->vm_clock_nsec / 1000000) % 1000));
1124
        snprintf(buf, buf_size,
1125
                 "%-10s%-20s%7s%20s%15s",
1126
                 sn->id_str, sn->name,
1127
                 get_human_readable_size(buf1, sizeof(buf1), sn->vm_state_size),
1128
                 date_buf,
1129
                 clock_buf);
1130
    }
1131
    return buf;
1132
}
1133

    
1134

    
1135
/**************************************************************/
1136
/* async I/Os */
1137

    
1138
BlockDriverAIOCB *bdrv_aio_read(BlockDriverState *bs, int64_t sector_num,
1139
                                uint8_t *buf, int nb_sectors,
1140
                                BlockDriverCompletionFunc *cb, void *opaque)
1141
{
1142
    BlockDriver *drv = bs->drv;
1143
    BlockDriverAIOCB *ret;
1144

    
1145
    if (!drv)
1146
        return NULL;
1147

    
1148
    /* XXX: we assume that nb_sectors == 0 is suppored by the async read */
1149
    if (sector_num == 0 && bs->boot_sector_enabled && nb_sectors > 0) {
1150
        memcpy(buf, bs->boot_sector_data, 512);
1151
        sector_num++;
1152
        nb_sectors--;
1153
        buf += 512;
1154
    }
1155

    
1156
    ret = drv->bdrv_aio_read(bs, sector_num, buf, nb_sectors, cb, opaque);
1157

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

    
1164
    return ret;
1165
}
1166

    
1167
BlockDriverAIOCB *bdrv_aio_write(BlockDriverState *bs, int64_t sector_num,
1168
                                 const uint8_t *buf, int nb_sectors,
1169
                                 BlockDriverCompletionFunc *cb, void *opaque)
1170
{
1171
    BlockDriver *drv = bs->drv;
1172
    BlockDriverAIOCB *ret;
1173

    
1174
    if (!drv)
1175
        return NULL;
1176
    if (bs->read_only)
1177
        return NULL;
1178
    if (sector_num == 0 && bs->boot_sector_enabled && nb_sectors > 0) {
1179
        memcpy(bs->boot_sector_data, buf, 512);
1180
    }
1181

    
1182
    ret = drv->bdrv_aio_write(bs, sector_num, buf, nb_sectors, cb, opaque);
1183

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

    
1190
    return ret;
1191
}
1192

    
1193
void bdrv_aio_cancel(BlockDriverAIOCB *acb)
1194
{
1195
    BlockDriver *drv = acb->bs->drv;
1196

    
1197
    drv->bdrv_aio_cancel(acb);
1198
}
1199

    
1200

    
1201
/**************************************************************/
1202
/* async block device emulation */
1203

    
1204
static void bdrv_aio_bh_cb(void *opaque)
1205
{
1206
    BlockDriverAIOCBSync *acb = opaque;
1207
    acb->common.cb(acb->common.opaque, acb->ret);
1208
    qemu_aio_release(acb);
1209
}
1210

    
1211
static BlockDriverAIOCB *bdrv_aio_read_em(BlockDriverState *bs,
1212
        int64_t sector_num, uint8_t *buf, int nb_sectors,
1213
        BlockDriverCompletionFunc *cb, void *opaque)
1214
{
1215
    BlockDriverAIOCBSync *acb;
1216
    int ret;
1217

    
1218
    acb = qemu_aio_get(bs, cb, opaque);
1219
    if (!acb->bh)
1220
        acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
1221
    ret = bdrv_read(bs, sector_num, buf, nb_sectors);
1222
    acb->ret = ret;
1223
    qemu_bh_schedule(acb->bh);
1224
    return &acb->common;
1225
}
1226

    
1227
static BlockDriverAIOCB *bdrv_aio_write_em(BlockDriverState *bs,
1228
        int64_t sector_num, const uint8_t *buf, int nb_sectors,
1229
        BlockDriverCompletionFunc *cb, void *opaque)
1230
{
1231
    BlockDriverAIOCBSync *acb;
1232
    int ret;
1233

    
1234
    acb = qemu_aio_get(bs, cb, opaque);
1235
    if (!acb->bh)
1236
        acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
1237
    ret = bdrv_write(bs, sector_num, buf, nb_sectors);
1238
    acb->ret = ret;
1239
    qemu_bh_schedule(acb->bh);
1240
    return &acb->common;
1241
}
1242

    
1243
static void bdrv_aio_cancel_em(BlockDriverAIOCB *blockacb)
1244
{
1245
    BlockDriverAIOCBSync *acb = (BlockDriverAIOCBSync *)blockacb;
1246
    qemu_bh_cancel(acb->bh);
1247
    qemu_aio_release(acb);
1248
}
1249

    
1250
/**************************************************************/
1251
/* sync block device emulation */
1252

    
1253
static void bdrv_rw_em_cb(void *opaque, int ret)
1254
{
1255
    *(int *)opaque = ret;
1256
}
1257

    
1258
#define NOT_DONE 0x7fffffff
1259

    
1260
static int bdrv_read_em(BlockDriverState *bs, int64_t sector_num,
1261
                        uint8_t *buf, int nb_sectors)
1262
{
1263
    int async_ret;
1264
    BlockDriverAIOCB *acb;
1265

    
1266
    async_ret = NOT_DONE;
1267
    acb = bdrv_aio_read(bs, sector_num, buf, nb_sectors,
1268
                        bdrv_rw_em_cb, &async_ret);
1269
    if (acb == NULL)
1270
        return -1;
1271

    
1272
    while (async_ret == NOT_DONE) {
1273
        qemu_aio_wait();
1274
    }
1275

    
1276
    return async_ret;
1277
}
1278

    
1279
static int bdrv_write_em(BlockDriverState *bs, int64_t sector_num,
1280
                         const uint8_t *buf, int nb_sectors)
1281
{
1282
    int async_ret;
1283
    BlockDriverAIOCB *acb;
1284

    
1285
    async_ret = NOT_DONE;
1286
    acb = bdrv_aio_write(bs, sector_num, buf, nb_sectors,
1287
                         bdrv_rw_em_cb, &async_ret);
1288
    if (acb == NULL)
1289
        return -1;
1290
    while (async_ret == NOT_DONE) {
1291
        qemu_aio_wait();
1292
    }
1293
    return async_ret;
1294
}
1295

    
1296
void bdrv_init(void)
1297
{
1298
    bdrv_register(&bdrv_raw);
1299
    bdrv_register(&bdrv_host_device);
1300
#ifndef _WIN32
1301
    bdrv_register(&bdrv_cow);
1302
#endif
1303
    bdrv_register(&bdrv_qcow);
1304
    bdrv_register(&bdrv_vmdk);
1305
    bdrv_register(&bdrv_cloop);
1306
    bdrv_register(&bdrv_dmg);
1307
    bdrv_register(&bdrv_bochs);
1308
    bdrv_register(&bdrv_vpc);
1309
    bdrv_register(&bdrv_vvfat);
1310
    bdrv_register(&bdrv_qcow2);
1311
    bdrv_register(&bdrv_parallels);
1312
    bdrv_register(&bdrv_nbd);
1313
}
1314

    
1315
void *qemu_aio_get(BlockDriverState *bs, BlockDriverCompletionFunc *cb,
1316
                   void *opaque)
1317
{
1318
    BlockDriver *drv;
1319
    BlockDriverAIOCB *acb;
1320

    
1321
    drv = bs->drv;
1322
    if (drv->free_aiocb) {
1323
        acb = drv->free_aiocb;
1324
        drv->free_aiocb = acb->next;
1325
    } else {
1326
        acb = qemu_mallocz(drv->aiocb_size);
1327
        if (!acb)
1328
            return NULL;
1329
    }
1330
    acb->bs = bs;
1331
    acb->cb = cb;
1332
    acb->opaque = opaque;
1333
    return acb;
1334
}
1335

    
1336
void qemu_aio_release(void *p)
1337
{
1338
    BlockDriverAIOCB *acb = p;
1339
    BlockDriver *drv = acb->bs->drv;
1340
    acb->next = drv->free_aiocb;
1341
    drv->free_aiocb = acb;
1342
}
1343

    
1344
/**************************************************************/
1345
/* removable device support */
1346

    
1347
/**
1348
 * Return TRUE if the media is present
1349
 */
1350
int bdrv_is_inserted(BlockDriverState *bs)
1351
{
1352
    BlockDriver *drv = bs->drv;
1353
    int ret;
1354
    if (!drv)
1355
        return 0;
1356
    if (!drv->bdrv_is_inserted)
1357
        return 1;
1358
    ret = drv->bdrv_is_inserted(bs);
1359
    return ret;
1360
}
1361

    
1362
/**
1363
 * Return TRUE if the media changed since the last call to this
1364
 * function. It is currently only used for floppy disks
1365
 */
1366
int bdrv_media_changed(BlockDriverState *bs)
1367
{
1368
    BlockDriver *drv = bs->drv;
1369
    int ret;
1370

    
1371
    if (!drv || !drv->bdrv_media_changed)
1372
        ret = -ENOTSUP;
1373
    else
1374
        ret = drv->bdrv_media_changed(bs);
1375
    if (ret == -ENOTSUP)
1376
        ret = bs->media_changed;
1377
    bs->media_changed = 0;
1378
    return ret;
1379
}
1380

    
1381
/**
1382
 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
1383
 */
1384
void bdrv_eject(BlockDriverState *bs, int eject_flag)
1385
{
1386
    BlockDriver *drv = bs->drv;
1387
    int ret;
1388

    
1389
    if (!drv || !drv->bdrv_eject) {
1390
        ret = -ENOTSUP;
1391
    } else {
1392
        ret = drv->bdrv_eject(bs, eject_flag);
1393
    }
1394
    if (ret == -ENOTSUP) {
1395
        if (eject_flag)
1396
            bdrv_close(bs);
1397
    }
1398
}
1399

    
1400
int bdrv_is_locked(BlockDriverState *bs)
1401
{
1402
    return bs->locked;
1403
}
1404

    
1405
/**
1406
 * Lock or unlock the media (if it is locked, the user won't be able
1407
 * to eject it manually).
1408
 */
1409
void bdrv_set_locked(BlockDriverState *bs, int locked)
1410
{
1411
    BlockDriver *drv = bs->drv;
1412

    
1413
    bs->locked = locked;
1414
    if (drv && drv->bdrv_set_locked) {
1415
        drv->bdrv_set_locked(bs, locked);
1416
    }
1417
}
1418

    
1419
/* needed for generic scsi interface */
1420

    
1421
int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
1422
{
1423
    BlockDriver *drv = bs->drv;
1424

    
1425
    if (drv && drv->bdrv_ioctl)
1426
        return drv->bdrv_ioctl(bs, req, buf);
1427
    return -ENOTSUP;
1428
}