Added license information
[kvmfornfv.git] / qemu / block / cloop.c
1 /*
2  * QEMU Block driver for CLOOP images
3  *
4  * Copyright (c) 2004 Johannes E. Schindelin
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 "qemu-common.h"
25 #include "block/block_int.h"
26 #include "qemu/module.h"
27 #include <zlib.h>
28
29 /* Maximum compressed block size */
30 #define MAX_BLOCK_SIZE (64 * 1024 * 1024)
31
32 typedef struct BDRVCloopState {
33     CoMutex lock;
34     uint32_t block_size;
35     uint32_t n_blocks;
36     uint64_t *offsets;
37     uint32_t sectors_per_block;
38     uint32_t current_block;
39     uint8_t *compressed_block;
40     uint8_t *uncompressed_block;
41     z_stream zstream;
42 } BDRVCloopState;
43
44 static int cloop_probe(const uint8_t *buf, int buf_size, const char *filename)
45 {
46     const char *magic_version_2_0 = "#!/bin/sh\n"
47         "#V2.0 Format\n"
48         "modprobe cloop file=$0 && mount -r -t iso9660 /dev/cloop $1\n";
49     int length = strlen(magic_version_2_0);
50     if (length > buf_size) {
51         length = buf_size;
52     }
53     if (!memcmp(magic_version_2_0, buf, length)) {
54         return 2;
55     }
56     return 0;
57 }
58
59 static int cloop_open(BlockDriverState *bs, QDict *options, int flags,
60                       Error **errp)
61 {
62     BDRVCloopState *s = bs->opaque;
63     uint32_t offsets_size, max_compressed_block_size = 1, i;
64     int ret;
65
66     bs->read_only = 1;
67
68     /* read header */
69     ret = bdrv_pread(bs->file, 128, &s->block_size, 4);
70     if (ret < 0) {
71         return ret;
72     }
73     s->block_size = be32_to_cpu(s->block_size);
74     if (s->block_size % 512) {
75         error_setg(errp, "block_size %" PRIu32 " must be a multiple of 512",
76                    s->block_size);
77         return -EINVAL;
78     }
79     if (s->block_size == 0) {
80         error_setg(errp, "block_size cannot be zero");
81         return -EINVAL;
82     }
83
84     /* cloop's create_compressed_fs.c warns about block sizes beyond 256 KB but
85      * we can accept more.  Prevent ridiculous values like 4 GB - 1 since we
86      * need a buffer this big.
87      */
88     if (s->block_size > MAX_BLOCK_SIZE) {
89         error_setg(errp, "block_size %" PRIu32 " must be %u MB or less",
90                    s->block_size,
91                    MAX_BLOCK_SIZE / (1024 * 1024));
92         return -EINVAL;
93     }
94
95     ret = bdrv_pread(bs->file, 128 + 4, &s->n_blocks, 4);
96     if (ret < 0) {
97         return ret;
98     }
99     s->n_blocks = be32_to_cpu(s->n_blocks);
100
101     /* read offsets */
102     if (s->n_blocks > (UINT32_MAX - 1) / sizeof(uint64_t)) {
103         /* Prevent integer overflow */
104         error_setg(errp, "n_blocks %" PRIu32 " must be %zu or less",
105                    s->n_blocks,
106                    (UINT32_MAX - 1) / sizeof(uint64_t));
107         return -EINVAL;
108     }
109     offsets_size = (s->n_blocks + 1) * sizeof(uint64_t);
110     if (offsets_size > 512 * 1024 * 1024) {
111         /* Prevent ridiculous offsets_size which causes memory allocation to
112          * fail or overflows bdrv_pread() size.  In practice the 512 MB
113          * offsets[] limit supports 16 TB images at 256 KB block size.
114          */
115         error_setg(errp, "image requires too many offsets, "
116                    "try increasing block size");
117         return -EINVAL;
118     }
119
120     s->offsets = g_try_malloc(offsets_size);
121     if (s->offsets == NULL) {
122         error_setg(errp, "Could not allocate offsets table");
123         return -ENOMEM;
124     }
125
126     ret = bdrv_pread(bs->file, 128 + 4 + 4, s->offsets, offsets_size);
127     if (ret < 0) {
128         goto fail;
129     }
130
131     for (i = 0; i < s->n_blocks + 1; i++) {
132         uint64_t size;
133
134         s->offsets[i] = be64_to_cpu(s->offsets[i]);
135         if (i == 0) {
136             continue;
137         }
138
139         if (s->offsets[i] < s->offsets[i - 1]) {
140             error_setg(errp, "offsets not monotonically increasing at "
141                        "index %" PRIu32 ", image file is corrupt", i);
142             ret = -EINVAL;
143             goto fail;
144         }
145
146         size = s->offsets[i] - s->offsets[i - 1];
147
148         /* Compressed blocks should be smaller than the uncompressed block size
149          * but maybe compression performed poorly so the compressed block is
150          * actually bigger.  Clamp down on unrealistic values to prevent
151          * ridiculous s->compressed_block allocation.
152          */
153         if (size > 2 * MAX_BLOCK_SIZE) {
154             error_setg(errp, "invalid compressed block size at index %" PRIu32
155                        ", image file is corrupt", i);
156             ret = -EINVAL;
157             goto fail;
158         }
159
160         if (size > max_compressed_block_size) {
161             max_compressed_block_size = size;
162         }
163     }
164
165     /* initialize zlib engine */
166     s->compressed_block = g_try_malloc(max_compressed_block_size + 1);
167     if (s->compressed_block == NULL) {
168         error_setg(errp, "Could not allocate compressed_block");
169         ret = -ENOMEM;
170         goto fail;
171     }
172
173     s->uncompressed_block = g_try_malloc(s->block_size);
174     if (s->uncompressed_block == NULL) {
175         error_setg(errp, "Could not allocate uncompressed_block");
176         ret = -ENOMEM;
177         goto fail;
178     }
179
180     if (inflateInit(&s->zstream) != Z_OK) {
181         ret = -EINVAL;
182         goto fail;
183     }
184     s->current_block = s->n_blocks;
185
186     s->sectors_per_block = s->block_size/512;
187     bs->total_sectors = s->n_blocks * s->sectors_per_block;
188     qemu_co_mutex_init(&s->lock);
189     return 0;
190
191 fail:
192     g_free(s->offsets);
193     g_free(s->compressed_block);
194     g_free(s->uncompressed_block);
195     return ret;
196 }
197
198 static inline int cloop_read_block(BlockDriverState *bs, int block_num)
199 {
200     BDRVCloopState *s = bs->opaque;
201
202     if (s->current_block != block_num) {
203         int ret;
204         uint32_t bytes = s->offsets[block_num + 1] - s->offsets[block_num];
205
206         ret = bdrv_pread(bs->file, s->offsets[block_num], s->compressed_block,
207                          bytes);
208         if (ret != bytes) {
209             return -1;
210         }
211
212         s->zstream.next_in = s->compressed_block;
213         s->zstream.avail_in = bytes;
214         s->zstream.next_out = s->uncompressed_block;
215         s->zstream.avail_out = s->block_size;
216         ret = inflateReset(&s->zstream);
217         if (ret != Z_OK) {
218             return -1;
219         }
220         ret = inflate(&s->zstream, Z_FINISH);
221         if (ret != Z_STREAM_END || s->zstream.total_out != s->block_size) {
222             return -1;
223         }
224
225         s->current_block = block_num;
226     }
227     return 0;
228 }
229
230 static int cloop_read(BlockDriverState *bs, int64_t sector_num,
231                     uint8_t *buf, int nb_sectors)
232 {
233     BDRVCloopState *s = bs->opaque;
234     int i;
235
236     for (i = 0; i < nb_sectors; i++) {
237         uint32_t sector_offset_in_block =
238             ((sector_num + i) % s->sectors_per_block),
239             block_num = (sector_num + i) / s->sectors_per_block;
240         if (cloop_read_block(bs, block_num) != 0) {
241             return -1;
242         }
243         memcpy(buf + i * 512,
244             s->uncompressed_block + sector_offset_in_block * 512, 512);
245     }
246     return 0;
247 }
248
249 static coroutine_fn int cloop_co_read(BlockDriverState *bs, int64_t sector_num,
250                                       uint8_t *buf, int nb_sectors)
251 {
252     int ret;
253     BDRVCloopState *s = bs->opaque;
254     qemu_co_mutex_lock(&s->lock);
255     ret = cloop_read(bs, sector_num, buf, nb_sectors);
256     qemu_co_mutex_unlock(&s->lock);
257     return ret;
258 }
259
260 static void cloop_close(BlockDriverState *bs)
261 {
262     BDRVCloopState *s = bs->opaque;
263     g_free(s->offsets);
264     g_free(s->compressed_block);
265     g_free(s->uncompressed_block);
266     inflateEnd(&s->zstream);
267 }
268
269 static BlockDriver bdrv_cloop = {
270     .format_name    = "cloop",
271     .instance_size  = sizeof(BDRVCloopState),
272     .bdrv_probe     = cloop_probe,
273     .bdrv_open      = cloop_open,
274     .bdrv_read      = cloop_co_read,
275     .bdrv_close     = cloop_close,
276 };
277
278 static void bdrv_cloop_init(void)
279 {
280     bdrv_register(&bdrv_cloop);
281 }
282
283 block_init(bdrv_cloop_init);