Blame view

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

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

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

#ifdef _WIN32
bellard authored
232
233
    if (is_windows_drive(filename) ||
        is_windows_drive_prefix(filename))
234
        return bdrv_find_format("raw");
235
#endif
236
237
    p = strchr(filename, ':');
    if (!p)
238
        return bdrv_find_format("raw");
239
240
241
242
243
    len = p - filename;
    if (len > sizeof(protocol) - 1)
        len = sizeof(protocol) - 1;
    memcpy(protocol, filename, len);
    protocol[len] = '\0';
bellard authored
244
    for(drv1 = first_drv; drv1 != NULL; drv1 = drv1->next) {
245
        if (drv1->protocol_name &&
bellard authored
246
247
248
249
250
251
            !strcmp(drv1->protocol_name, protocol))
            return drv1;
    }
    return NULL;
}
252
253
254
255
256
257
/*
 * Detect host devices. By convention, /dev/cdrom[N] is always
 * recognized as a host CDROM.
 */
static BlockDriver *find_hdev_driver(const char *filename)
{
258
259
    int score_max = 0, score;
    BlockDriver *drv = NULL, *d;
260
261
262
263
264
265
266
267
268
    for (d = first_drv; d; d = d->next) {
        if (d->bdrv_probe_device) {
            score = d->bdrv_probe_device(filename);
            if (score > score_max) {
                score_max = score;
                drv = d;
            }
        }
269
    }
270
271
    return drv;
272
}
273
274
275
276
277
278
279
280
static BlockDriver *find_image_format(const char *filename)
{
    int ret, score, score_max;
    BlockDriver *drv1, *drv;
    uint8_t buf[2048];
    BlockDriverState *bs;
bellard authored
281
    drv = find_protocol(filename);
282
    /* no need to test disk image formats for vvfat */
283
    if (drv && strcmp(drv->format_name, "vvfat") == 0)
bellard authored
284
        return drv;
285
bellard authored
286
287
288
289
290
291
292
293
294
    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
295
296
    score_max = 0;
    for(drv1 = first_drv; drv1 != NULL; drv1 = drv1->next) {
bellard authored
297
298
299
300
301
302
        if (drv1->bdrv_probe) {
            score = drv1->bdrv_probe(buf, ret, filename);
            if (score > score_max) {
                score_max = score;
                drv = drv1;
            }
bellard authored
303
        }
bellard authored
304
    }
bellard authored
305
306
307
    return drv;
}
bellard authored
308
int bdrv_file_open(BlockDriverState **pbs, const char *filename, int flags)
bellard authored
309
{
bellard authored
310
311
312
313
314
315
316
317
    BlockDriverState *bs;
    int ret;

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

int bdrv_open(BlockDriverState *bs, const char *filename, int flags)
{
    return bdrv_open2(bs, filename, flags, NULL);
bellard authored
327
328
}
bellard authored
329
int bdrv_open2(BlockDriverState *bs, const char *filename, int flags,
bellard authored
330
331
               BlockDriver *drv)
{
bellard authored
332
    int ret, open_flags;
333
334
    char tmp_filename[PATH_MAX];
    char backing_filename[PATH_MAX];
335
bellard authored
336
337
338
    bs->read_only = 0;
    bs->is_temporary = 0;
    bs->encrypted = 0;
339
    bs->valid_key = 0;
340
341
    /* buffer_alignment defaulted to 512, drivers can change this value */
    bs->buffer_alignment = 512;
bellard authored
342
bellard authored
343
    if (flags & BDRV_O_SNAPSHOT) {
bellard authored
344
345
        BlockDriverState *bs1;
        int64_t total_size;
346
        int is_protocol = 0;
Kevin Wolf authored
347
348
        BlockDriver *bdrv_qcow2;
        QEMUOptionParameter *options;
349
bellard authored
350
351
        /* if snapshot, we create a temporary backing file and open it
           instead of opening 'filename' directly */
352
bellard authored
353
354
        /* if there is a backing file, use it */
        bs1 = bdrv_new("");
355
        ret = bdrv_open2(bs1, filename, 0, drv);
356
        if (ret < 0) {
bellard authored
357
            bdrv_delete(bs1);
358
            return ret;
bellard authored
359
        }
bellard authored
360
        total_size = bdrv_getlength(bs1) >> SECTOR_BITS;
361
362
363
364

        if (bs1->drv && bs1->drv->protocol_name)
            is_protocol = 1;
bellard authored
365
        bdrv_delete(bs1);
366
bellard authored
367
        get_tmp_filename(tmp_filename, sizeof(tmp_filename));
368
369
370
371
372
373
374
375

        /* Real path is meaningless for protocols */
        if (is_protocol)
            snprintf(backing_filename, sizeof(backing_filename),
                     "%s", filename);
        else
            realpath(filename, backing_filename);
Kevin Wolf authored
376
377
378
379
380
381
382
383
384
385
386
        bdrv_qcow2 = bdrv_find_format("qcow2");
        options = parse_option_parameters("", bdrv_qcow2->create_options, NULL);

        set_option_parameter_int(options, BLOCK_OPT_SIZE, total_size * 512);
        set_option_parameter(options, BLOCK_OPT_BACKING_FILE, backing_filename);
        if (drv) {
            set_option_parameter(options, BLOCK_OPT_BACKING_FMT,
                drv->format_name);
        }

        ret = bdrv_create(bdrv_qcow2, tmp_filename, options);
387
388
        if (ret < 0) {
            return ret;
bellard authored
389
        }
Kevin Wolf authored
390
bellard authored
391
        filename = tmp_filename;
Kevin Wolf authored
392
        drv = bdrv_qcow2;
bellard authored
393
394
        bs->is_temporary = 1;
    }
bellard authored
395
bellard authored
396
    pstrcpy(bs->filename, sizeof(bs->filename), filename);
bellard authored
397
398
    if (flags & BDRV_O_FILE) {
        drv = find_protocol(filename);
399
    } else if (!drv) {
400
401
402
403
        drv = find_hdev_driver(filename);
        if (!drv) {
            drv = find_image_format(filename);
        }
404
405
406
407
    }
    if (!drv) {
        ret = -ENOENT;
        goto unlink_and_fail;
bellard authored
408
409
410
    }
    bs->drv = drv;
    bs->opaque = qemu_mallocz(drv->instance_size);
bellard authored
411
412
413
    /* Note: for compatibility, we open disk image files as RDWR, and
       RDONLY as fallback */
    if (!(flags & BDRV_O_FILE))
414
        open_flags = BDRV_O_RDWR | (flags & BDRV_O_CACHE_MASK);
bellard authored
415
416
    else
        open_flags = flags & ~(BDRV_O_FILE | BDRV_O_SNAPSHOT);
417
    ret = drv->bdrv_open(bs, filename, open_flags);
418
    if ((ret == -EACCES || ret == -EPERM) && !(flags & BDRV_O_FILE)) {
419
        ret = drv->bdrv_open(bs, filename, open_flags & ~BDRV_O_RDWR);
bellard authored
420
421
        bs->read_only = 1;
    }
bellard authored
422
423
    if (ret < 0) {
        qemu_free(bs->opaque);
bellard authored
424
425
        bs->opaque = NULL;
        bs->drv = NULL;
426
427
428
    unlink_and_fail:
        if (bs->is_temporary)
            unlink(filename);
bellard authored
429
        return ret;
430
    }
431
432
433
    if (drv->bdrv_getlength) {
        bs->total_sectors = bdrv_getlength(bs) >> SECTOR_BITS;
    }
434
#ifndef _WIN32
bellard authored
435
436
437
438
    if (bs->is_temporary) {
        unlink(filename);
    }
#endif
bellard authored
439
    if (bs->backing_file[0] != '\0') {
bellard authored
440
        /* if there is a backing file, use it */
441
        BlockDriver *back_drv = NULL;
bellard authored
442
        bs->backing_hd = bdrv_new("");
bellard authored
443
444
        path_combine(backing_filename, sizeof(backing_filename),
                     filename, bs->backing_file);
445
446
447
448
        if (bs->backing_format[0] != '\0')
            back_drv = bdrv_find_format(bs->backing_format);
        ret = bdrv_open2(bs->backing_hd, backing_filename, open_flags,
                         back_drv);
449
450
451
452
        if (ret < 0) {
            bdrv_close(bs);
            return ret;
        }
453
454
    }
455
456
457
458
459
460
    if (!bdrv_key_required(bs)) {
        /* call the change callback */
        bs->media_changed = 1;
        if (bs->change_cb)
            bs->change_cb(bs->change_opaque);
    }
bellard authored
461
    return 0;
bellard authored
462
463
464
465
}

void bdrv_close(BlockDriverState *bs)
{
466
    if (bs->drv) {
bellard authored
467
468
469
470
471
472
473
474
        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);
        }
475
#endif
bellard authored
476
477
        bs->opaque = NULL;
        bs->drv = NULL;
bellard authored
478
479

        /* call the change callback */
480
        bs->media_changed = 1;
bellard authored
481
482
483
484
485
486
487
        if (bs->change_cb)
            bs->change_cb(bs->change_opaque);
    }
}

