2 * QEMU Block driver for CLOOP images
4 * Copyright (c) 2004 Johannes E. Schindelin
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
24 #include "qemu-common.h"
25 #include "block_int.h"
29 typedef struct BDRVCloopState
{
34 uint32_t sectors_per_block
;
35 uint32_t current_block
;
36 uint8_t *compressed_block
;
37 uint8_t *uncompressed_block
;
41 static int cloop_probe(const uint8_t *buf
, int buf_size
, const char *filename
)
43 const char* magic_version_2_0
="#!/bin/sh\n"
45 "modprobe cloop file=$0 && mount -r -t iso9660 /dev/cloop $1\n";
46 int length
=strlen(magic_version_2_0
);
49 if(!memcmp(magic_version_2_0
,buf
,length
))
54 static int cloop_open(BlockDriverState
*bs
, int flags
)
56 BDRVCloopState
*s
= bs
->opaque
;
57 uint32_t offsets_size
,max_compressed_block_size
=1,i
;
62 if (bdrv_pread(bs
->file
, 128, &s
->block_size
, 4) < 4) {
65 s
->block_size
= be32_to_cpu(s
->block_size
);
67 if (bdrv_pread(bs
->file
, 128 + 4, &s
->n_blocks
, 4) < 4) {
70 s
->n_blocks
= be32_to_cpu(s
->n_blocks
);
73 offsets_size
= s
->n_blocks
* sizeof(uint64_t);
74 s
->offsets
= g_malloc(offsets_size
);
75 if (bdrv_pread(bs
->file
, 128 + 4 + 4, s
->offsets
, offsets_size
) <
79 for(i
=0;i
<s
->n_blocks
;i
++) {
80 s
->offsets
[i
]=be64_to_cpu(s
->offsets
[i
]);
82 uint32_t size
=s
->offsets
[i
]-s
->offsets
[i
-1];
83 if(size
>max_compressed_block_size
)
84 max_compressed_block_size
=size
;
88 /* initialize zlib engine */
89 s
->compressed_block
= g_malloc(max_compressed_block_size
+1);
90 s
->uncompressed_block
= g_malloc(s
->block_size
);
91 if(inflateInit(&s
->zstream
) != Z_OK
)
93 s
->current_block
=s
->n_blocks
;
95 s
->sectors_per_block
= s
->block_size
/512;
96 bs
->total_sectors
= s
->n_blocks
*s
->sectors_per_block
;
97 qemu_co_mutex_init(&s
->lock
);
104 static inline int cloop_read_block(BlockDriverState
*bs
, int block_num
)
106 BDRVCloopState
*s
= bs
->opaque
;
108 if(s
->current_block
!= block_num
) {
110 uint32_t bytes
= s
->offsets
[block_num
+1]-s
->offsets
[block_num
];
112 ret
= bdrv_pread(bs
->file
, s
->offsets
[block_num
], s
->compressed_block
,
117 s
->zstream
.next_in
= s
->compressed_block
;
118 s
->zstream
.avail_in
= bytes
;
119 s
->zstream
.next_out
= s
->uncompressed_block
;
120 s
->zstream
.avail_out
= s
->block_size
;
121 ret
= inflateReset(&s
->zstream
);
124 ret
= inflate(&s
->zstream
, Z_FINISH
);
125 if(ret
!= Z_STREAM_END
|| s
->zstream
.total_out
!= s
->block_size
)
128 s
->current_block
= block_num
;
133 static int cloop_read(BlockDriverState
*bs
, int64_t sector_num
,
134 uint8_t *buf
, int nb_sectors
)
136 BDRVCloopState
*s
= bs
->opaque
;
139 for(i
=0;i
<nb_sectors
;i
++) {
140 uint32_t sector_offset_in_block
=((sector_num
+i
)%s
->sectors_per_block
),
141 block_num
=(sector_num
+i
)/s
->sectors_per_block
;
142 if(cloop_read_block(bs
, block_num
) != 0)
144 memcpy(buf
+i
*512,s
->uncompressed_block
+sector_offset_in_block
*512,512);
149 static coroutine_fn
int cloop_co_read(BlockDriverState
*bs
, int64_t sector_num
,
150 uint8_t *buf
, int nb_sectors
)
153 BDRVCloopState
*s
= bs
->opaque
;
154 qemu_co_mutex_lock(&s
->lock
);
155 ret
= cloop_read(bs
, sector_num
, buf
, nb_sectors
);
156 qemu_co_mutex_unlock(&s
->lock
);
160 static void cloop_close(BlockDriverState
*bs
)
162 BDRVCloopState
*s
= bs
->opaque
;
165 free(s
->compressed_block
);
166 free(s
->uncompressed_block
);
167 inflateEnd(&s
->zstream
);
170 static BlockDriver bdrv_cloop
= {
171 .format_name
= "cloop",
172 .instance_size
= sizeof(BDRVCloopState
),
173 .bdrv_probe
= cloop_probe
,
174 .bdrv_open
= cloop_open
,
175 .bdrv_read
= cloop_co_read
,
176 .bdrv_close
= cloop_close
,
179 static void bdrv_cloop_init(void)
181 bdrv_register(&bdrv_cloop
);
184 block_init(bdrv_cloop_init
);