]>
Commit | Line | Data |
---|---|---|
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_int.h" | |
26 | #include "module.h" | |
27 | #include <zlib.h> | |
28 | ||
29 | typedef struct BDRVCloopState { | |
30 | uint32_t block_size; | |
31 | uint32_t n_blocks; | |
32 | uint64_t* offsets; | |
33 | uint32_t sectors_per_block; | |
34 | uint32_t current_block; | |
35 | uint8_t *compressed_block; | |
36 | uint8_t *uncompressed_block; | |
37 | z_stream zstream; | |
38 | } BDRVCloopState; | |
39 | ||
40 | static int cloop_probe(const uint8_t *buf, int buf_size, const char *filename) | |
41 | { | |
42 | const char* magic_version_2_0="#!/bin/sh\n" | |
43 | "#V2.0 Format\n" | |
44 | "modprobe cloop file=$0 && mount -r -t iso9660 /dev/cloop $1\n"; | |
45 | int length=strlen(magic_version_2_0); | |
46 | if(length>buf_size) | |
47 | length=buf_size; | |
48 | if(!memcmp(magic_version_2_0,buf,length)) | |
49 | return 2; | |
50 | return 0; | |
51 | } | |
52 | ||
53 | static int cloop_open(BlockDriverState *bs, int flags) | |
54 | { | |
55 | BDRVCloopState *s = bs->opaque; | |
56 | uint32_t offsets_size,max_compressed_block_size=1,i; | |
57 | ||
58 | bs->read_only = 1; | |
59 | ||
60 | /* read header */ | |
61 | if (bdrv_pread(bs->file, 128, &s->block_size, 4) < 4) { | |
62 | goto cloop_close; | |
63 | } | |
64 | s->block_size = be32_to_cpu(s->block_size); | |
65 | ||
66 | if (bdrv_pread(bs->file, 128 + 4, &s->n_blocks, 4) < 4) { | |
67 | goto cloop_close; | |
68 | } | |
69 | s->n_blocks = be32_to_cpu(s->n_blocks); | |
70 | ||
71 | /* read offsets */ | |
72 | offsets_size = s->n_blocks * sizeof(uint64_t); | |
73 | s->offsets = g_malloc(offsets_size); | |
74 | if (bdrv_pread(bs->file, 128 + 4 + 4, s->offsets, offsets_size) < | |
75 | offsets_size) { | |
76 | goto cloop_close; | |
77 | } | |
78 | for(i=0;i<s->n_blocks;i++) { | |
79 | s->offsets[i]=be64_to_cpu(s->offsets[i]); | |
80 | if(i>0) { | |
81 | uint32_t size=s->offsets[i]-s->offsets[i-1]; | |
82 | if(size>max_compressed_block_size) | |
83 | max_compressed_block_size=size; | |
84 | } | |
85 | } | |
86 | ||
87 | /* initialize zlib engine */ | |
88 | s->compressed_block = g_malloc(max_compressed_block_size+1); | |
89 | s->uncompressed_block = g_malloc(s->block_size); | |
90 | if(inflateInit(&s->zstream) != Z_OK) | |
91 | goto cloop_close; | |
92 | s->current_block=s->n_blocks; | |
93 | ||
94 | s->sectors_per_block = s->block_size/512; | |
95 | bs->total_sectors = s->n_blocks*s->sectors_per_block; | |
96 | return 0; | |
97 | ||
98 | cloop_close: | |
99 | return -1; | |
100 | } | |
101 | ||
102 | static inline int cloop_read_block(BlockDriverState *bs, int block_num) | |
103 | { | |
104 | BDRVCloopState *s = bs->opaque; | |
105 | ||
106 | if(s->current_block != block_num) { | |
107 | int ret; | |
108 | uint32_t bytes = s->offsets[block_num+1]-s->offsets[block_num]; | |
109 | ||
110 | ret = bdrv_pread(bs->file, s->offsets[block_num], s->compressed_block, | |
111 | bytes); | |
112 | if (ret != bytes) | |
113 | return -1; | |
114 | ||
115 | s->zstream.next_in = s->compressed_block; | |
116 | s->zstream.avail_in = bytes; | |
117 | s->zstream.next_out = s->uncompressed_block; | |
118 | s->zstream.avail_out = s->block_size; | |
119 | ret = inflateReset(&s->zstream); | |
120 | if(ret != Z_OK) | |
121 | return -1; | |
122 | ret = inflate(&s->zstream, Z_FINISH); | |
123 | if(ret != Z_STREAM_END || s->zstream.total_out != s->block_size) | |
124 | return -1; | |
125 | ||
126 | s->current_block = block_num; | |
127 | } | |
128 | return 0; | |
129 | } | |
130 | ||
131 | static int cloop_read(BlockDriverState *bs, int64_t sector_num, | |
132 | uint8_t *buf, int nb_sectors) | |
133 | { | |
134 | BDRVCloopState *s = bs->opaque; | |
135 | int i; | |
136 | ||
137 | for(i=0;i<nb_sectors;i++) { | |
138 | uint32_t sector_offset_in_block=((sector_num+i)%s->sectors_per_block), | |
139 | block_num=(sector_num+i)/s->sectors_per_block; | |
140 | if(cloop_read_block(bs, block_num) != 0) | |
141 | return -1; | |
142 | memcpy(buf+i*512,s->uncompressed_block+sector_offset_in_block*512,512); | |
143 | } | |
144 | return 0; | |
145 | } | |
146 | ||
147 | static void cloop_close(BlockDriverState *bs) | |
148 | { | |
149 | BDRVCloopState *s = bs->opaque; | |
150 | if(s->n_blocks>0) | |
151 | free(s->offsets); | |
152 | free(s->compressed_block); | |
153 | free(s->uncompressed_block); | |
154 | inflateEnd(&s->zstream); | |
155 | } | |
156 | ||
157 | static BlockDriver bdrv_cloop = { | |
158 | .format_name = "cloop", | |
159 | .instance_size = sizeof(BDRVCloopState), | |
160 | .bdrv_probe = cloop_probe, | |
161 | .bdrv_open = cloop_open, | |
162 | .bdrv_read = cloop_read, | |
163 | .bdrv_close = cloop_close, | |
164 | }; | |
165 | ||
166 | static void bdrv_cloop_init(void) | |
167 | { | |
168 | bdrv_register(&bdrv_cloop); | |
169 | } | |
170 | ||
171 | block_init(bdrv_cloop_init); |