void bdrv_delete(BlockDriverState *bs)
{
488
489
490
491
492
493
494
495
    BlockDriverState **pbs;

    pbs = &bdrv_first;
    while (*pbs != bs && *pbs != NULL)
        pbs = &(*pbs)->next;
    if (*pbs == bs)
        *pbs = bs->next;
bellard authored
496
497
    bdrv_close(bs);
    qemu_free(bs);
bellard authored
498
499
}
500
501
502
503
504
505
506
507
508
509
510
511
512
513
/*
 * Run consistency checks on an image
 *
 * Returns the number of errors or -errno when an internal error occurs
 */
int bdrv_check(BlockDriverState *bs)
{
    if (bs->drv->bdrv_check == NULL) {
        return -ENOTSUP;
    }

    return bs->drv->bdrv_check(bs);
}
514
515
516
/* commit COW file into the raw image */
int bdrv_commit(BlockDriverState *bs)
{
517
    BlockDriver *drv = bs->drv;
bellard authored
518
    int64_t i, total_sectors;
bellard authored
519
520
    int n, j;
    unsigned char sector[512];
521
522
523
    if (!drv)
        return -ENOMEDIUM;
524
525

    if (bs->read_only) {
bellard authored
526
	return -EACCES;
527
528
    }
bellard authored
529
530
531
    if (!bs->backing_hd) {
	return -ENOTSUP;
    }
532
bellard authored
533
534
    total_sectors = bdrv_getlength(bs) >> SECTOR_BITS;
    for (i = 0; i < total_sectors;) {
535
        if (drv->bdrv_is_allocated(bs, i, 65536, &n)) {
bellard authored
536
537
538
539
540
541
542
543
544
            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++;
545
	    }
bellard authored
546
547
548
	} else {
            i += n;
        }
549
    }
