]>
git.proxmox.com Git - mirror_qemu.git/blob - block.c
2 * QEMU System Emulator block driver
4 * Copyright (c) 2003 Fabrice Bellard
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:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
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
25 #include "block_int.h"
28 #include <sys/types.h>
30 #include <sys/ioctl.h>
31 #include <sys/queue.h>
35 static BlockDriverState
*bdrv_first
;
36 static BlockDriver
*first_drv
;
38 void bdrv_register(BlockDriver
*bdrv
)
40 bdrv
->next
= first_drv
;
44 /* create a new block device (by default it is empty) */
45 BlockDriverState
*bdrv_new(const char *device_name
)
47 BlockDriverState
**pbs
, *bs
;
49 bs
= qemu_mallocz(sizeof(BlockDriverState
));
52 pstrcpy(bs
->device_name
, sizeof(bs
->device_name
), device_name
);
53 if (device_name
[0] != '\0') {
54 /* insert at the end */
63 BlockDriver
*bdrv_find_format(const char *format_name
)
66 for(drv1
= first_drv
; drv1
!= NULL
; drv1
= drv1
->next
) {
67 if (!strcmp(drv1
->format_name
, format_name
))
73 int bdrv_create(BlockDriver
*drv
,
74 const char *filename
, int64_t size_in_sectors
,
75 const char *backing_file
, int flags
)
77 if (!drv
->bdrv_create
)
79 return drv
->bdrv_create(filename
, size_in_sectors
, backing_file
, flags
);
83 static void get_tmp_filename(char *filename
, int size
)
85 /* XXX: find a better function */
89 static void get_tmp_filename(char *filename
, int size
)
92 /* XXX: race condition possible */
93 pstrcpy(filename
, size
, "/tmp/vl.XXXXXX");
94 fd
= mkstemp(filename
);
99 /* XXX: force raw format if block or character device ? It would
100 simplify the BSD case */
101 static BlockDriver
*find_image_format(const char *filename
)
103 int fd
, ret
, score
, score_max
;
104 BlockDriver
*drv1
, *drv
;
106 size_t bufsize
= 1024;
108 fd
= open(filename
, O_RDONLY
| O_BINARY
| O_LARGEFILE
);
113 #ifdef DIOCGSECTORSIZE
115 unsigned int sectorsize
= 512;
116 if (!ioctl(fd
, DIOCGSECTORSIZE
, §orsize
) &&
117 sectorsize
> bufsize
)
118 bufsize
= sectorsize
;
121 buf
= qemu_malloc(bufsize
);
124 ret
= read(fd
, buf
, bufsize
);
135 for(drv1
= first_drv
; drv1
!= NULL
; drv1
= drv1
->next
) {
136 score
= drv1
->bdrv_probe(buf
, ret
, filename
);
137 if (score
> score_max
) {
146 int bdrv_open(BlockDriverState
*bs
, const char *filename
, int snapshot
)
148 return bdrv_open2(bs
, filename
, snapshot
, NULL
);
151 int bdrv_open2(BlockDriverState
*bs
, const char *filename
, int snapshot
,
155 char tmp_filename
[1024];
158 bs
->is_temporary
= 0;
162 BlockDriverState
*bs1
;
165 /* if snapshot, we create a temporary backing file and open it
166 instead of opening 'filename' directly */
168 /* if there is a backing file, use it */
173 if (bdrv_open(bs1
, filename
, 0) < 0) {
177 total_size
= bs1
->total_sectors
;
180 get_tmp_filename(tmp_filename
, sizeof(tmp_filename
));
181 /* XXX: use cow for linux as it is more efficient ? */
182 if (bdrv_create(&bdrv_qcow
, tmp_filename
,
183 total_size
, filename
, 0) < 0) {
186 filename
= tmp_filename
;
187 bs
->is_temporary
= 1;
190 pstrcpy(bs
->filename
, sizeof(bs
->filename
), filename
);
192 drv
= find_image_format(filename
);
197 bs
->opaque
= qemu_mallocz(drv
->instance_size
);
198 if (bs
->opaque
== NULL
&& drv
->instance_size
> 0)
201 ret
= drv
->bdrv_open(bs
, filename
);
203 qemu_free(bs
->opaque
);
207 if (bs
->is_temporary
) {
211 if (bs
->backing_file
[0] != '\0' && drv
->bdrv_is_allocated
) {
212 /* if there is a backing file, use it */
213 bs
->backing_hd
= bdrv_new("");
214 if (!bs
->backing_hd
) {
219 if (bdrv_open(bs
->backing_hd
, bs
->backing_file
, 0) < 0)
225 /* call the change callback */
227 bs
->change_cb(bs
->change_opaque
);
232 void bdrv_close(BlockDriverState
*bs
)
236 bdrv_delete(bs
->backing_hd
);
237 bs
->drv
->bdrv_close(bs
);
238 qemu_free(bs
->opaque
);
240 if (bs
->is_temporary
) {
241 unlink(bs
->filename
);
248 /* call the change callback */
250 bs
->change_cb(bs
->change_opaque
);
254 void bdrv_delete(BlockDriverState
*bs
)
256 /* XXX: remove the driver list */
261 /* commit COW file into the raw image */
262 int bdrv_commit(BlockDriverState
*bs
)
266 unsigned char sector
[512];
275 if (!bs
->backing_hd
) {
279 for (i
= 0; i
< bs
->total_sectors
;) {
280 if (bs
->drv
->bdrv_is_allocated(bs
, i
, 65536, &n
)) {
281 for(j
= 0; j
< n
; j
++) {
282 if (bdrv_read(bs
, i
, sector
, 1) != 0) {
286 if (bdrv_write(bs
->backing_hd
, i
, sector
, 1) != 0) {
298 /* return -1 if error */
299 int bdrv_read(BlockDriverState
*bs
, int64_t sector_num
,
300 uint8_t *buf
, int nb_sectors
)
303 BlockDriver
*drv
= bs
->drv
;
308 while (nb_sectors
> 0) {
309 if (sector_num
== 0 && bs
->boot_sector_enabled
) {
310 memcpy(buf
, bs
->boot_sector_data
, 512);
312 } else if (bs
->backing_hd
) {
313 if (drv
->bdrv_is_allocated(bs
, sector_num
, nb_sectors
, &n
)) {
314 ret
= drv
->bdrv_read(bs
, sector_num
, buf
, n
);
318 /* read from the base image */
319 ret
= bdrv_read(bs
->backing_hd
, sector_num
, buf
, n
);
324 ret
= drv
->bdrv_read(bs
, sector_num
, buf
, nb_sectors
);
327 /* no need to loop */
337 /* return -1 if error */
338 int bdrv_write(BlockDriverState
*bs
, int64_t sector_num
,
339 const uint8_t *buf
, int nb_sectors
)
345 return bs
->drv
->bdrv_write(bs
, sector_num
, buf
, nb_sectors
);
348 void bdrv_get_geometry(BlockDriverState
*bs
, int64_t *nb_sectors_ptr
)
350 *nb_sectors_ptr
= bs
->total_sectors
;
353 /* force a given boot sector. */
354 void bdrv_set_boot_sector(BlockDriverState
*bs
, const uint8_t *data
, int size
)
356 bs
->boot_sector_enabled
= 1;
359 memcpy(bs
->boot_sector_data
, data
, size
);
360 memset(bs
->boot_sector_data
+ size
, 0, 512 - size
);
363 void bdrv_set_geometry_hint(BlockDriverState
*bs
,
364 int cyls
, int heads
, int secs
)
371 void bdrv_set_type_hint(BlockDriverState
*bs
, int type
)
374 bs
->removable
= ((type
== BDRV_TYPE_CDROM
||
375 type
== BDRV_TYPE_FLOPPY
));
378 void bdrv_set_translation_hint(BlockDriverState
*bs
, int translation
)
380 bs
->translation
= translation
;
383 void bdrv_get_geometry_hint(BlockDriverState
*bs
,
384 int *pcyls
, int *pheads
, int *psecs
)
391 int bdrv_get_type_hint(BlockDriverState
*bs
)
396 int bdrv_get_translation_hint(BlockDriverState
*bs
)
398 return bs
->translation
;
401 int bdrv_is_removable(BlockDriverState
*bs
)
403 return bs
->removable
;
406 int bdrv_is_read_only(BlockDriverState
*bs
)
408 return bs
->read_only
;
411 int bdrv_is_inserted(BlockDriverState
*bs
)
416 int bdrv_is_locked(BlockDriverState
*bs
)
421 void bdrv_set_locked(BlockDriverState
*bs
, int locked
)
426 void bdrv_set_change_cb(BlockDriverState
*bs
,
427 void (*change_cb
)(void *opaque
), void *opaque
)
429 bs
->change_cb
= change_cb
;
430 bs
->change_opaque
= opaque
;
433 int bdrv_is_encrypted(BlockDriverState
*bs
)
435 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
)
437 return bs
->encrypted
;
440 int bdrv_set_key(BlockDriverState
*bs
, const char *key
)
443 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
) {
444 ret
= bdrv_set_key(bs
->backing_hd
, key
);
450 if (!bs
->encrypted
|| !bs
->drv
|| !bs
->drv
->bdrv_set_key
)
452 return bs
->drv
->bdrv_set_key(bs
, key
);
455 void bdrv_get_format(BlockDriverState
*bs
, char *buf
, int buf_size
)
457 if (!bs
->inserted
|| !bs
->drv
) {
460 pstrcpy(buf
, buf_size
, bs
->drv
->format_name
);
464 void bdrv_iterate_format(void (*it
)(void *opaque
, const char *name
),
469 for (drv
= first_drv
; drv
!= NULL
; drv
= drv
->next
) {
470 it(opaque
, drv
->format_name
);
474 BlockDriverState
*bdrv_find(const char *name
)
476 BlockDriverState
*bs
;
478 for (bs
= bdrv_first
; bs
!= NULL
; bs
= bs
->next
) {
479 if (!strcmp(name
, bs
->device_name
))
485 void bdrv_iterate(void (*it
)(void *opaque
, const char *name
), void *opaque
)
487 BlockDriverState
*bs
;
489 for (bs
= bdrv_first
; bs
!= NULL
; bs
= bs
->next
) {
490 it(opaque
, bs
->device_name
);
494 const char *bdrv_get_device_name(BlockDriverState
*bs
)
496 return bs
->device_name
;
501 BlockDriverState
*bs
;
503 for (bs
= bdrv_first
; bs
!= NULL
; bs
= bs
->next
) {
504 term_printf("%s:", bs
->device_name
);
505 term_printf(" type=");
510 case BDRV_TYPE_CDROM
:
511 term_printf("cdrom");
513 case BDRV_TYPE_FLOPPY
:
514 term_printf("floppy");
517 term_printf(" removable=%d", bs
->removable
);
519 term_printf(" locked=%d", bs
->locked
);
522 term_printf(" file=%s", bs
->filename
);
523 if (bs
->backing_file
[0] != '\0')
524 term_printf(" backing_file=%s", bs
->backing_file
);
525 term_printf(" ro=%d", bs
->read_only
);
526 term_printf(" drv=%s", bs
->drv
->format_name
);
528 term_printf(" encrypted");
530 term_printf(" [not inserted]");
537 /**************************************************************/
538 /* RAW block driver */
540 typedef struct BDRVRawState
{
544 static int raw_probe(const uint8_t *buf
, int buf_size
, const char *filename
)
546 return 1; /* maybe */
549 static int raw_open(BlockDriverState
*bs
, const char *filename
)
551 BDRVRawState
*s
= bs
->opaque
;
558 fd
= open(filename
, O_RDWR
| O_BINARY
| O_LARGEFILE
);
560 fd
= open(filename
, O_RDONLY
| O_BINARY
| O_LARGEFILE
);
566 if (!fstat(fd
, &sb
) && (S_IFCHR
& sb
.st_mode
)) {
567 #ifdef DIOCGMEDIASIZE
568 if (ioctl(fd
, DIOCGMEDIASIZE
, (off_t
*)&size
))
570 size
= lseek(fd
, 0LL, SEEK_END
);
574 size
= lseek(fd
, 0, SEEK_END
);
577 /* On Windows hosts it can happen that we're unable to get file size
578 for CD-ROM raw device (it's inherent limitation of the CDFS driver). */
580 size
= LONG_LONG_MAX
;
582 bs
->total_sectors
= size
/ 512;
587 static int raw_read(BlockDriverState
*bs
, int64_t sector_num
,
588 uint8_t *buf
, int nb_sectors
)
590 BDRVRawState
*s
= bs
->opaque
;
593 lseek(s
->fd
, sector_num
* 512, SEEK_SET
);
594 ret
= read(s
->fd
, buf
, nb_sectors
* 512);
595 if (ret
!= nb_sectors
* 512)
600 static int raw_write(BlockDriverState
*bs
, int64_t sector_num
,
601 const uint8_t *buf
, int nb_sectors
)
603 BDRVRawState
*s
= bs
->opaque
;
606 lseek(s
->fd
, sector_num
* 512, SEEK_SET
);
607 ret
= write(s
->fd
, buf
, nb_sectors
* 512);
608 if (ret
!= nb_sectors
* 512)
613 static void raw_close(BlockDriverState
*bs
)
615 BDRVRawState
*s
= bs
->opaque
;
619 static int raw_create(const char *filename
, int64_t total_size
,
620 const char *backing_file
, int flags
)
624 if (flags
|| backing_file
)
627 fd
= open(filename
, O_WRONLY
| O_CREAT
| O_TRUNC
| O_BINARY
| O_LARGEFILE
,
631 ftruncate(fd
, total_size
* 512);
636 BlockDriver bdrv_raw
= {
638 sizeof(BDRVRawState
),
649 bdrv_register(&bdrv_raw
);
651 bdrv_register(&bdrv_cow
);
653 bdrv_register(&bdrv_qcow
);
654 bdrv_register(&bdrv_vmdk
);
655 bdrv_register(&bdrv_cloop
);
656 bdrv_register(&bdrv_dmg
);
657 bdrv_register(&bdrv_bochs
);
658 bdrv_register(&bdrv_vpc
);
659 bdrv_register(&bdrv_vvfat
);