Branch data Line data Source code
1 : : /* SPDX-License-Identifier: LGPL-2.1+ */
2 : :
3 : : #include <zlib.h>
4 : :
5 : : #include "alloc-util.h"
6 : : #include "btrfs-util.h"
7 : : #include "qcow2-util.h"
8 : : #include "sparse-endian.h"
9 : : #include "util.h"
10 : :
11 : : #define QCOW2_MAGIC 0x514649fb
12 : :
13 : : #define QCOW2_COPIED (1ULL << 63)
14 : : #define QCOW2_COMPRESSED (1ULL << 62)
15 : : #define QCOW2_ZERO (1ULL << 0)
16 : :
17 : : typedef struct _packed_ Header {
18 : : be32_t magic;
19 : : be32_t version;
20 : :
21 : : be64_t backing_file_offset;
22 : : be32_t backing_file_size;
23 : :
24 : : be32_t cluster_bits;
25 : : be64_t size;
26 : : be32_t crypt_method;
27 : :
28 : : be32_t l1_size;
29 : : be64_t l1_table_offset;
30 : :
31 : : be64_t refcount_table_offset;
32 : : be32_t refcount_table_clusters;
33 : :
34 : : be32_t nb_snapshots;
35 : : be64_t snapshots_offset;
36 : :
37 : : /* The remainder is only present on QCOW3 */
38 : : be64_t incompatible_features;
39 : : be64_t compatible_features;
40 : : be64_t autoclear_features;
41 : :
42 : : be32_t refcount_order;
43 : : be32_t header_length;
44 : : } Header;
45 : :
46 : : #define HEADER_MAGIC(header) be32toh((header)->magic)
47 : : #define HEADER_VERSION(header) be32toh((header)->version)
48 : : #define HEADER_CLUSTER_BITS(header) be32toh((header)->cluster_bits)
49 : : #define HEADER_CLUSTER_SIZE(header) (1ULL << HEADER_CLUSTER_BITS(header))
50 : : #define HEADER_L2_BITS(header) (HEADER_CLUSTER_BITS(header) - 3)
51 : : #define HEADER_SIZE(header) be64toh((header)->size)
52 : : #define HEADER_CRYPT_METHOD(header) be32toh((header)->crypt_method)
53 : : #define HEADER_L1_SIZE(header) be32toh((header)->l1_size)
54 : : #define HEADER_L2_SIZE(header) (HEADER_CLUSTER_SIZE(header)/sizeof(uint64_t))
55 : : #define HEADER_L1_TABLE_OFFSET(header) be64toh((header)->l1_table_offset)
56 : :
57 : 0 : static uint32_t HEADER_HEADER_LENGTH(const Header *h) {
58 [ # # ]: 0 : if (HEADER_VERSION(h) < 3)
59 : 0 : return offsetof(Header, incompatible_features);
60 : :
61 : 0 : return be32toh(h->header_length);
62 : : }
63 : :
64 : 0 : static int copy_cluster(
65 : : int sfd, uint64_t soffset,
66 : : int dfd, uint64_t doffset,
67 : : uint64_t cluster_size,
68 : : void *buffer) {
69 : :
70 : : ssize_t l;
71 : : int r;
72 : :
73 : 0 : r = btrfs_clone_range(sfd, soffset, dfd, doffset, cluster_size);
74 [ # # ]: 0 : if (r >= 0)
75 : 0 : return r;
76 : :
77 : 0 : l = pread(sfd, buffer, cluster_size, soffset);
78 [ # # ]: 0 : if (l < 0)
79 : 0 : return -errno;
80 [ # # ]: 0 : if ((uint64_t) l != cluster_size)
81 : 0 : return -EIO;
82 : :
83 : 0 : l = pwrite(dfd, buffer, cluster_size, doffset);
84 [ # # ]: 0 : if (l < 0)
85 : 0 : return -errno;
86 [ # # ]: 0 : if ((uint64_t) l != cluster_size)
87 : 0 : return -EIO;
88 : :
89 : 0 : return 0;
90 : : }
91 : :
92 : 0 : static int decompress_cluster(
93 : : int sfd, uint64_t soffset,
94 : : int dfd, uint64_t doffset,
95 : : uint64_t compressed_size,
96 : : uint64_t cluster_size,
97 : : void *buffer1,
98 : : void *buffer2) {
99 : :
100 : 0 : _cleanup_free_ void *large_buffer = NULL;
101 : 0 : z_stream s = {};
102 : : uint64_t sz;
103 : : ssize_t l;
104 : : int r;
105 : :
106 [ # # ]: 0 : if (compressed_size > cluster_size) {
107 : : /* The usual cluster buffer doesn't suffice, let's
108 : : * allocate a larger one, temporarily */
109 : :
110 : 0 : large_buffer = malloc(compressed_size);
111 [ # # ]: 0 : if (!large_buffer)
112 : 0 : return -ENOMEM;
113 : :
114 : 0 : buffer1 = large_buffer;
115 : : }
116 : :
117 : 0 : l = pread(sfd, buffer1, compressed_size, soffset);
118 [ # # ]: 0 : if (l < 0)
119 : 0 : return -errno;
120 [ # # ]: 0 : if ((uint64_t) l != compressed_size)
121 : 0 : return -EIO;
122 : :
123 : 0 : s.next_in = buffer1;
124 : 0 : s.avail_in = compressed_size;
125 : 0 : s.next_out = buffer2;
126 : 0 : s.avail_out = cluster_size;
127 : :
128 : 0 : r = inflateInit2(&s, -12);
129 [ # # ]: 0 : if (r != Z_OK)
130 : 0 : return -EIO;
131 : :
132 : 0 : r = inflate(&s, Z_FINISH);
133 : 0 : sz = (uint8_t*) s.next_out - (uint8_t*) buffer2;
134 : 0 : inflateEnd(&s);
135 [ # # # # ]: 0 : if (r != Z_STREAM_END || sz != cluster_size)
136 : 0 : return -EIO;
137 : :
138 : 0 : l = pwrite(dfd, buffer2, cluster_size, doffset);
139 [ # # ]: 0 : if (l < 0)
140 : 0 : return -errno;
141 [ # # ]: 0 : if ((uint64_t) l != cluster_size)
142 : 0 : return -EIO;
143 : :
144 : 0 : return 0;
145 : : }
146 : :
147 : 0 : static int normalize_offset(
148 : : const Header *header,
149 : : uint64_t p,
150 : : uint64_t *ret,
151 : : bool *compressed,
152 : : uint64_t *compressed_size) {
153 : :
154 : : uint64_t q;
155 : :
156 : 0 : q = be64toh(p);
157 : :
158 [ # # ]: 0 : if (q & QCOW2_COMPRESSED) {
159 : : uint64_t sz, csize_shift, csize_mask;
160 : :
161 [ # # ]: 0 : if (!compressed)
162 : 0 : return -EOPNOTSUPP;
163 : :
164 : 0 : csize_shift = 64 - 2 - (HEADER_CLUSTER_BITS(header) - 8);
165 : 0 : csize_mask = (1ULL << (HEADER_CLUSTER_BITS(header) - 8)) - 1;
166 : 0 : sz = (((q >> csize_shift) & csize_mask) + 1) * 512 - (q & 511);
167 : 0 : q &= ((1ULL << csize_shift) - 1);
168 : :
169 [ # # ]: 0 : if (compressed_size)
170 : 0 : *compressed_size = sz;
171 : :
172 : 0 : *compressed = true;
173 : :
174 : : } else {
175 [ # # ]: 0 : if (compressed) {
176 : 0 : *compressed = false;
177 : 0 : *compressed_size = 0;
178 : : }
179 : :
180 [ # # ]: 0 : if (q & QCOW2_ZERO) {
181 : : /* We make no distinction between zero blocks and holes */
182 : 0 : *ret = 0;
183 : 0 : return 0;
184 : : }
185 : :
186 : 0 : q &= ~QCOW2_COPIED;
187 : : }
188 : :
189 : 0 : *ret = q;
190 : 0 : return q > 0; /* returns positive if not a hole */
191 : : }
192 : :
193 : 0 : static int verify_header(const Header *header) {
194 [ # # ]: 0 : assert(header);
195 : :
196 [ # # ]: 0 : if (HEADER_MAGIC(header) != QCOW2_MAGIC)
197 : 0 : return -EBADMSG;
198 : :
199 [ # # # # ]: 0 : if (!IN_SET(HEADER_VERSION(header), 2, 3))
200 : 0 : return -EOPNOTSUPP;
201 : :
202 [ # # ]: 0 : if (HEADER_CRYPT_METHOD(header) != 0)
203 : 0 : return -EOPNOTSUPP;
204 : :
205 [ # # ]: 0 : if (HEADER_CLUSTER_BITS(header) < 9) /* 512K */
206 : 0 : return -EBADMSG;
207 : :
208 [ # # ]: 0 : if (HEADER_CLUSTER_BITS(header) > 21) /* 2MB */
209 : 0 : return -EBADMSG;
210 : :
211 [ # # ]: 0 : if (HEADER_SIZE(header) % HEADER_CLUSTER_SIZE(header) != 0)
212 : 0 : return -EBADMSG;
213 : :
214 [ # # ]: 0 : if (HEADER_L1_SIZE(header) > 32*1024*1024) /* 32MB */
215 : 0 : return -EBADMSG;
216 : :
217 [ # # ]: 0 : if (HEADER_VERSION(header) == 3) {
218 : :
219 [ # # ]: 0 : if (header->incompatible_features != 0)
220 : 0 : return -EOPNOTSUPP;
221 : :
222 [ # # ]: 0 : if (HEADER_HEADER_LENGTH(header) < sizeof(Header))
223 : 0 : return -EBADMSG;
224 : : }
225 : :
226 : 0 : return 0;
227 : : }
228 : :
229 : 0 : int qcow2_convert(int qcow2_fd, int raw_fd) {
230 : 0 : _cleanup_free_ void *buffer1 = NULL, *buffer2 = NULL;
231 : 0 : _cleanup_free_ be64_t *l1_table = NULL, *l2_table = NULL;
232 : : uint64_t sz, i;
233 : : Header header;
234 : : ssize_t l;
235 : : int r;
236 : :
237 : 0 : l = pread(qcow2_fd, &header, sizeof(header), 0);
238 [ # # ]: 0 : if (l < 0)
239 : 0 : return -errno;
240 [ # # ]: 0 : if (l != sizeof(header))
241 : 0 : return -EIO;
242 : :
243 : 0 : r = verify_header(&header);
244 [ # # ]: 0 : if (r < 0)
245 : 0 : return r;
246 : :
247 : 0 : l1_table = new(be64_t, HEADER_L1_SIZE(&header));
248 [ # # ]: 0 : if (!l1_table)
249 : 0 : return -ENOMEM;
250 : :
251 : 0 : l2_table = malloc(HEADER_CLUSTER_SIZE(&header));
252 [ # # ]: 0 : if (!l2_table)
253 : 0 : return -ENOMEM;
254 : :
255 : 0 : buffer1 = malloc(HEADER_CLUSTER_SIZE(&header));
256 [ # # ]: 0 : if (!buffer1)
257 : 0 : return -ENOMEM;
258 : :
259 : 0 : buffer2 = malloc(HEADER_CLUSTER_SIZE(&header));
260 [ # # ]: 0 : if (!buffer2)
261 : 0 : return -ENOMEM;
262 : :
263 : : /* Empty the file if it exists, we rely on zero bits */
264 [ # # ]: 0 : if (ftruncate(raw_fd, 0) < 0)
265 : 0 : return -errno;
266 : :
267 [ # # ]: 0 : if (ftruncate(raw_fd, HEADER_SIZE(&header)) < 0)
268 : 0 : return -errno;
269 : :
270 : 0 : sz = sizeof(uint64_t) * HEADER_L1_SIZE(&header);
271 : 0 : l = pread(qcow2_fd, l1_table, sz, HEADER_L1_TABLE_OFFSET(&header));
272 [ # # ]: 0 : if (l < 0)
273 : 0 : return -errno;
274 [ # # ]: 0 : if ((uint64_t) l != sz)
275 : 0 : return -EIO;
276 : :
277 [ # # ]: 0 : for (i = 0; i < HEADER_L1_SIZE(&header); i ++) {
278 : : uint64_t l2_begin, j;
279 : :
280 : 0 : r = normalize_offset(&header, l1_table[i], &l2_begin, NULL, NULL);
281 [ # # ]: 0 : if (r < 0)
282 : 0 : return r;
283 [ # # ]: 0 : if (r == 0)
284 : 0 : continue;
285 : :
286 : 0 : l = pread(qcow2_fd, l2_table, HEADER_CLUSTER_SIZE(&header), l2_begin);
287 [ # # ]: 0 : if (l < 0)
288 : 0 : return -errno;
289 [ # # ]: 0 : if ((uint64_t) l != HEADER_CLUSTER_SIZE(&header))
290 : 0 : return -EIO;
291 : :
292 [ # # ]: 0 : for (j = 0; j < HEADER_L2_SIZE(&header); j++) {
293 : : uint64_t data_begin, p, compressed_size;
294 : : bool compressed;
295 : :
296 : 0 : p = ((i << HEADER_L2_BITS(&header)) + j) << HEADER_CLUSTER_BITS(&header);
297 : :
298 : 0 : r = normalize_offset(&header, l2_table[j], &data_begin, &compressed, &compressed_size);
299 [ # # ]: 0 : if (r < 0)
300 : 0 : return r;
301 [ # # ]: 0 : if (r == 0)
302 : 0 : continue;
303 : :
304 [ # # ]: 0 : if (compressed)
305 : 0 : r = decompress_cluster(
306 : : qcow2_fd, data_begin,
307 : : raw_fd, p,
308 : 0 : compressed_size, HEADER_CLUSTER_SIZE(&header),
309 : : buffer1, buffer2);
310 : : else
311 : 0 : r = copy_cluster(
312 : : qcow2_fd, data_begin,
313 : : raw_fd, p,
314 : 0 : HEADER_CLUSTER_SIZE(&header), buffer1);
315 [ # # ]: 0 : if (r < 0)
316 : 0 : return r;
317 : : }
318 : : }
319 : :
320 : 0 : return 0;
321 : : }
322 : :
323 : 0 : int qcow2_detect(int fd) {
324 : : be32_t id;
325 : : ssize_t l;
326 : :
327 : 0 : l = pread(fd, &id, sizeof(id), 0);
328 [ # # ]: 0 : if (l < 0)
329 : 0 : return -errno;
330 [ # # ]: 0 : if (l != sizeof(id))
331 : 0 : return -EIO;
332 : :
333 : 0 : return htobe32(QCOW2_MAGIC) == id;
334 : : }
|