550
551
552
    if (drv->bdrv_make_empty)
	return drv->bdrv_make_empty(bs);
553
554
555
556
    return 0;
}
557
558
559
560
561
562
563
564
565
566
567
568
569
static int bdrv_check_byte_request(BlockDriverState *bs, int64_t offset,
                                   size_t size)
{
    int64_t len;

    if (!bdrv_is_inserted(bs))
        return -ENOMEDIUM;

    if (bs->growable)
        return 0;

    len = bdrv_getlength(bs);
570
571
572
573
    if (offset < 0)
        return -EIO;

    if ((offset > len) || (len - offset < size))
574
575
576
577
578
579
580
581
        return -EIO;

    return 0;
}

static int bdrv_check_request(BlockDriverState *bs, int64_t sector_num,
                              int nb_sectors)
{
582
    return bdrv_check_byte_request(bs, sector_num * 512, nb_sectors * 512);
583
584
}
585
/* return < 0 if error. See bdrv_write() for the return codes */
586
int bdrv_read(BlockDriverState *bs, int64_t sector_num,
bellard authored
587
588
              uint8_t *buf, int nb_sectors)
{
bellard authored
589
590
    BlockDriver *drv = bs->drv;
591
592
    if (!drv)
        return -ENOMEDIUM;
593
594
    if (bdrv_check_request(bs, sector_num, nb_sectors))
        return -EIO;
bellard authored
595
596
    return drv->bdrv_read(bs, sector_num, buf, nb_sectors);
bellard authored
597
598
}
599
/* Return < 0 if error. Important errors are:
600
601
602
603
604
  -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
*/
605
int bdrv_write(BlockDriverState *bs, int64_t sector_num,
bellard authored
606
607
               const uint8_t *buf, int nb_sectors)
{
bellard authored
608
    BlockDriver *drv = bs->drv;
609
610
    if (!bs->drv)
        return -ENOMEDIUM;
bellard authored
611
    if (bs->read_only)
612
        return -EACCES;
613
614
615
    if (bdrv_check_request(bs, sector_num, nb_sectors))
        return -EIO;
616
    return drv->bdrv_write(bs, sector_num, buf, nb_sectors);
bellard authored
617
618
}
619
620
int bdrv_pread(BlockDriverState *bs, int64_t offset,
               void *buf, int count1)
bellard authored
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
661
662
{
    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;
}
663
664
int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
                const void *buf, int count1)
bellard authored
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
{
    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;
}

/**
 * Truncate file to 'offset' bytes (needed only for file protocols)
 */
int bdrv_truncate(BlockDriverState *bs, int64_t offset)
{
    BlockDriver *drv = bs->drv;
    if (!drv)
718
        return -ENOMEDIUM;
bellard authored
719
720
721
722
723
724
725
726
727
728
729
730
    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)
731
        return -ENOMEDIUM;
bellard authored
732
733
734
735
736
    if (!drv->bdrv_getlength) {
        /* legacy mode */
        return bs->total_sectors * SECTOR_SIZE;
    }
    return drv->bdrv_getlength(bs);
bellard authored
737
738
}
739
/* return 0 as number of sectors if no device present or error */
740
void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
bellard authored
741
{
742
743
744
745
746
747
748
    int64_t length;
    length = bdrv_getlength(bs);
    if (length < 0)
        length = 0;
    else
        length = length >> SECTOR_BITS;
    *nb_sectors_ptr = length;
bellard authored
749
}
bellard authored
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
struct partition {
        uint8_t boot_ind;           /* 0x80 - active */
        uint8_t head;               /* starting head */
        uint8_t sector;             /* starting sector */
        uint8_t cyl;                /* starting cylinder */
        uint8_t sys_ind;            /* What partition type */
        uint8_t end_head;           /* end head */
        uint8_t end_sector;         /* end sector */
        uint8_t end_cyl;            /* end cylinder */
        uint32_t start_sect;        /* starting sector counting from 0 */
        uint32_t nr_sects;          /* nr of sectors in partition */
} __attribute__((packed));

