bdrv_write should not stop on partial write (Gleb Natapov)
[qemu] / block.c
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 "config-host.h"
25 #ifdef _BSD
26 /* include native header before sys-queue.h */
27 #include <sys/queue.h>
28 #endif
29
30 #include "qemu-common.h"
31 #include "console.h"
32 #include "block_int.h"
33
34 #ifdef _BSD
35 #include <sys/types.h>
36 #include <sys/stat.h>
37 #include <sys/ioctl.h>
38 #include <sys/disk.h>
39 #endif
40
41 #define SECTOR_BITS 9
42 #define SECTOR_SIZE (1 << SECTOR_BITS)
43
44 typedef struct BlockDriverAIOCBSync {
45     BlockDriverAIOCB common;
46     QEMUBH *bh;
47     int ret;
48 } BlockDriverAIOCBSync;
49
50 static BlockDriverAIOCB *bdrv_aio_read_em(BlockDriverState *bs,
51         int64_t sector_num, uint8_t *buf, int nb_sectors,
52         BlockDriverCompletionFunc *cb, void *opaque);
53 static BlockDriverAIOCB *bdrv_aio_write_em(BlockDriverState *bs,
54         int64_t sector_num, const uint8_t *buf, int nb_sectors,
55         BlockDriverCompletionFunc *cb, void *opaque);
56 static void bdrv_aio_cancel_em(BlockDriverAIOCB *acb);
57 static int bdrv_read_em(BlockDriverState *bs, int64_t sector_num,
58                         uint8_t *buf, int nb_sectors);
59 static int bdrv_write_em(BlockDriverState *bs, int64_t sector_num,
60                          const uint8_t *buf, int nb_sectors);
61
62 BlockDriverState *bdrv_first;
63
64 static BlockDriver *first_drv;
65
66 int path_is_absolute(const char *path)
67 {
68     const char *p;
69 #ifdef _WIN32
70     /* specific case for names like: "\\.\d:" */
71     if (*path == '/' || *path == '\\')
72         return 1;
73 #endif
74     p = strchr(path, ':');
75     if (p)
76         p++;
77     else
78         p = path;
79 #ifdef _WIN32
80     return (*p == '/' || *p == '\\');
81 #else
82     return (*p == '/');
83 #endif
84 }
85
86 /* if filename is absolute, just copy it to dest. Otherwise, build a
87    path to it by considering it is relative to base_path. URL are
88    supported. */
89 void path_combine(char *dest, int dest_size,
90                   const char *base_path,
91                   const char *filename)
92 {
93     const char *p, *p1;
94     int len;
95
96     if (dest_size <= 0)
97         return;
98     if (path_is_absolute(filename)) {
99         pstrcpy(dest, dest_size, filename);
100     } else {
101         p = strchr(base_path, ':');
102         if (p)
103             p++;
104         else
105             p = base_path;
106         p1 = strrchr(base_path, '/');
107 #ifdef _WIN32
108         {
109             const char *p2;
110             p2 = strrchr(base_path, '\\');
111             if (!p1 || p2 > p1)
112                 p1 = p2;
113         }
114 #endif
115         if (p1)
116             p1++;
117         else
118             p1 = base_path;
119         if (p1 > p)
120             p = p1;
121         len = p - base_path;
122         if (len > dest_size - 1)
123             len = dest_size - 1;
124         memcpy(dest, base_path, len);
125         dest[len] = '\0';
126         pstrcat(dest, dest_size, filename);
127     }
128 }
129
130
131 static void bdrv_register(BlockDriver *bdrv)
132 {
133     if (!bdrv->bdrv_aio_read) {
134         /* add AIO emulation layer */
135         bdrv->bdrv_aio_read = bdrv_aio_read_em;
136         bdrv->bdrv_aio_write = bdrv_aio_write_em;
137         bdrv->bdrv_aio_cancel = bdrv_aio_cancel_em;
138         bdrv->aiocb_size = sizeof(BlockDriverAIOCBSync);
139     } else if (!bdrv->bdrv_read && !bdrv->bdrv_pread) {
140         /* add synchronous IO emulation layer */
141         bdrv->bdrv_read = bdrv_read_em;
142         bdrv->bdrv_write = bdrv_write_em;
143     }
144     bdrv->next = first_drv;
145     first_drv = bdrv;
146 }
147
148 /* create a new block device (by default it is empty) */
149 BlockDriverState *bdrv_new(const char *device_name)
150 {
151     BlockDriverState **pbs, *bs;
152
153     bs = qemu_mallocz(sizeof(BlockDriverState));
154     if(!bs)
155         return NULL;
156     pstrcpy(bs->device_name, sizeof(bs->device_name), device_name);
157     if (device_name[0] != '\0') {
158         /* insert at the end */
159         pbs = &bdrv_first;
160         while (*pbs != NULL)
161             pbs = &(*pbs)->next;
162         *pbs = bs;
163     }
164     return bs;
165 }
166
167 BlockDriver *bdrv_find_format(const char *format_name)
168 {
169     BlockDriver *drv1;
170     for(drv1 = first_drv; drv1 != NULL; drv1 = drv1->next) {
171         if (!strcmp(drv1->format_name, format_name))
172             return drv1;
173     }
174     return NULL;
175 }
176
177 int bdrv_create(BlockDriver *drv,
178                 const char *filename, int64_t size_in_sectors,
179                 const char *backing_file, int flags)
180 {
181     if (!drv->bdrv_create)
182         return -ENOTSUP;
183     return drv->bdrv_create(filename, size_in_sectors, backing_file, flags);
184 }
185
186 #ifdef _WIN32
187 void get_tmp_filename(char *filename, int size)
188 {
189     char temp_dir[MAX_PATH];
190
191     GetTempPath(MAX_PATH, temp_dir);
192     GetTempFileName(temp_dir, "qem", 0, filename);
193 }
194 #else
195 void get_tmp_filename(char *filename, int size)
196 {
197     int fd;
198     const char *tmpdir;
199     /* XXX: race condition possible */
200     tmpdir = getenv("TMPDIR");
201     if (!tmpdir)
202         tmpdir = "/tmp";
203     snprintf(filename, size, "%s/vl.XXXXXX", tmpdir);
204     fd = mkstemp(filename);
205     close(fd);
206 }
207 #endif
208
209 #ifdef _WIN32
210 static int is_windows_drive_prefix(const char *filename)
211 {
212     return (((filename[0] >= 'a' && filename[0] <= 'z') ||
213              (filename[0] >= 'A' && filename[0] <= 'Z')) &&
214             filename[1] == ':');
215 }
216
217 static int is_windows_drive(const char *filename)
218 {
219     if (is_windows_drive_prefix(filename) &&
220         filename[2] == '\0')
221         return 1;
222     if (strstart(filename, "\\\\.\\", NULL) ||
223         strstart(filename, "//./", NULL))
224         return 1;
225     return 0;
226 }
227 #endif
228
229 static BlockDriver *find_protocol(const char *filename)
230 {
231     BlockDriver *drv1;
232     char protocol[128];
233     int len;
234     const char *p;
235
236 #ifdef _WIN32
237     if (is_windows_drive(filename) ||
238         is_windows_drive_prefix(filename))
239         return &bdrv_raw;
240 #endif
241     p = strchr(filename, ':');
242     if (!p)
243         return &bdrv_raw;
244     len = p - filename;
245     if (len > sizeof(protocol) - 1)
246         len = sizeof(protocol) - 1;
247     memcpy(protocol, filename, len);
248     protocol[len] = '\0';
249     for(drv1 = first_drv; drv1 != NULL; drv1 = drv1->next) {
250         if (drv1->protocol_name &&
251             !strcmp(drv1->protocol_name, protocol))
252             return drv1;
253     }
254     return NULL;
255 }
256
257 /* XXX: force raw format if block or character device ? It would
258    simplify the BSD case */
259 static BlockDriver *find_image_format(const char *filename)
260 {
261     int ret, score, score_max;
262     BlockDriver *drv1, *drv;
263     uint8_t buf[2048];
264     BlockDriverState *bs;
265
266     /* detect host devices. By convention, /dev/cdrom[N] is always
267        recognized as a host CDROM */
268     if (strstart(filename, "/dev/cdrom", NULL))
269         return &bdrv_host_device;
270 #ifdef _WIN32
271     if (is_windows_drive(filename))
272         return &bdrv_host_device;
273 #else
274     {
275         struct stat st;
276         if (stat(filename, &st) >= 0 &&
277             (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode))) {
278             return &bdrv_host_device;
279         }
280     }
281 #endif
282
283     drv = find_protocol(filename);
284     /* no need to test disk image formats for vvfat */
285     if (drv == &bdrv_vvfat)
286         return drv;
287
288     ret = bdrv_file_open(&bs, filename, BDRV_O_RDONLY);
289     if (ret < 0)
290         return NULL;
291     ret = bdrv_pread(bs, 0, buf, sizeof(buf));
292     bdrv_delete(bs);
293     if (ret < 0) {
294         return NULL;
295     }
296
297     score_max = 0;
298     for(drv1 = first_drv; drv1 != NULL; drv1 = drv1->next) {
299         if (drv1->bdrv_probe) {
300             score = drv1->bdrv_probe(buf, ret, filename);
301             if (score > score_max) {
302                 score_max = score;
303                 drv = drv1;
304             }
305         }
306     }
307     return drv;
308 }
309
310 int bdrv_file_open(BlockDriverState **pbs, const char *filename, int flags)
311 {
312     BlockDriverState *bs;
313     int ret;
314
315     bs = bdrv_new("");
316     if (!bs)
317         return -ENOMEM;
318     ret = bdrv_open2(bs, filename, flags | BDRV_O_FILE, NULL);
319     if (ret < 0) {
320         bdrv_delete(bs);
321         return ret;
322     }
323     *pbs = bs;
324     return 0;
325 }
326
327 int bdrv_open(BlockDriverState *bs, const char *filename, int flags)
328 {
329     return bdrv_open2(bs, filename, flags, NULL);
330 }
331
332 int bdrv_open2(BlockDriverState *bs, const char *filename, int flags,
333                BlockDriver *drv)
334 {
335     int ret, open_flags;
336     char tmp_filename[PATH_MAX];
337     char backing_filename[PATH_MAX];
338
339     bs->read_only = 0;
340     bs->is_temporary = 0;
341     bs->encrypted = 0;
342
343     if (flags & BDRV_O_SNAPSHOT) {
344         BlockDriverState *bs1;
345         int64_t total_size;
346         int is_protocol = 0;
347
348         /* if snapshot, we create a temporary backing file and open it
349            instead of opening 'filename' directly */
350
351         /* if there is a backing file, use it */
352         bs1 = bdrv_new("");
353         if (!bs1) {
354             return -ENOMEM;
355         }
356         if (bdrv_open(bs1, filename, 0) < 0) {
357             bdrv_delete(bs1);
358             return -1;
359         }
360         total_size = bdrv_getlength(bs1) >> SECTOR_BITS;
361
362         if (bs1->drv && bs1->drv->protocol_name)
363             is_protocol = 1;
364
365         bdrv_delete(bs1);
366
367         get_tmp_filename(tmp_filename, sizeof(tmp_filename));
368
369         /* Real path is meaningless for protocols */
370         if (is_protocol)
371             snprintf(backing_filename, sizeof(backing_filename),
372                      "%s", filename);
373         else
374             realpath(filename, backing_filename);
375
376         if (bdrv_create(&bdrv_qcow2, tmp_filename,
377                         total_size, backing_filename, 0) < 0) {
378             return -1;
379         }
380         filename = tmp_filename;
381         bs->is_temporary = 1;
382     }
383
384     pstrcpy(bs->filename, sizeof(bs->filename), filename);
385     if (flags & BDRV_O_FILE) {
386         drv = find_protocol(filename);
387         if (!drv)
388             return -ENOENT;
389     } else {
390         if (!drv) {
391             drv = find_image_format(filename);
392             if (!drv)
393                 return -1;
394         }
395     }
396     bs->drv = drv;
397     bs->opaque = qemu_mallocz(drv->instance_size);
398     if (bs->opaque == NULL && drv->instance_size > 0)
399         return -1;
400     /* Note: for compatibility, we open disk image files as RDWR, and
401        RDONLY as fallback */
402     if (!(flags & BDRV_O_FILE))
403         open_flags = BDRV_O_RDWR | (flags & BDRV_O_CACHE_MASK);
404     else
405         open_flags = flags & ~(BDRV_O_FILE | BDRV_O_SNAPSHOT);
406     ret = drv->bdrv_open(bs, filename, open_flags);
407     if ((ret == -EACCES || ret == -EPERM) && !(flags & BDRV_O_FILE)) {
408         ret = drv->bdrv_open(bs, filename, open_flags & ~BDRV_O_RDWR);
409         bs->read_only = 1;
410     }
411     if (ret < 0) {
412         qemu_free(bs->opaque);
413         bs->opaque = NULL;
414         bs->drv = NULL;
415         return ret;
416     }
417     if (drv->bdrv_getlength) {
418         bs->total_sectors = bdrv_getlength(bs) >> SECTOR_BITS;
419     }
420 #ifndef _WIN32
421     if (bs->is_temporary) {
422         unlink(filename);
423     }
424 #endif
425     if (bs->backing_file[0] != '\0') {
426         /* if there is a backing file, use it */
427         bs->backing_hd = bdrv_new("");
428         if (!bs->backing_hd) {
429         fail:
430             bdrv_close(bs);
431             return -ENOMEM;
432         }
433         path_combine(backing_filename, sizeof(backing_filename),
434                      filename, bs->backing_file);
435         if (bdrv_open(bs->backing_hd, backing_filename, open_flags) < 0)
436             goto fail;
437     }
438
439     /* call the change callback */
440     bs->media_changed = 1;
441     if (bs->change_cb)
442         bs->change_cb(bs->change_opaque);
443
444     return 0;
445 }
446
447 void bdrv_close(BlockDriverState *bs)
448 {
449     if (bs->drv) {
450         if (bs->backing_hd)
451             bdrv_delete(bs->backing_hd);
452         bs->drv->bdrv_close(bs);
453         qemu_free(bs->opaque);
454 #ifdef _WIN32
455         if (bs->is_temporary) {
456             unlink(bs->filename);
457         }
458 #endif
459         bs->opaque = NULL;
460         bs->drv = NULL;
461
462         /* call the change callback */
463         bs->media_changed = 1;
464         if (bs->change_cb)
465             bs->change_cb(bs->change_opaque);
466     }
467 }
468
469 void bdrv_delete(BlockDriverState *bs)
470 {
471     BlockDriverState **pbs;
472
473     pbs = &bdrv_first;
474     while (*pbs != bs && *pbs != NULL)
475         pbs = &(*pbs)->next;
476     if (*pbs == bs)
477         *pbs = bs->next;
478
479     bdrv_close(bs);
480     qemu_free(bs);
481 }
482
483 /* commit COW file into the raw image */
484 int bdrv_commit(BlockDriverState *bs)
485 {
486     BlockDriver *drv = bs->drv;
487     int64_t i, total_sectors;
488     int n, j;
489     unsigned char sector[512];
490
491     if (!drv)
492         return -ENOMEDIUM;
493
494     if (bs->read_only) {
495         return -EACCES;
496     }
497
498     if (!bs->backing_hd) {
499         return -ENOTSUP;
500     }
501
502     total_sectors = bdrv_getlength(bs) >> SECTOR_BITS;
503     for (i = 0; i < total_sectors;) {
504         if (drv->bdrv_is_allocated(bs, i, 65536, &n)) {
505             for(j = 0; j < n; j++) {
506                 if (bdrv_read(bs, i, sector, 1) != 0) {
507                     return -EIO;
508                 }
509
510                 if (bdrv_write(bs->backing_hd, i, sector, 1) != 0) {
511                     return -EIO;
512                 }
513                 i++;
514             }
515         } else {
516             i += n;
517         }
518     }
519
520     if (drv->bdrv_make_empty)
521         return drv->bdrv_make_empty(bs);
522
523     return 0;
524 }
525
526 /* return < 0 if error. See bdrv_write() for the return codes */
527 int bdrv_read(BlockDriverState *bs, int64_t sector_num,
528               uint8_t *buf, int nb_sectors)
529 {
530     BlockDriver *drv = bs->drv;
531
532     if (!drv)
533         return -ENOMEDIUM;
534
535     if (drv->bdrv_pread) {
536         int ret, len;
537         len = nb_sectors * 512;
538         ret = drv->bdrv_pread(bs, sector_num * 512, buf, len);
539         if (ret < 0)
540             return ret;
541         else if (ret != len)
542             return -EINVAL;
543         else {
544             bs->rd_bytes += (unsigned) len;
545             bs->rd_ops ++;
546             return 0;
547         }
548     } else {
549         return drv->bdrv_read(bs, sector_num, buf, nb_sectors);
550     }
551 }
552
553 /* Return < 0 if error. Important errors are:
554   -EIO         generic I/O error (may happen for all errors)
555   -ENOMEDIUM   No media inserted.
556   -EINVAL      Invalid sector number or nb_sectors
557   -EACCES      Trying to write a read-only device
558 */
559 int bdrv_write(BlockDriverState *bs, int64_t sector_num,
560                const uint8_t *buf, int nb_sectors)
561 {
562     BlockDriver *drv = bs->drv;
563     if (!bs->drv)
564         return -ENOMEDIUM;
565     if (bs->read_only)
566         return -EACCES;
567     if (drv->bdrv_pwrite) {
568         int ret, len, count = 0;
569         len = nb_sectors * 512;
570         do {
571             ret = drv->bdrv_pwrite(bs, sector_num * 512, buf, len - count);
572             if (ret < 0) {
573                 printf("bdrv_write ret=%d\n", ret);
574                 return ret;
575             }
576             count += ret;
577             buf += ret;
578         } while (count != len);
579         bs->wr_bytes += (unsigned) len;
580         bs->wr_ops ++;
581         return 0;
582     }
583     return drv->bdrv_write(bs, sector_num, buf, nb_sectors);
584 }
585
586 static int bdrv_pread_em(BlockDriverState *bs, int64_t offset,
587                          uint8_t *buf, int count1)
588 {
589     uint8_t tmp_buf[SECTOR_SIZE];
590     int len, nb_sectors, count;
591     int64_t sector_num;
592
593     count = count1;
594     /* first read to align to sector start */
595     len = (SECTOR_SIZE - offset) & (SECTOR_SIZE - 1);
596     if (len > count)
597         len = count;
598     sector_num = offset >> SECTOR_BITS;
599     if (len > 0) {
600         if (bdrv_read(bs, sector_num, tmp_buf, 1) < 0)
601             return -EIO;
602         memcpy(buf, tmp_buf + (offset & (SECTOR_SIZE - 1)), len);
603         count -= len;
604         if (count == 0)
605             return count1;
606         sector_num++;
607         buf += len;
608     }
609
610     /* read the sectors "in place" */
611     nb_sectors = count >> SECTOR_BITS;
612     if (nb_sectors > 0) {
613         if (bdrv_read(bs, sector_num, buf, nb_sectors) < 0)
614             return -EIO;
615         sector_num += nb_sectors;
616         len = nb_sectors << SECTOR_BITS;
617         buf += len;
618         count -= len;
619     }
620
621     /* add data from the last sector */
622     if (count > 0) {
623         if (bdrv_read(bs, sector_num, tmp_buf, 1) < 0)
624             return -EIO;
625         memcpy(buf, tmp_buf, count);
626     }
627     return count1;
628 }
629
630 static int bdrv_pwrite_em(BlockDriverState *bs, int64_t offset,
631                           const uint8_t *buf, int count1)
632 {
633     uint8_t tmp_buf[SECTOR_SIZE];
634     int len, nb_sectors, count;
635     int64_t sector_num;
636
637     count = count1;
638     /* first write to align to sector start */
639     len = (SECTOR_SIZE - offset) & (SECTOR_SIZE - 1);
640     if (len > count)
641         len = count;
642     sector_num = offset >> SECTOR_BITS;
643     if (len > 0) {
644         if (bdrv_read(bs, sector_num, tmp_buf, 1) < 0)
645             return -EIO;
646         memcpy(tmp_buf + (offset & (SECTOR_SIZE - 1)), buf, len);
647         if (bdrv_write(bs, sector_num, tmp_buf, 1) < 0)
648             return -EIO;
649         count -= len;
650         if (count == 0)
651             return count1;
652         sector_num++;
653         buf += len;
654     }
655
656     /* write the sectors "in place" */
657     nb_sectors = count >> SECTOR_BITS;
658     if (nb_sectors > 0) {
659         if (bdrv_write(bs, sector_num, buf, nb_sectors) < 0)
660             return -EIO;
661         sector_num += nb_sectors;
662         len = nb_sectors << SECTOR_BITS;
663         buf += len;
664         count -= len;
665     }
666
667     /* add data from the last sector */
668     if (count > 0) {
669         if (bdrv_read(bs, sector_num, tmp_buf, 1) < 0)
670             return -EIO;
671         memcpy(tmp_buf, buf, count);
672         if (bdrv_write(bs, sector_num, tmp_buf, 1) < 0)
673             return -EIO;
674     }
675     return count1;
676 }
677
678 /**
679  * Read with byte offsets (needed only for file protocols)
680  */
681 int bdrv_pread(BlockDriverState *bs, int64_t offset,
682                void *buf1, int count1)
683 {
684     BlockDriver *drv = bs->drv;
685
686     if (!drv)
687         return -ENOMEDIUM;
688     if (!drv->bdrv_pread)
689         return bdrv_pread_em(bs, offset, buf1, count1);
690     return drv->bdrv_pread(bs, offset, buf1, count1);
691 }
692
693 /**
694  * Write with byte offsets (needed only for file protocols)
695  */
696 int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
697                 const void *buf1, int count1)
698 {
699     BlockDriver *drv = bs->drv;
700
701     if (!drv)
702         return -ENOMEDIUM;
703     if (!drv->bdrv_pwrite)
704         return bdrv_pwrite_em(bs, offset, buf1, count1);
705     return drv->bdrv_pwrite(bs, offset, buf1, count1);
706 }
707
708 /**
709  * Truncate file to 'offset' bytes (needed only for file protocols)
710  */
711 int bdrv_truncate(BlockDriverState *bs, int64_t offset)
712 {
713     BlockDriver *drv = bs->drv;
714     if (!drv)
715         return -ENOMEDIUM;
716     if (!drv->bdrv_truncate)
717         return -ENOTSUP;
718     return drv->bdrv_truncate(bs, offset);
719 }
720
721 /**
722  * Length of a file in bytes. Return < 0 if error or unknown.
723  */
724 int64_t bdrv_getlength(BlockDriverState *bs)
725 {
726     BlockDriver *drv = bs->drv;
727     if (!drv)
728         return -ENOMEDIUM;
729     if (!drv->bdrv_getlength) {
730         /* legacy mode */
731         return bs->total_sectors * SECTOR_SIZE;
732     }
733     return drv->bdrv_getlength(bs);
734 }
735
736 /* return 0 as number of sectors if no device present or error */
737 void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
738 {
739     int64_t length;
740     length = bdrv_getlength(bs);
741     if (length < 0)
742         length = 0;
743     else
744         length = length >> SECTOR_BITS;
745     *nb_sectors_ptr = length;
746 }
747
748 struct partition {
749         uint8_t boot_ind;           /* 0x80 - active */
750         uint8_t head;               /* starting head */
751         uint8_t sector;             /* starting sector */
752         uint8_t cyl;                /* starting cylinder */
753         uint8_t sys_ind;            /* What partition type */
754         uint8_t end_head;           /* end head */
755         uint8_t end_sector;         /* end sector */
756         uint8_t end_cyl;            /* end cylinder */
757         uint32_t start_sect;        /* starting sector counting from 0 */
758         uint32_t nr_sects;          /* nr of sectors in partition */
759 } __attribute__((packed));
760
761 /* try to guess the disk logical geometry from the MSDOS partition table. Return 0 if OK, -1 if could not guess */
762 static int guess_disk_lchs(BlockDriverState *bs,
763                            int *pcylinders, int *pheads, int *psectors)
764 {
765     uint8_t buf[512];
766     int ret, i, heads, sectors, cylinders;
767     struct partition *p;
768     uint32_t nr_sects;
769     uint64_t nb_sectors;
770
771     bdrv_get_geometry(bs, &nb_sectors);
772
773     ret = bdrv_read(bs, 0, buf, 1);
774     if (ret < 0)
775         return -1;
776     /* test msdos magic */
777     if (buf[510] != 0x55 || buf[511] != 0xaa)
778         return -1;
779     for(i = 0; i < 4; i++) {
780         p = ((struct partition *)(buf + 0x1be)) + i;
781         nr_sects = le32_to_cpu(p->nr_sects);
782         if (nr_sects && p->end_head) {
783             /* We make the assumption that the partition terminates on
784                a cylinder boundary */
785             heads = p->end_head + 1;
786             sectors = p->end_sector & 63;
787             if (sectors == 0)
788                 continue;
789             cylinders = nb_sectors / (heads * sectors);
790             if (cylinders < 1 || cylinders > 16383)
791                 continue;
792             *pheads = heads;
793             *psectors = sectors;
794             *pcylinders = cylinders;
795 #if 0
796             printf("guessed geometry: LCHS=%d %d %d\n",
797                    cylinders, heads, sectors);
798 #endif
799             return 0;
800         }
801     }
802     return -1;
803 }
804
805 void bdrv_guess_geometry(BlockDriverState *bs, int *pcyls, int *pheads, int *psecs)
806 {
807     int translation, lba_detected = 0;
808     int cylinders, heads, secs;
809     uint64_t nb_sectors;
810
811     /* if a geometry hint is available, use it */
812     bdrv_get_geometry(bs, &nb_sectors);
813     bdrv_get_geometry_hint(bs, &cylinders, &heads, &secs);
814     translation = bdrv_get_translation_hint(bs);
815     if (cylinders != 0) {
816         *pcyls = cylinders;
817         *pheads = heads;
818         *psecs = secs;
819     } else {
820         if (guess_disk_lchs(bs, &cylinders, &heads, &secs) == 0) {
821             if (heads > 16) {
822                 /* if heads > 16, it means that a BIOS LBA
823                    translation was active, so the default
824                    hardware geometry is OK */
825                 lba_detected = 1;
826                 goto default_geometry;
827             } else {
828                 *pcyls = cylinders;
829                 *pheads = heads;
830                 *psecs = secs;
831                 /* disable any translation to be in sync with
832                    the logical geometry */
833                 if (translation == BIOS_ATA_TRANSLATION_AUTO) {
834                     bdrv_set_translation_hint(bs,
835                                               BIOS_ATA_TRANSLATION_NONE);
836                 }
837             }
838         } else {
839         default_geometry:
840             /* if no geometry, use a standard physical disk geometry */
841             cylinders = nb_sectors / (16 * 63);
842
843             if (cylinders > 16383)
844                 cylinders = 16383;
845             else if (cylinders < 2)
846                 cylinders = 2;
847             *pcyls = cylinders;
848             *pheads = 16;
849             *psecs = 63;
850             if ((lba_detected == 1) && (translation == BIOS_ATA_TRANSLATION_AUTO)) {
851                 if ((*pcyls * *pheads) <= 131072) {
852                     bdrv_set_translation_hint(bs,
853                                               BIOS_ATA_TRANSLATION_LARGE);
854                 } else {
855                     bdrv_set_translation_hint(bs,
856                                               BIOS_ATA_TRANSLATION_LBA);
857                 }
858             }
859         }
860         bdrv_set_geometry_hint(bs, *pcyls, *pheads, *psecs);
861     }
862 }
863
864 void bdrv_set_geometry_hint(BlockDriverState *bs,
865                             int cyls, int heads, int secs)
866 {
867     bs->cyls = cyls;
868     bs->heads = heads;
869     bs->secs = secs;
870 }
871
872 void bdrv_set_type_hint(BlockDriverState *bs, int type)
873 {
874     bs->type = type;
875     bs->removable = ((type == BDRV_TYPE_CDROM ||
876                       type == BDRV_TYPE_FLOPPY));
877 }
878
879 void bdrv_set_translation_hint(BlockDriverState *bs, int translation)
880 {
881     bs->translation = translation;
882 }
883
884 void bdrv_get_geometry_hint(BlockDriverState *bs,
885                             int *pcyls, int *pheads, int *psecs)
886 {
887     *pcyls = bs->cyls;
888     *pheads = bs->heads;
889     *psecs = bs->secs;
890 }
891
892 int bdrv_get_type_hint(BlockDriverState *bs)
893 {
894     return bs->type;
895 }
896
897 int bdrv_get_translation_hint(BlockDriverState *bs)
898 {
899     return bs->translation;
900 }
901
902 int bdrv_is_removable(BlockDriverState *bs)
903 {
904     return bs->removable;
905 }
906
907 int bdrv_is_read_only(BlockDriverState *bs)
908 {
909     return bs->read_only;
910 }
911
912 int bdrv_is_sg(BlockDriverState *bs)
913 {
914     return bs->sg;
915 }
916
917 /* XXX: no longer used */
918 void bdrv_set_change_cb(BlockDriverState *bs,
919                         void (*change_cb)(void *opaque), void *opaque)
920 {
921     bs->change_cb = change_cb;
922     bs->change_opaque = opaque;
923 }
924
925 int bdrv_is_encrypted(BlockDriverState *bs)
926 {
927     if (bs->backing_hd && bs->backing_hd->encrypted)
928         return 1;
929     return bs->encrypted;
930 }
931
932 int bdrv_set_key(BlockDriverState *bs, const char *key)
933 {
934     int ret;
935     if (bs->backing_hd && bs->backing_hd->encrypted) {
936         ret = bdrv_set_key(bs->backing_hd, key);
937         if (ret < 0)
938             return ret;
939         if (!bs->encrypted)
940             return 0;
941     }
942     if (!bs->encrypted || !bs->drv || !bs->drv->bdrv_set_key)
943         return -1;
944     return bs->drv->bdrv_set_key(bs, key);
945 }
946
947 void bdrv_get_format(BlockDriverState *bs, char *buf, int buf_size)
948 {
949     if (!bs->drv) {
950         buf[0] = '\0';
951     } else {
952         pstrcpy(buf, buf_size, bs->drv->format_name);
953     }
954 }
955
956 void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
957                          void *opaque)
958 {
959     BlockDriver *drv;
960
961     for (drv = first_drv; drv != NULL; drv = drv->next) {
962         it(opaque, drv->format_name);
963     }
964 }
965
966 BlockDriverState *bdrv_find(const char *name)
967 {
968     BlockDriverState *bs;
969
970     for (bs = bdrv_first; bs != NULL; bs = bs->next) {
971         if (!strcmp(name, bs->device_name))
972             return bs;
973     }
974     return NULL;
975 }
976
977 void bdrv_iterate(void (*it)(void *opaque, const char *name), void *opaque)
978 {
979     BlockDriverState *bs;
980
981     for (bs = bdrv_first; bs != NULL; bs = bs->next) {
982         it(opaque, bs->device_name);
983     }
984 }
985
986 const char *bdrv_get_device_name(BlockDriverState *bs)
987 {
988     return bs->device_name;
989 }
990
991 void bdrv_flush(BlockDriverState *bs)
992 {
993     if (bs->drv->bdrv_flush)
994         bs->drv->bdrv_flush(bs);
995     if (bs->backing_hd)
996         bdrv_flush(bs->backing_hd);
997 }
998
999 void bdrv_flush_all(void)
1000 {
1001     BlockDriverState *bs;
1002
1003     for (bs = bdrv_first; bs != NULL; bs = bs->next)
1004         if (bs->drv && !bdrv_is_read_only(bs) && 
1005             (!bdrv_is_removable(bs) || bdrv_is_inserted(bs)))
1006             bdrv_flush(bs);
1007 }
1008
1009 /*
1010  * Returns true iff the specified sector is present in the disk image. Drivers
1011  * not implementing the functionality are assumed to not support backing files,
1012  * hence all their sectors are reported as allocated.
1013  *
1014  * 'pnum' is set to the number of sectors (including and immediately following
1015  * the specified sector) that are known to be in the same
1016  * allocated/unallocated state.
1017  *
1018  * 'nb_sectors' is the max value 'pnum' should be set to.
1019  */
1020 int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
1021         int *pnum)
1022 {
1023     int64_t n;
1024     if (!bs->drv->bdrv_is_allocated) {
1025         if (sector_num >= bs->total_sectors) {
1026             *pnum = 0;
1027             return 0;
1028         }
1029         n = bs->total_sectors - sector_num;
1030         *pnum = (n < nb_sectors) ? (n) : (nb_sectors);
1031         return 1;
1032     }
1033     return bs->drv->bdrv_is_allocated(bs, sector_num, nb_sectors, pnum);
1034 }
1035
1036 void bdrv_info(void)
1037 {
1038     BlockDriverState *bs;
1039
1040     for (bs = bdrv_first; bs != NULL; bs = bs->next) {
1041         term_printf("%s:", bs->device_name);
1042         term_printf(" type=");
1043         switch(bs->type) {
1044         case BDRV_TYPE_HD:
1045             term_printf("hd");
1046             break;
1047         case BDRV_TYPE_CDROM:
1048             term_printf("cdrom");
1049             break;
1050         case BDRV_TYPE_FLOPPY:
1051             term_printf("floppy");
1052             break;
1053         }
1054         term_printf(" removable=%d", bs->removable);
1055         if (bs->removable) {
1056             term_printf(" locked=%d", bs->locked);
1057         }
1058         if (bs->drv) {
1059             term_printf(" file=");
1060             term_print_filename(bs->filename);
1061             if (bs->backing_file[0] != '\0') {
1062                 term_printf(" backing_file=");
1063                 term_print_filename(bs->backing_file);
1064             }
1065             term_printf(" ro=%d", bs->read_only);
1066             term_printf(" drv=%s", bs->drv->format_name);
1067             if (bs->encrypted)
1068                 term_printf(" encrypted");
1069         } else {
1070             term_printf(" [not inserted]");
1071         }
1072         term_printf("\n");
1073     }
1074 }
1075
1076 /* The "info blockstats" command. */
1077 void bdrv_info_stats (void)
1078 {
1079     BlockDriverState *bs;
1080
1081     for (bs = bdrv_first; bs != NULL; bs = bs->next) {
1082         term_printf ("%s:"
1083                      " rd_bytes=%" PRIu64
1084                      " wr_bytes=%" PRIu64
1085                      " rd_operations=%" PRIu64
1086                      " wr_operations=%" PRIu64
1087                      "\n",
1088                      bs->device_name,
1089                      bs->rd_bytes, bs->wr_bytes,
1090                      bs->rd_ops, bs->wr_ops);
1091     }
1092 }
1093
1094 void bdrv_get_backing_filename(BlockDriverState *bs,
1095                                char *filename, int filename_size)
1096 {
1097     if (!bs->backing_hd) {
1098         pstrcpy(filename, filename_size, "");
1099     } else {
1100         pstrcpy(filename, filename_size, bs->backing_file);
1101     }
1102 }
1103
1104 int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
1105                           const uint8_t *buf, int nb_sectors)
1106 {
1107     BlockDriver *drv = bs->drv;
1108     if (!drv)
1109         return -ENOMEDIUM;
1110     if (!drv->bdrv_write_compressed)
1111         return -ENOTSUP;
1112     return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);
1113 }
1114
1115 int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
1116 {
1117     BlockDriver *drv = bs->drv;
1118     if (!drv)
1119         return -ENOMEDIUM;
1120     if (!drv->bdrv_get_info)
1121         return -ENOTSUP;
1122     memset(bdi, 0, sizeof(*bdi));
1123     return drv->bdrv_get_info(bs, bdi);
1124 }
1125
1126 /**************************************************************/
1127 /* handling of snapshots */
1128
1129 int bdrv_snapshot_create(BlockDriverState *bs,
1130                          QEMUSnapshotInfo *sn_info)
1131 {
1132     BlockDriver *drv = bs->drv;
1133     if (!drv)
1134         return -ENOMEDIUM;
1135     if (!drv->bdrv_snapshot_create)
1136         return -ENOTSUP;
1137     return drv->bdrv_snapshot_create(bs, sn_info);
1138 }
1139
1140 int bdrv_snapshot_goto(BlockDriverState *bs,
1141                        const char *snapshot_id)
1142 {
1143     BlockDriver *drv = bs->drv;
1144     if (!drv)
1145         return -ENOMEDIUM;
1146     if (!drv->bdrv_snapshot_goto)
1147         return -ENOTSUP;
1148     return drv->bdrv_snapshot_goto(bs, snapshot_id);
1149 }
1150
1151 int bdrv_snapshot_delete(BlockDriverState *bs, const char *snapshot_id)
1152 {
1153     BlockDriver *drv = bs->drv;
1154     if (!drv)
1155         return -ENOMEDIUM;
1156     if (!drv->bdrv_snapshot_delete)
1157         return -ENOTSUP;
1158     return drv->bdrv_snapshot_delete(bs, snapshot_id);
1159 }
1160
1161 int bdrv_snapshot_list(BlockDriverState *bs,
1162                        QEMUSnapshotInfo **psn_info)
1163 {
1164     BlockDriver *drv = bs->drv;
1165     if (!drv)
1166         return -ENOMEDIUM;
1167     if (!drv->bdrv_snapshot_list)
1168         return -ENOTSUP;
1169     return drv->bdrv_snapshot_list(bs, psn_info);
1170 }
1171
1172 #define NB_SUFFIXES 4
1173
1174 char *get_human_readable_size(char *buf, int buf_size, int64_t size)
1175 {
1176     static const char suffixes[NB_SUFFIXES] = "KMGT";
1177     int64_t base;
1178     int i;
1179
1180     if (size <= 999) {
1181         snprintf(buf, buf_size, "%" PRId64, size);
1182     } else {
1183         base = 1024;
1184         for(i = 0; i < NB_SUFFIXES; i++) {
1185             if (size < (10 * base)) {
1186                 snprintf(buf, buf_size, "%0.1f%c",
1187                          (double)size / base,
1188                          suffixes[i]);
1189                 break;
1190             } else if (size < (1000 * base) || i == (NB_SUFFIXES - 1)) {
1191                 snprintf(buf, buf_size, "%" PRId64 "%c",
1192                          ((size + (base >> 1)) / base),
1193                          suffixes[i]);
1194                 break;
1195             }
1196             base = base * 1024;
1197         }
1198     }
1199     return buf;
1200 }
1201
1202 char *bdrv_snapshot_dump(char *buf, int buf_size, QEMUSnapshotInfo *sn)
1203 {
1204     char buf1[128], date_buf[128], clock_buf[128];
1205 #ifdef _WIN32
1206     struct tm *ptm;
1207 #else
1208     struct tm tm;
1209 #endif
1210     time_t ti;
1211     int64_t secs;
1212
1213     if (!sn) {
1214         snprintf(buf, buf_size,
1215                  "%-10s%-20s%7s%20s%15s",
1216                  "ID", "TAG", "VM SIZE", "DATE", "VM CLOCK");
1217     } else {
1218         ti = sn->date_sec;
1219 #ifdef _WIN32
1220         ptm = localtime(&ti);
1221         strftime(date_buf, sizeof(date_buf),
1222                  "%Y-%m-%d %H:%M:%S", ptm);
1223 #else
1224         localtime_r(&ti, &tm);
1225         strftime(date_buf, sizeof(date_buf),
1226                  "%Y-%m-%d %H:%M:%S", &tm);
1227 #endif
1228         secs = sn->vm_clock_nsec / 1000000000;
1229         snprintf(clock_buf, sizeof(clock_buf),
1230                  "%02d:%02d:%02d.%03d",
1231                  (int)(secs / 3600),
1232                  (int)((secs / 60) % 60),
1233                  (int)(secs % 60),
1234                  (int)((sn->vm_clock_nsec / 1000000) % 1000));
1235         snprintf(buf, buf_size,
1236                  "%-10s%-20s%7s%20s%15s",
1237                  sn->id_str, sn->name,
1238                  get_human_readable_size(buf1, sizeof(buf1), sn->vm_state_size),
1239                  date_buf,
1240                  clock_buf);
1241     }
1242     return buf;
1243 }
1244
1245
1246 /**************************************************************/
1247 /* async I/Os */
1248
1249 BlockDriverAIOCB *bdrv_aio_read(BlockDriverState *bs, int64_t sector_num,
1250                                 uint8_t *buf, int nb_sectors,
1251                                 BlockDriverCompletionFunc *cb, void *opaque)
1252 {
1253     BlockDriver *drv = bs->drv;
1254     BlockDriverAIOCB *ret;
1255
1256     if (!drv)
1257         return NULL;
1258
1259     ret = drv->bdrv_aio_read(bs, sector_num, buf, nb_sectors, cb, opaque);
1260
1261     if (ret) {
1262         /* Update stats even though technically transfer has not happened. */
1263         bs->rd_bytes += (unsigned) nb_sectors * SECTOR_SIZE;
1264         bs->rd_ops ++;
1265     }
1266
1267     return ret;
1268 }
1269
1270 BlockDriverAIOCB *bdrv_aio_write(BlockDriverState *bs, int64_t sector_num,
1271                                  const uint8_t *buf, int nb_sectors,
1272                                  BlockDriverCompletionFunc *cb, void *opaque)
1273 {
1274     BlockDriver *drv = bs->drv;
1275     BlockDriverAIOCB *ret;
1276
1277     if (!drv)
1278         return NULL;
1279     if (bs->read_only)
1280         return NULL;
1281
1282     ret = drv->bdrv_aio_write(bs, sector_num, buf, nb_sectors, cb, opaque);
1283
1284     if (ret) {
1285         /* Update stats even though technically transfer has not happened. */
1286         bs->wr_bytes += (unsigned) nb_sectors * SECTOR_SIZE;
1287         bs->wr_ops ++;
1288     }
1289
1290     return ret;
1291 }
1292
1293 void bdrv_aio_cancel(BlockDriverAIOCB *acb)
1294 {
1295     BlockDriver *drv = acb->bs->drv;
1296
1297     drv->bdrv_aio_cancel(acb);
1298 }
1299
1300
1301 /**************************************************************/
1302 /* async block device emulation */
1303
1304 static void bdrv_aio_bh_cb(void *opaque)
1305 {
1306     BlockDriverAIOCBSync *acb = opaque;
1307     acb->common.cb(acb->common.opaque, acb->ret);
1308     qemu_aio_release(acb);
1309 }
1310
1311 static BlockDriverAIOCB *bdrv_aio_read_em(BlockDriverState *bs,
1312         int64_t sector_num, uint8_t *buf, int nb_sectors,
1313         BlockDriverCompletionFunc *cb, void *opaque)
1314 {
1315     BlockDriverAIOCBSync *acb;
1316     int ret;
1317
1318     acb = qemu_aio_get(bs, cb, opaque);
1319     if (!acb->bh)
1320         acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
1321     ret = bdrv_read(bs, sector_num, buf, nb_sectors);
1322     acb->ret = ret;
1323     qemu_bh_schedule(acb->bh);
1324     return &acb->common;
1325 }
1326
1327 static BlockDriverAIOCB *bdrv_aio_write_em(BlockDriverState *bs,
1328         int64_t sector_num, const uint8_t *buf, int nb_sectors,
1329         BlockDriverCompletionFunc *cb, void *opaque)
1330 {
1331     BlockDriverAIOCBSync *acb;
1332     int ret;
1333
1334     acb = qemu_aio_get(bs, cb, opaque);
1335     if (!acb->bh)
1336         acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
1337     ret = bdrv_write(bs, sector_num, buf, nb_sectors);
1338     acb->ret = ret;
1339     qemu_bh_schedule(acb->bh);
1340     return &acb->common;
1341 }
1342
1343 static void bdrv_aio_cancel_em(BlockDriverAIOCB *blockacb)
1344 {
1345     BlockDriverAIOCBSync *acb = (BlockDriverAIOCBSync *)blockacb;
1346     qemu_bh_cancel(acb->bh);
1347     qemu_aio_release(acb);
1348 }
1349
1350 /**************************************************************/
1351 /* sync block device emulation */
1352
1353 static void bdrv_rw_em_cb(void *opaque, int ret)
1354 {
1355     *(int *)opaque = ret;
1356 }
1357
1358 #define NOT_DONE 0x7fffffff
1359
1360 static int bdrv_read_em(BlockDriverState *bs, int64_t sector_num,
1361                         uint8_t *buf, int nb_sectors)
1362 {
1363     int async_ret;
1364     BlockDriverAIOCB *acb;
1365
1366     async_ret = NOT_DONE;
1367     acb = bdrv_aio_read(bs, sector_num, buf, nb_sectors,
1368                         bdrv_rw_em_cb, &async_ret);
1369     if (acb == NULL)
1370         return -1;
1371
1372     while (async_ret == NOT_DONE) {
1373         qemu_aio_wait();
1374     }
1375
1376     return async_ret;
1377 }
1378
1379 static int bdrv_write_em(BlockDriverState *bs, int64_t sector_num,
1380                          const uint8_t *buf, int nb_sectors)
1381 {
1382     int async_ret;
1383     BlockDriverAIOCB *acb;
1384
1385     async_ret = NOT_DONE;
1386     acb = bdrv_aio_write(bs, sector_num, buf, nb_sectors,
1387                          bdrv_rw_em_cb, &async_ret);
1388     if (acb == NULL)
1389         return -1;
1390     while (async_ret == NOT_DONE) {
1391         qemu_aio_wait();
1392     }
1393     return async_ret;
1394 }
1395
1396 void bdrv_init(void)
1397 {
1398     bdrv_register(&bdrv_raw);
1399     bdrv_register(&bdrv_host_device);
1400 #ifndef _WIN32
1401     bdrv_register(&bdrv_cow);
1402 #endif
1403     bdrv_register(&bdrv_qcow);
1404     bdrv_register(&bdrv_vmdk);
1405     bdrv_register(&bdrv_cloop);
1406     bdrv_register(&bdrv_dmg);
1407     bdrv_register(&bdrv_bochs);
1408     bdrv_register(&bdrv_vpc);
1409     bdrv_register(&bdrv_vvfat);
1410     bdrv_register(&bdrv_qcow2);
1411     bdrv_register(&bdrv_parallels);
1412     bdrv_register(&bdrv_nbd);
1413 }
1414
1415 void *qemu_aio_get(BlockDriverState *bs, BlockDriverCompletionFunc *cb,
1416                    void *opaque)
1417 {
1418     BlockDriver *drv;
1419     BlockDriverAIOCB *acb;
1420
1421     drv = bs->drv;
1422     if (drv->free_aiocb) {
1423         acb = drv->free_aiocb;
1424         drv->free_aiocb = acb->next;
1425     } else {
1426         acb = qemu_mallocz(drv->aiocb_size);
1427         if (!acb)
1428             return NULL;
1429     }
1430     acb->bs = bs;
1431     acb->cb = cb;
1432     acb->opaque = opaque;
1433     return acb;
1434 }
1435
1436 void qemu_aio_release(void *p)
1437 {
1438     BlockDriverAIOCB *acb = p;
1439     BlockDriver *drv = acb->bs->drv;
1440     acb->next = drv->free_aiocb;
1441     drv->free_aiocb = acb;
1442 }
1443
1444 /**************************************************************/
1445 /* removable device support */
1446
1447 /**
1448  * Return TRUE if the media is present
1449  */
1450 int bdrv_is_inserted(BlockDriverState *bs)
1451 {
1452     BlockDriver *drv = bs->drv;
1453     int ret;
1454     if (!drv)
1455         return 0;
1456     if (!drv->bdrv_is_inserted)
1457         return 1;
1458     ret = drv->bdrv_is_inserted(bs);
1459     return ret;
1460 }
1461
1462 /**
1463  * Return TRUE if the media changed since the last call to this
1464  * function. It is currently only used for floppy disks
1465  */
1466 int bdrv_media_changed(BlockDriverState *bs)
1467 {
1468     BlockDriver *drv = bs->drv;
1469     int ret;
1470
1471     if (!drv || !drv->bdrv_media_changed)
1472         ret = -ENOTSUP;
1473     else
1474         ret = drv->bdrv_media_changed(bs);
1475     if (ret == -ENOTSUP)
1476         ret = bs->media_changed;
1477     bs->media_changed = 0;
1478     return ret;
1479 }
1480
1481 /**
1482  * If eject_flag is TRUE, eject the media. Otherwise, close the tray
1483  */
1484 void bdrv_eject(BlockDriverState *bs, int eject_flag)
1485 {
1486     BlockDriver *drv = bs->drv;
1487     int ret;
1488
1489     if (!drv || !drv->bdrv_eject) {
1490         ret = -ENOTSUP;
1491     } else {
1492         ret = drv->bdrv_eject(bs, eject_flag);
1493     }
1494     if (ret == -ENOTSUP) {
1495         if (eject_flag)
1496             bdrv_close(bs);
1497     }
1498 }
1499
1500 int bdrv_is_locked(BlockDriverState *bs)
1501 {
1502     return bs->locked;
1503 }
1504
1505 /**
1506  * Lock or unlock the media (if it is locked, the user won't be able
1507  * to eject it manually).
1508  */
1509 void bdrv_set_locked(BlockDriverState *bs, int locked)
1510 {
1511     BlockDriver *drv = bs->drv;
1512
1513     bs->locked = locked;
1514     if (drv && drv->bdrv_set_locked) {
1515         drv->bdrv_set_locked(bs, locked);
1516     }
1517 }
1518
1519 /* needed for generic scsi interface */
1520
1521 int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
1522 {
1523     BlockDriver *drv = bs->drv;
1524
1525     if (drv && drv->bdrv_ioctl)
1526         return drv->bdrv_ioctl(bs, req, buf);
1527     return -ENOTSUP;
1528 }