2 This file is part of systemd.
4 Copyright 2015 Lennart Poettering
6 systemd is free software; you can redistribute it and/or modify it
7 under the terms of the GNU Lesser General Public License as published by
8 the Free Software Foundation; either version 2.1 of the License, or
9 (at your option) any later version.
11 systemd is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
16 You should have received a copy of the GNU Lesser General Public License
17 along with systemd; If not, see <http://www.gnu.org/licenses/>.
22 #include "alloc-util.h"
23 #include "btrfs-util.h"
24 #include "qcow2-util.h"
25 #include "sparse-endian.h"
28 #define QCOW2_MAGIC 0x514649fb
30 #define QCOW2_COPIED (1ULL << 63)
31 #define QCOW2_COMPRESSED (1ULL << 62)
32 #define QCOW2_ZERO (1ULL << 0)
34 typedef struct _packed_ Header
{
38 be64_t backing_file_offset
;
39 be32_t backing_file_size
;
46 be64_t l1_table_offset
;
48 be64_t refcount_table_offset
;
49 be32_t refcount_table_clusters
;
52 be64_t snapshots_offset
;
54 /* The remainder is only present on QCOW3 */
55 be64_t incompatible_features
;
56 be64_t compatible_features
;
57 be64_t autoclear_features
;
59 be32_t refcount_order
;
63 #define HEADER_MAGIC(header) be32toh((header)->magic)
64 #define HEADER_VERSION(header) be32toh((header)->version)
65 #define HEADER_CLUSTER_BITS(header) be32toh((header)->cluster_bits)
66 #define HEADER_CLUSTER_SIZE(header) (1ULL << HEADER_CLUSTER_BITS(header))
67 #define HEADER_L2_BITS(header) (HEADER_CLUSTER_BITS(header) - 3)
68 #define HEADER_SIZE(header) be64toh((header)->size)
69 #define HEADER_CRYPT_METHOD(header) be32toh((header)->crypt_method)
70 #define HEADER_L1_SIZE(header) be32toh((header)->l1_size)
71 #define HEADER_L2_SIZE(header) (HEADER_CLUSTER_SIZE(header)/sizeof(uint64_t))
72 #define HEADER_L1_TABLE_OFFSET(header) be64toh((header)->l1_table_offset)
74 static uint32_t HEADER_HEADER_LENGTH(const Header
*h
) {
75 if (HEADER_VERSION(h
) < 3)
76 return offsetof(Header
, incompatible_features
);
78 return be32toh(h
->header_length
);
81 static int copy_cluster(
82 int sfd
, uint64_t soffset
,
83 int dfd
, uint64_t doffset
,
84 uint64_t cluster_size
,
90 r
= btrfs_clone_range(sfd
, soffset
, dfd
, doffset
, cluster_size
);
94 l
= pread(sfd
, buffer
, cluster_size
, soffset
);
97 if ((uint64_t) l
!= cluster_size
)
100 l
= pwrite(dfd
, buffer
, cluster_size
, doffset
);
103 if ((uint64_t) l
!= cluster_size
)
109 static int decompress_cluster(
110 int sfd
, uint64_t soffset
,
111 int dfd
, uint64_t doffset
,
112 uint64_t compressed_size
,
113 uint64_t cluster_size
,
117 _cleanup_free_
void *large_buffer
= NULL
;
123 if (compressed_size
> cluster_size
) {
124 /* The usual cluster buffer doesn't suffice, let's
125 * allocate a larger one, temporarily */
127 large_buffer
= malloc(compressed_size
);
131 buffer1
= large_buffer
;
134 l
= pread(sfd
, buffer1
, compressed_size
, soffset
);
137 if ((uint64_t) l
!= compressed_size
)
141 s
.avail_in
= compressed_size
;
142 s
.next_out
= buffer2
;
143 s
.avail_out
= cluster_size
;
145 r
= inflateInit2(&s
, -12);
149 r
= inflate(&s
, Z_FINISH
);
150 sz
= (uint8_t*) s
.next_out
- (uint8_t*) buffer2
;
152 if (r
!= Z_STREAM_END
|| sz
!= cluster_size
)
155 l
= pwrite(dfd
, buffer2
, cluster_size
, doffset
);
158 if ((uint64_t) l
!= cluster_size
)
164 static int normalize_offset(
165 const Header
*header
,
169 uint64_t *compressed_size
) {
175 if (q
& QCOW2_COMPRESSED
) {
176 uint64_t sz
, csize_shift
, csize_mask
;
181 csize_shift
= 64 - 2 - (HEADER_CLUSTER_BITS(header
) - 8);
182 csize_mask
= (1ULL << (HEADER_CLUSTER_BITS(header
) - 8)) - 1;
183 sz
= (((q
>> csize_shift
) & csize_mask
) + 1) * 512 - (q
& 511);
184 q
&= ((1ULL << csize_shift
) - 1);
187 *compressed_size
= sz
;
194 *compressed_size
= 0;
197 if (q
& QCOW2_ZERO
) {
198 /* We make no distinction between zero blocks and holes */
207 return q
> 0; /* returns positive if not a hole */
210 static int verify_header(const Header
*header
) {
213 if (HEADER_MAGIC(header
) != QCOW2_MAGIC
)
216 if (!IN_SET(HEADER_VERSION(header
), 2, 3))
219 if (HEADER_CRYPT_METHOD(header
) != 0)
222 if (HEADER_CLUSTER_BITS(header
) < 9) /* 512K */
225 if (HEADER_CLUSTER_BITS(header
) > 21) /* 2MB */
228 if (HEADER_SIZE(header
) % HEADER_CLUSTER_SIZE(header
) != 0)
231 if (HEADER_L1_SIZE(header
) > 32*1024*1024) /* 32MB */
234 if (HEADER_VERSION(header
) == 3) {
236 if (header
->incompatible_features
!= 0)
239 if (HEADER_HEADER_LENGTH(header
) < sizeof(Header
))
246 int qcow2_convert(int qcow2_fd
, int raw_fd
) {
247 _cleanup_free_
void *buffer1
= NULL
, *buffer2
= NULL
;
248 _cleanup_free_ be64_t
*l1_table
= NULL
, *l2_table
= NULL
;
254 l
= pread(qcow2_fd
, &header
, sizeof(header
), 0);
257 if (l
!= sizeof(header
))
260 r
= verify_header(&header
);
264 l1_table
= new(be64_t
, HEADER_L1_SIZE(&header
));
268 l2_table
= malloc(HEADER_CLUSTER_SIZE(&header
));
272 buffer1
= malloc(HEADER_CLUSTER_SIZE(&header
));
276 buffer2
= malloc(HEADER_CLUSTER_SIZE(&header
));
280 /* Empty the file if it exists, we rely on zero bits */
281 if (ftruncate(raw_fd
, 0) < 0)
284 if (ftruncate(raw_fd
, HEADER_SIZE(&header
)) < 0)
287 sz
= sizeof(uint64_t) * HEADER_L1_SIZE(&header
);
288 l
= pread(qcow2_fd
, l1_table
, sz
, HEADER_L1_TABLE_OFFSET(&header
));
291 if ((uint64_t) l
!= sz
)
294 for (i
= 0; i
< HEADER_L1_SIZE(&header
); i
++) {
295 uint64_t l2_begin
, j
;
297 r
= normalize_offset(&header
, l1_table
[i
], &l2_begin
, NULL
, NULL
);
303 l
= pread(qcow2_fd
, l2_table
, HEADER_CLUSTER_SIZE(&header
), l2_begin
);
306 if ((uint64_t) l
!= HEADER_CLUSTER_SIZE(&header
))
309 for (j
= 0; j
< HEADER_L2_SIZE(&header
); j
++) {
310 uint64_t data_begin
, p
, compressed_size
;
313 p
= ((i
<< HEADER_L2_BITS(&header
)) + j
) << HEADER_CLUSTER_BITS(&header
);
315 r
= normalize_offset(&header
, l2_table
[j
], &data_begin
, &compressed
, &compressed_size
);
322 r
= decompress_cluster(
323 qcow2_fd
, data_begin
,
325 compressed_size
, HEADER_CLUSTER_SIZE(&header
),
329 qcow2_fd
, data_begin
,
331 HEADER_CLUSTER_SIZE(&header
), buffer1
);
340 int qcow2_detect(int fd
) {
344 l
= pread(fd
, &id
, sizeof(id
), 0);
350 return htobe32(QCOW2_MAGIC
) == id
;