/* try to guess the disk logical geometry from the MSDOS partition table. Return 0 if OK, -1 if could not guess */
static int guess_disk_lchs(BlockDriverState *bs,
                           int *pcylinders, int *pheads, int *psectors)
{
    uint8_t buf[512];
    int ret, i, heads, sectors, cylinders;
    struct partition *p;
    uint32_t nr_sects;
772
    uint64_t nb_sectors;
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811

    bdrv_get_geometry(bs, &nb_sectors);

    ret = bdrv_read(bs, 0, buf, 1);
    if (ret < 0)
        return -1;
    /* test msdos magic */
    if (buf[510] != 0x55 || buf[511] != 0xaa)
        return -1;
    for(i = 0; i < 4; i++) {
        p = ((struct partition *)(buf + 0x1be)) + i;
        nr_sects = le32_to_cpu(p->nr_sects);
        if (nr_sects && p->end_head) {
            /* We make the assumption that the partition terminates on
               a cylinder boundary */
            heads = p->end_head + 1;
            sectors = p->end_sector & 63;
            if (sectors == 0)
                continue;
            cylinders = nb_sectors / (heads * sectors);
            if (cylinders < 1 || cylinders > 16383)
                continue;
            *pheads = heads;
            *psectors = sectors;
            *pcylinders = cylinders;
#if 0
            printf("guessed geometry: LCHS=%d %d %d\n",
                   cylinders, heads, sectors);
#endif
            return 0;
        }
    }
    return -1;
}

void bdrv_guess_geometry(BlockDriverState *bs, int *pcyls, int *pheads, int *psecs)
{
    int translation, lba_detected = 0;
    int cylinders, heads, secs;
812
    uint64_t nb_sectors;
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866

    /* if a geometry hint is available, use it */
    bdrv_get_geometry(bs, &nb_sectors);
    bdrv_get_geometry_hint(bs, &cylinders, &heads, &secs);
    translation = bdrv_get_translation_hint(bs);
    if (cylinders != 0) {
        *pcyls = cylinders;
        *pheads = heads;
        *psecs = secs;
    } else {
        if (guess_disk_lchs(bs, &cylinders, &heads, &secs) == 0) {
            if (heads > 16) {
                /* if heads > 16, it means that a BIOS LBA
                   translation was active, so the default
                   hardware geometry is OK */
                lba_detected = 1;
                goto default_geometry;
            } else {
                *pcyls = cylinders;
                *pheads = heads;
                *psecs = secs;
                /* disable any translation to be in sync with
                   the logical geometry */
                if (translation == BIOS_ATA_TRANSLATION_AUTO) {
                    bdrv_set_translation_hint(bs,
                                              BIOS_ATA_TRANSLATION_NONE);
                }
            }
        } else {
        default_geometry:
            /* if no geometry, use a standard physical disk geometry */
            cylinders = nb_sectors / (16 * 63);

            if (cylinders > 16383)
                cylinders = 16383;
            else if (cylinders < 2)
                cylinders = 2;
            *pcyls = cylinders;
            *pheads = 16;
            *psecs = 63;
            if ((lba_detected == 1) && (translation == BIOS_ATA_TRANSLATION_AUTO)) {
                if ((*pcyls * *pheads) <= 131072) {
                    bdrv_set_translation_hint(bs,
                                              BIOS_ATA_TRANSLATION_LARGE);
                } else {
                    bdrv_set_translation_hint(bs,
                                              BIOS_ATA_TRANSLATION_LBA);
                }
            }
        }
        bdrv_set_geometry_hint(bs, *pcyls, *pheads, *psecs);
    }
}
867
void bdrv_set_geometry_hint(BlockDriverState *bs,
bellard authored
868
869
870
871
872
873
874
875
876
877
878
879
880
881
                            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));
}
882
883
884
885
886
void bdrv_set_translation_hint(BlockDriverState *bs, int translation)
{
    bs->translation = translation;
}
887
void bdrv_get_geometry_hint(BlockDriverState *bs,
bellard authored
888
889
890
891
892
893
894
895
896
897
898
899
                            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;
}
900
901
902
903
904
int bdrv_get_translation_hint(BlockDriverState *bs)
{
    return bs->translation;
}
bellard authored
905
906
907
908
909
910
911
912
913
914
int bdrv_is_removable(BlockDriverState *bs)
{
    return bs->removable;
}

int bdrv_is_read_only(BlockDriverState *bs)
{
    return bs->read_only;
}
915
916
917
918
919
int bdrv_is_sg(BlockDriverState *bs)
{
    return bs->sg;
}
920
/* XXX: no longer used */
921
void bdrv_set_change_cb(BlockDriverState *bs,
bellard authored
922
923
924
925
926
927
                        void (*change_cb)(void *opaque), void *opaque)
{
    bs->change_cb = change_cb;
    bs->change_opaque = opaque;
}
bellard authored
928
929
930
931
932
933
934
int bdrv_is_encrypted(BlockDriverState *bs)
{
    if (bs->backing_hd && bs->backing_hd->encrypted)
        return 1;
    return bs->encrypted;
}
935
936
937
938
939
940
941
942
943
int bdrv_key_required(BlockDriverState *bs)
{
    BlockDriverState *backing_hd = bs->backing_hd;

    if (backing_hd && backing_hd->encrypted && !backing_hd->valid_key)
        return 1;
    return (bs->encrypted && !bs->valid_key);
}
bellard authored
944
945
946
947
948
949
950
951
952
953
954
955
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;
956
    ret = bs->drv->bdrv_set_key(bs, key);
957
958
959
960
961
962
963
964
965
    if (ret < 0) {
        bs->valid_key = 0;
    } else if (!bs->valid_key) {
        bs->valid_key = 1;
        /* call the change callback now, we skipped it on open */
        bs->media_changed = 1;
        if (bs->change_cb)
            bs->change_cb(bs->change_opaque);
    }
966
    return ret;
