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/osdep.h"
25 #include "qapi/error.h"
26 #include "qemu-common.h"
27 #include "block/block_int.h"
28 #include "qemu/module.h"
31 /* Maximum compressed block size */
32 #define MAX_BLOCK_SIZE (64 * 1024 * 1024)
34 typedef struct BDRVCloopState
{
39 uint32_t sectors_per_block
;
40 uint32_t current_block
;
41 uint8_t *compressed_block
;
42 uint8_t *uncompressed_block
;
46 static int cloop_probe(const uint8_t *buf
, int buf_size
, const char *filename
)
48 const char *magic_version_2_0
= "#!/bin/sh\n"
50 "modprobe cloop file=$0 && mount -r -t iso9660 /dev/cloop $1\n";
51 int length
= strlen(magic_version_2_0
);
52 if (length
> buf_size
) {
55 if (!memcmp(magic_version_2_0
, buf
, length
)) {
61 static int cloop_open(BlockDriverState
*bs
, QDict
*options
, int flags
,
64 BDRVCloopState
*s
= bs
->opaque
;
65 uint32_t offsets_size
, max_compressed_block_size
= 1, i
;
71 ret
= bdrv_pread(bs
->file
->bs
, 128, &s
->block_size
, 4);
75 s
->block_size
= be32_to_cpu(s
->block_size
);
76 if (s
->block_size
% 512) {
77 error_setg(errp
, "block_size %" PRIu32
" must be a multiple of 512",
81 if (s
->block_size
== 0) {
82 error_setg(errp
, "block_size cannot be zero");
86 /* cloop's create_compressed_fs.c warns about block sizes beyond 256 KB but
87 * we can accept more. Prevent ridiculous values like 4 GB - 1 since we
88 * need a buffer this big.
90 if (s
->block_size
> MAX_BLOCK_SIZE
) {
91 error_setg(errp
, "block_size %" PRIu32
" must be %u MB or less",
93 MAX_BLOCK_SIZE
/ (1024 * 1024));
97 ret
= bdrv_pread(bs
->file
->bs
, 128 + 4, &s
->n_blocks
, 4);
101 s
->n_blocks
= be32_to_cpu(s
->n_blocks
);
104 if (s
->n_blocks
> (UINT32_MAX
- 1) / sizeof(uint64_t)) {
105 /* Prevent integer overflow */
106 error_setg(errp
, "n_blocks %" PRIu32
" must be %zu or less",
108 (UINT32_MAX
- 1) / sizeof(uint64_t));
111 offsets_size
= (s
->n_blocks
+ 1) * sizeof(uint64_t);
112 if (offsets_size
> 512 * 1024 * 1024) {
113 /* Prevent ridiculous offsets_size which causes memory allocation to
114 * fail or overflows bdrv_pread() size. In practice the 512 MB
115 * offsets[] limit supports 16 TB images at 256 KB block size.
117 error_setg(errp
, "image requires too many offsets, "
118 "try increasing block size");
122 s
->offsets
= g_try_malloc(offsets_size
);
123 if (s
->offsets
== NULL
) {
124 error_setg(errp
, "Could not allocate offsets table");
128 ret
= bdrv_pread(bs
->file
->bs
, 128 + 4 + 4, s
->offsets
, offsets_size
);
133 for (i
= 0; i
< s
->n_blocks
+ 1; i
++) {
136 s
->offsets
[i
] = be64_to_cpu(s
->offsets
[i
]);
141 if (s
->offsets
[i
] < s
->offsets
[i
- 1]) {
142 error_setg(errp
, "offsets not monotonically increasing at "
143 "index %" PRIu32
", image file is corrupt", i
);
148 size
= s
->offsets
[i
] - s
->offsets
[i
- 1];
150 /* Compressed blocks should be smaller than the uncompressed block size
151 * but maybe compression performed poorly so the compressed block is
152 * actually bigger. Clamp down on unrealistic values to prevent
153 * ridiculous s->compressed_block allocation.
155 if (size
> 2 * MAX_BLOCK_SIZE
) {
156 error_setg(errp
, "invalid compressed block size at index %" PRIu32
157 ", image file is corrupt", i
);
162 if (size
> max_compressed_block_size
) {
163 max_compressed_block_size
= size
;
167 /* initialize zlib engine */
168 s
->compressed_block
= g_try_malloc(max_compressed_block_size
+ 1);
169 if (s
->compressed_block
== NULL
) {
170 error_setg(errp
, "Could not allocate compressed_block");
175 s
->uncompressed_block
= g_try_malloc(s
->block_size
);
176 if (s
->uncompressed_block
== NULL
) {
177 error_setg(errp
, "Could not allocate uncompressed_block");
182 if (inflateInit(&s
->zstream
) != Z_OK
) {
186 s
->current_block
= s
->n_blocks
;
188 s
->sectors_per_block
= s
->block_size
/512;
189 bs
->total_sectors
= s
->n_blocks
* s
->sectors_per_block
;
190 qemu_co_mutex_init(&s
->lock
);
195 g_free(s
->compressed_block
);
196 g_free(s
->uncompressed_block
);
200 static inline int cloop_read_block(BlockDriverState
*bs
, int block_num
)
202 BDRVCloopState
*s
= bs
->opaque
;
204 if (s
->current_block
!= block_num
) {
206 uint32_t bytes
= s
->offsets
[block_num
+ 1] - s
->offsets
[block_num
];
208 ret
= bdrv_pread(bs
->file
->bs
, s
->offsets
[block_num
],
209 s
->compressed_block
, bytes
);
214 s
->zstream
.next_in
= s
->compressed_block
;
215 s
->zstream
.avail_in
= bytes
;
216 s
->zstream
.next_out
= s
->uncompressed_block
;
217 s
->zstream
.avail_out
= s
->block_size
;
218 ret
= inflateReset(&s
->zstream
);
222 ret
= inflate(&s
->zstream
, Z_FINISH
);
223 if (ret
!= Z_STREAM_END
|| s
->zstream
.total_out
!= s
->block_size
) {
227 s
->current_block
= block_num
;
232 static int cloop_read(BlockDriverState
*bs
, int64_t sector_num
,
233 uint8_t *buf
, int nb_sectors
)
235 BDRVCloopState
*s
= bs
->opaque
;
238 for (i
= 0; i
< nb_sectors
; i
++) {
239 uint32_t sector_offset_in_block
=
240 ((sector_num
+ i
) % s
->sectors_per_block
),
241 block_num
= (sector_num
+ i
) / s
->sectors_per_block
;
242 if (cloop_read_block(bs
, block_num
) != 0) {
245 memcpy(buf
+ i
* 512,
246 s
->uncompressed_block
+ sector_offset_in_block
* 512, 512);
251 static coroutine_fn
int cloop_co_read(BlockDriverState
*bs
, int64_t sector_num
,
252 uint8_t *buf
, int nb_sectors
)
255 BDRVCloopState
*s
= bs
->opaque
;
256 qemu_co_mutex_lock(&s
->lock
);
257 ret
= cloop_read(bs
, sector_num
, buf
, nb_sectors
);
258 qemu_co_mutex_unlock(&s
->lock
);
262 static void cloop_close(BlockDriverState
*bs
)
264 BDRVCloopState
*s
= bs
->opaque
;
266 g_free(s
->compressed_block
);
267 g_free(s
->uncompressed_block
);
268 inflateEnd(&s
->zstream
);
271 static BlockDriver bdrv_cloop
= {
272 .format_name
= "cloop",
273 .instance_size
= sizeof(BDRVCloopState
),
274 .bdrv_probe
= cloop_probe
,
275 .bdrv_open
= cloop_open
,
276 .bdrv_read
= cloop_co_read
,
277 .bdrv_close
= cloop_close
,
280 static void bdrv_cloop_init(void)
282 bdrv_register(&bdrv_cloop
);
285 block_init(bdrv_cloop_init
);