bellard authored
967
968
969
970
}

void bdrv_get_format(BlockDriverState *bs, char *buf, int buf_size)
{
971
    if (!bs->drv) {
bellard authored
972
973
974
975
976
977
        buf[0] = '\0';
    } else {
        pstrcpy(buf, buf_size, bs->drv->format_name);
    }
}
978
void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
bellard authored
979
980
981
982
983
984
985
986
987
                         void *opaque)
{
    BlockDriver *drv;

    for (drv = first_drv; drv != NULL; drv = drv->next) {
        it(opaque, drv->format_name);
    }
}
bellard authored
988
989
990
991
992
993
994
995
996
997
998
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;
}
999
void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs), void *opaque)
bellard authored
1000
1001
1002
1003
{
    BlockDriverState *bs;

    for (bs = bdrv_first; bs != NULL; bs = bs->next) {
1004
        it(opaque, bs);
bellard authored
1005
1006
1007
    }
}
bellard authored
1008
1009
1010
1011
1012
const char *bdrv_get_device_name(BlockDriverState *bs)
{
    return bs->device_name;
}
pbrook authored
1013
1014
void bdrv_flush(BlockDriverState *bs)
{
1015
1016
    if (!bs->drv)
        return;
pbrook authored
1017
1018
1019
1020
1021
1022
    if (bs->drv->bdrv_flush)
        bs->drv->bdrv_flush(bs);
    if (bs->backing_hd)
        bdrv_flush(bs->backing_hd);
}
aliguori authored
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
void bdrv_flush_all(void)
{
    BlockDriverState *bs;

    for (bs = bdrv_first; bs != NULL; bs = bs->next)
        if (bs->drv && !bdrv_is_read_only(bs) && 
            (!bdrv_is_removable(bs) || bdrv_is_inserted(bs)))
            bdrv_flush(bs);
}
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
/*
 * Returns true iff the specified sector is present in the disk image. Drivers
 * not implementing the functionality are assumed to not support backing files,
 * hence all their sectors are reported as allocated.
 *
 * 'pnum' is set to the number of sectors (including and immediately following
 * the specified sector) that are known to be in the same
 * allocated/unallocated state.
 *
 * 'nb_sectors' is the max value 'pnum' should be set to.
 */
int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
	int *pnum)
{
    int64_t n;
    if (!bs->drv->bdrv_is_allocated) {
        if (sector_num >= bs->total_sectors) {
            *pnum = 0;
            return 0;
        }
        n = bs->total_sectors - sector_num;
        *pnum = (n < nb_sectors) ? (n) : (nb_sectors);
        return 1;
    }
    return bs->drv->bdrv_is_allocated(bs, sector_num, nb_sectors, pnum);
}
1060
void bdrv_info(Monitor *mon)
bellard authored
1061
1062
1063
1064
{
    BlockDriverState *bs;

    for (bs = bdrv_first; bs != NULL; bs = bs->next) {
1065
1066
        monitor_printf(mon, "%s:", bs->device_name);
        monitor_printf(mon, " type=");
bellard authored
1067
1068
        switch(bs->type) {
        case BDRV_TYPE_HD:
1069
            monitor_printf(mon, "hd");
bellard authored
1070
1071
            break;
        case BDRV_TYPE_CDROM:
1072
            monitor_printf(mon, "cdrom");
bellard authored
1073
1074
            break;
        case BDRV_TYPE_FLOPPY:
1075
            monitor_printf(mon, "floppy");
bellard authored
1076
1077
            break;
        }
1078
        monitor_printf(mon, " removable=%d", bs->removable);
bellard authored
1079
        if (bs->removable) {
1080
            monitor_printf(mon, " locked=%d", bs->locked);
bellard authored
1081
        }
1082
        if (bs->drv) {
1083
1084
            monitor_printf(mon, " file=");
            monitor_print_filename(mon, bs->filename);
1085
            if (bs->backing_file[0] != '\0') {
1086
1087
1088
1089
1090
1091
                monitor_printf(mon, " backing_file=");
                monitor_print_filename(mon, bs->backing_file);
            }
            monitor_printf(mon, " ro=%d", bs->read_only);
            monitor_printf(mon, " drv=%s", bs->drv->format_name);
            monitor_printf(mon, " encrypted=%d", bdrv_is_encrypted(bs));
bellard authored
1092
        } else {
1093
            monitor_printf(mon, " [not inserted]");
bellard authored
1094
        }
1095
        monitor_printf(mon, "\n");
bellard authored
1096
1097
    }
}
1098
1099

/* The "info blockstats" command. */
1100
void bdrv_info_stats(Monitor *mon)
1101
1102
1103
1104
{
    BlockDriverState *bs;

    for (bs = bdrv_first; bs != NULL; bs = bs->next) {
1105
1106
1107
1108
1109
        monitor_printf(mon, "%s:"
                       " rd_bytes=%" PRIu64
                       " wr_bytes=%" PRIu64
                       " rd_operations=%" PRIu64
                       " wr_operations=%" PRIu64
aliguori authored
1110
                       "\n",
1111
1112
1113
                       bs->device_name,
                       bs->rd_bytes, bs->wr_bytes,
                       bs->rd_ops, bs->wr_ops);
1114
1115
    }
}
bellard authored
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
{
    if (bs->backing_hd && bs->backing_hd->encrypted)
        return bs->backing_file;
    else if (bs->encrypted)
        return bs->filename;
    else
        return NULL;
}
1127
void bdrv_get_backing_filename(BlockDriverState *bs,
bellard authored
1128
1129
1130
1131
1132
1133
1134
1135
1136
                               char *filename, int filename_size)
{
    if (!bs->backing_hd) {
        pstrcpy(filename, filename_size, "");
    } else {
        pstrcpy(filename, filename_size, bs->backing_file);
    }
}
1137
int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
bellard authored
1138
1139
1140
1141
                          const uint8_t *buf, int nb_sectors)
{
    BlockDriver *drv = bs->drv;
    if (!drv)
1142
        return -ENOMEDIUM;
bellard authored
1143
1144
    if (!drv->bdrv_write_compressed)
        return -ENOTSUP;
1145
1146
    if (bdrv_check_request(bs, sector_num, nb_sectors))
        return -EIO;
bellard authored
1147
1148
    return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);
}
1149
bellard authored
1150
1151
1152
1153
int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
{
    BlockDriver *drv = bs->drv;
    if (!drv)
1154
        return -ENOMEDIUM;
bellard authored
1155
1156
1157
1158
1159
1160
    if (!drv->bdrv_get_info)
        return -ENOTSUP;
    memset(bdi, 0, sizeof(*bdi));
    return drv->bdrv_get_info(bs, bdi);
}
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
int bdrv_put_buffer(BlockDriverState *bs, const uint8_t *buf, int64_t pos, int size)
{
    BlockDriver *drv = bs->drv;
    if (!drv)
        return -ENOMEDIUM;
    if (!drv->bdrv_put_buffer)
        return -ENOTSUP;
    return drv->bdrv_put_buffer(bs, buf, pos, size);
}

int bdrv_get_buffer(BlockDriverState *bs, uint8_t *buf, int64_t pos, int size)
{
    BlockDriver *drv = bs->drv;
    if (!drv)
        return -ENOMEDIUM;
    if (!drv->bdrv_get_buffer)
        return -ENOTSUP;
    return drv->bdrv_get_buffer(bs, buf, pos, size);
}
bellard authored
1181
1182
1183
/**************************************************************/
/* handling of snapshots */
1184
int bdrv_snapshot_create(BlockDriverState *bs,
bellard authored
1185
1186
1187
1188
                         QEMUSnapshotInfo *sn_info)
{
    BlockDriver *drv = bs->drv;
    if (!drv)
1189
        return -ENOMEDIUM;
bellard authored
1190
1191
1192
1193
1194
    if (!drv->bdrv_snapshot_create)
        return -ENOTSUP;
    return drv->bdrv_snapshot_create(bs, sn_info);
}
1195
int bdrv_snapshot_goto(BlockDriverState *bs,
bellard authored
1196
1197
1198
1199
                       const char *snapshot_id)
{
    BlockDriver *drv = bs->drv;
    if (!drv)
1200
        return -ENOMEDIUM;
bellard authored
1201
1202
1203
1204
1205
1206
1207
1208
1209
    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)
1210
        return -ENOMEDIUM;
bellard authored
1211
1212
1213
1214
1215
    if (!drv->bdrv_snapshot_delete)
        return -ENOTSUP;
    return drv->bdrv_snapshot_delete(bs, snapshot_id);
}
1216
int bdrv_snapshot_list(BlockDriverState *bs,
bellard authored
1217
1218
1219
1220
                       QEMUSnapshotInfo **psn_info)
{
    BlockDriver *drv = bs->drv;
    if (!drv)
1221
        return -ENOMEDIUM;
bellard authored
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
    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)) {
1241
                snprintf(buf, buf_size, "%0.1f%c",
bellard authored
1242
1243
1244
1245
                         (double)size / base,
                         suffixes[i]);
                break;
            } else if (size < (1000 * base) || i == (NB_SUFFIXES - 1)) {
1246
                snprintf(buf, buf_size, "%" PRId64 "%c",
bellard authored
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
                         ((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];
1260
1261
1262
#ifdef _WIN32
    struct tm *ptm;
#else
bellard authored
1263
    struct tm tm;
1264
#endif
bellard authored
1265
1266
1267
1268
    time_t ti;
    int64_t secs;

    if (!sn) {
1269
1270
        snprintf(buf, buf_size,
                 "%-10s%-20s%7s%20s%15s",
bellard authored
1271
1272
1273
                 "ID", "TAG", "VM SIZE", "DATE", "VM CLOCK");
    } else {
        ti = sn->date_sec;
1274
1275
1276
1277
1278
#ifdef _WIN32
        ptm = localtime(&ti);
        strftime(date_buf, sizeof(date_buf),
                 "%Y-%m-%d %H:%M:%S", ptm);
#else
bellard authored
1279
1280
1281
        localtime_r(&ti, &tm);
        strftime(date_buf, sizeof(date_buf),
                 "%Y-%m-%d %H:%M:%S", &tm);
1282
#endif
bellard authored
1283
1284
1285
1286
1287
        secs = sn->vm_clock_nsec / 1000000000;
        snprintf(clock_buf, sizeof(clock_buf),
                 "%02d:%02d:%02d.%03d",
                 (int)(secs / 3600),
                 (int)((secs / 60) % 60),
1288
                 (int)(secs % 60),
bellard authored
1289
1290
                 (int)((sn->vm_clock_nsec / 1000000) % 1000));
        snprintf(buf, buf_size,
1291
                 "%-10s%-20s%7s%20s%15s",
bellard authored
1292
1293
1294
1295
1296
1297
1298
1299
                 sn->id_str, sn->name,
                 get_human_readable_size(buf1, sizeof(buf1), sn->vm_state_size),
                 date_buf,
                 clock_buf);
    }
    return buf;
}
bellard authored
1300
bellard authored
1301
/**************************************************************/
bellard authored
1302
/* async I/Os */
bellard authored
1303
1304
BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
1305
                                 QEMUIOVector *qiov, int nb_sectors,
1306
1307
                                 BlockDriverCompletionFunc *cb, void *opaque)
{
bellard authored
1308
    BlockDriver *drv = bs->drv;
1309
    BlockDriverAIOCB *ret;
bellard authored
1310
1311
    if (!drv)
1312
        return NULL;
1313
1314
    if (bdrv_check_request(bs, sector_num, nb_sectors))
        return NULL;
1315
1316
1317
    ret = drv->bdrv_aio_readv(bs, sector_num, qiov, nb_sectors,
                              cb, opaque);
1318
1319
1320
1321
1322
1323
1324
1325

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

    return ret;
bellard authored
1326
1327
}
1328
1329
1330
BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
                                  QEMUIOVector *qiov, int nb_sectors,
                                  BlockDriverCompletionFunc *cb, void *opaque)
bellard authored
1331
{
bellard authored
1332
    BlockDriver *drv = bs->drv;
1333
    BlockDriverAIOCB *ret;
bellard authored
1334
1335
    if (!drv)
1336
        return NULL;
bellard authored
1337
    if (bs->read_only)
1338
        return NULL;
1339
1340
    if (bdrv_check_request(bs, sector_num, nb_sectors))
        return NULL;
bellard authored
1341
1342
1343
    ret = drv->bdrv_aio_writev(bs, sector_num, qiov, nb_sectors,
                               cb, opaque);
1344
1345
1346
1347
1348
1349
1350
1351

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

    return ret;
bellard authored
1352
1353
1354
1355
}

void bdrv_aio_cancel(BlockDriverAIOCB *acb)
{
1356
    acb->pool->cancel(acb);
bellard authored
1357
1358
}
1359
bellard authored
1360
1361
1362
/**************************************************************/
/* async block device emulation */
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
typedef struct BlockDriverAIOCBSync {
    BlockDriverAIOCB common;
    QEMUBH *bh;
    int ret;
    /* vector translation state */
    QEMUIOVector *qiov;
    uint8_t *bounce;
    int is_write;
} BlockDriverAIOCBSync;

static void bdrv_aio_cancel_em(BlockDriverAIOCB *blockacb)
{
    BlockDriverAIOCBSync *acb = (BlockDriverAIOCBSync *)blockacb;
1376
    qemu_bh_delete(acb->bh);
1377
    acb->bh = NULL;
1378
1379
1380
1381
1382
1383
1384
1385
    qemu_aio_release(acb);
}

static AIOPool bdrv_em_aio_pool = {
    .aiocb_size         = sizeof(BlockDriverAIOCBSync),
    .cancel             = bdrv_aio_cancel_em,
};
1386
static void bdrv_aio_bh_cb(void *opaque)
bellard authored
1387
{
1388
    BlockDriverAIOCBSync *acb = opaque;
1389
1390
1391

    if (!acb->is_write)
        qemu_iovec_from_buffer(acb->qiov, acb->bounce, acb->qiov->size);
1392
    qemu_vfree(acb->bounce);
1393
    acb->common.cb(acb->common.opaque, acb->ret);
1394
    qemu_bh_delete(acb->bh);
1395
    acb->bh = NULL;
1396
    qemu_aio_release(acb);
bellard authored
1397
}
1398
1399
1400
1401
1402
1403
1404
1405
1406
static BlockDriverAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs,
                                            int64_t sector_num,
                                            QEMUIOVector *qiov,
                                            int nb_sectors,
                                            BlockDriverCompletionFunc *cb,
                                            void *opaque,
                                            int is_write)
bellard authored
1407
{
1408
1409
    BlockDriverAIOCBSync *acb;
1410
    acb = qemu_aio_get(&bdrv_em_aio_pool, bs, cb, opaque);
1411
1412
    acb->is_write = is_write;
    acb->qiov = qiov;
1413
    acb->bounce = qemu_blockalign(bs, qiov->size);
1414
1415
1416
    if (!acb->bh)
        acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
1417
1418
1419
1420
1421
1422
1423
1424

    if (is_write) {
        qemu_iovec_to_buffer(acb->qiov, acb->bounce);
        acb->ret = bdrv_write(bs, sector_num, acb->bounce, nb_sectors);
    } else {
        acb->ret = bdrv_read(bs, sector_num, acb->bounce, nb_sectors);
    }
1425
    qemu_bh_schedule(acb->bh);
1426
1427
    return &acb->common;
1428
1429
}
1430
1431
static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
        int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
1432
        BlockDriverCompletionFunc *cb, void *opaque)
1433
{
1434
1435
    return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 0);
}
bellard authored
1436
1437
1438
1439
1440
1441
static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
        int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
        BlockDriverCompletionFunc *cb, void *opaque)
{
    return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 1);
1442
1443
}
bellard authored
1444
1445
/**************************************************************/
/* sync block device emulation */
bellard authored
1446
bellard authored
1447
1448
1449
static void bdrv_rw_em_cb(void *opaque, int ret)
{
    *(int *)opaque = ret;
bellard authored
1450
1451
}
bellard authored
1452
1453
#define NOT_DONE 0x7fffffff
1454
static int bdrv_read_em(BlockDriverState *bs, int64_t sector_num,
bellard authored
1455
                        uint8_t *buf, int nb_sectors)
pbrook authored
1456
{
1457
1458
    int async_ret;
    BlockDriverAIOCB *acb;
1459
1460
    struct iovec iov;
    QEMUIOVector qiov;
bellard authored
1461
1462

    async_ret = NOT_DONE;
1463
    iov.iov_base = (void *)buf;
1464
1465
1466
1467
    iov.iov_len = nb_sectors * 512;
    qemu_iovec_init_external(&qiov, &iov, 1);
    acb = bdrv_aio_readv(bs, sector_num, &qiov, nb_sectors,
        bdrv_rw_em_cb, &async_ret);
1468
    if (acb == NULL)
1469
        return -1;
1470
bellard authored
1471
1472
1473
    while (async_ret == NOT_DONE) {
        qemu_aio_wait();
    }
1474
bellard authored
1475
    return async_ret;
pbrook authored
1476
1477
}
bellard authored
1478
1479
1480
static int bdrv_write_em(BlockDriverState *bs, int64_t sector_num,
                         const uint8_t *buf, int nb_sectors)
{
1481
1482
    int async_ret;
    BlockDriverAIOCB *acb;
1483
1484
    struct iovec iov;
    QEMUIOVector qiov;
bellard authored
1485
1486

    async_ret = NOT_DONE;
1487
1488
1489
1490
1491
    iov.iov_base = (void *)buf;
    iov.iov_len = nb_sectors * 512;
    qemu_iovec_init_external(&qiov, &iov, 1);
    acb = bdrv_aio_writev(bs, sector_num, &qiov, nb_sectors,
        bdrv_rw_em_cb, &async_ret);
1492
    if (acb == NULL)
1493
        return -1;
bellard authored
1494
1495
1496
1497
1498
    while (async_ret == NOT_DONE) {
        qemu_aio_wait();
    }
    return async_ret;
}
bellard authored
1499
1500
1501

void bdrv_init(void)
{
1502
    module_call_init(MODULE_INIT_BLOCK);
bellard authored
1503
}
1504
1505
1506
void *qemu_aio_get(AIOPool *pool, BlockDriverState *bs,
                   BlockDriverCompletionFunc *cb, void *opaque)
1507
1508
1509
{
    BlockDriverAIOCB *acb;
1510
1511
1512
    if (pool->free_aiocb) {
        acb = pool->free_aiocb;
        pool->free_aiocb = acb->next;
1513
    } else {
1514
1515
        acb = qemu_mallocz(pool->aiocb_size);
        acb->pool = pool;
1516
1517
1518
1519
1520
1521
1522
1523
1524
    }
    acb->bs = bs;
    acb->cb = cb;
    acb->opaque = opaque;
    return acb;
}

void qemu_aio_release(void *p)
{
1525
1526
1527
1528
    BlockDriverAIOCB *acb = (BlockDriverAIOCB *)p;
    AIOPool *pool = acb->pool;
    acb->next = pool->free_aiocb;
    pool->free_aiocb = acb;
1529
}
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550

/**************************************************************/
/* 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
1551
 * function. It is currently only used for floppy disks
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
 */
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
 */
1571
int bdrv_eject(BlockDriverState *bs, int eject_flag)
1572
1573
1574
1575
{
    BlockDriver *drv = bs->drv;
    int ret;
1576
1577
1578
1579
    if (bs->locked) {
        return -EBUSY;
    }
1580
1581
1582
1583
1584
1585
1586
1587
    if (!drv || !drv->bdrv_eject) {
        ret = -ENOTSUP;
    } else {
        ret = drv->bdrv_eject(bs, eject_flag);
    }
    if (ret == -ENOTSUP) {
        if (eject_flag)
            bdrv_close(bs);
1588
        ret = 0;
1589
    }
1590
1591

    return ret;
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
}

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);
    }
}
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622

/* needed for generic scsi interface */

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

    if (drv && drv->bdrv_ioctl)
        return drv->bdrv_ioctl(bs, req, buf);
    return -ENOTSUP;
}
1623
1624
1625
1626
BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
        unsigned long int req, void *buf,
        BlockDriverCompletionFunc *cb, void *opaque)
1627
{
1628
    BlockDriver *drv = bs->drv;
1629
1630
1631
1632
    if (drv && drv->bdrv_aio_ioctl)
        return drv->bdrv_aio_ioctl(bs, req, buf, cb, opaque);
    return NULL;
1633
}
1634
1635
1636
1637
1638

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