1 /* SPDX-License-Identifier: LGPL-2.1+ */
3 This file is part of systemd.
5 Copyright 2015 Lennart Poettering
10 #include "alloc-util.h"
11 #include "btrfs-util.h"
12 #include "qcow2-util.h"
13 #include "sparse-endian.h"
16 #define QCOW2_MAGIC 0x514649fb
18 #define QCOW2_COPIED (1ULL << 63)
19 #define QCOW2_COMPRESSED (1ULL << 62)
20 #define QCOW2_ZERO (1ULL << 0)
22 typedef struct _packed_ Header
{
26 be64_t backing_file_offset
;
27 be32_t backing_file_size
;
34 be64_t l1_table_offset
;
36 be64_t refcount_table_offset
;
37 be32_t refcount_table_clusters
;
40 be64_t snapshots_offset
;
42 /* The remainder is only present on QCOW3 */
43 be64_t incompatible_features
;
44 be64_t compatible_features
;
45 be64_t autoclear_features
;
47 be32_t refcount_order
;
51 #define HEADER_MAGIC(header) be32toh((header)->magic)
52 #define HEADER_VERSION(header) be32toh((header)->version)
53 #define HEADER_CLUSTER_BITS(header) be32toh((header)->cluster_bits)
54 #define HEADER_CLUSTER_SIZE(header) (1ULL << HEADER_CLUSTER_BITS(header))
55 #define HEADER_L2_BITS(header) (HEADER_CLUSTER_BITS(header) - 3)
56 #define HEADER_SIZE(header) be64toh((header)->size)
57 #define HEADER_CRYPT_METHOD(header) be32toh((header)->crypt_method)
58 #define HEADER_L1_SIZE(header) be32toh((header)->l1_size)
59 #define HEADER_L2_SIZE(header) (HEADER_CLUSTER_SIZE(header)/sizeof(uint64_t))
60 #define HEADER_L1_TABLE_OFFSET(header) be64toh((header)->l1_table_offset)
62 static uint32_t HEADER_HEADER_LENGTH(const Header
*h
) {
63 if (HEADER_VERSION(h
) < 3)
64 return offsetof(Header
, incompatible_features
);
66 return be32toh(h
->header_length
);
69 static int copy_cluster(
70 int sfd
, uint64_t soffset
,
71 int dfd
, uint64_t doffset
,
72 uint64_t cluster_size
,
78 r
= btrfs_clone_range(sfd
, soffset
, dfd
, doffset
, cluster_size
);
82 l
= pread(sfd
, buffer
, cluster_size
, soffset
);
85 if ((uint64_t) l
!= cluster_size
)
88 l
= pwrite(dfd
, buffer
, cluster_size
, doffset
);
91 if ((uint64_t) l
!= cluster_size
)
97 static int decompress_cluster(
98 int sfd
, uint64_t soffset
,
99 int dfd
, uint64_t doffset
,
100 uint64_t compressed_size
,
101 uint64_t cluster_size
,
105 _cleanup_free_
void *large_buffer
= NULL
;
111 if (compressed_size
> cluster_size
) {
112 /* The usual cluster buffer doesn't suffice, let's
113 * allocate a larger one, temporarily */
115 large_buffer
= malloc(compressed_size
);
119 buffer1
= large_buffer
;
122 l
= pread(sfd
, buffer1
, compressed_size
, soffset
);
125 if ((uint64_t) l
!= compressed_size
)
129 s
.avail_in
= compressed_size
;
130 s
.next_out
= buffer2
;
131 s
.avail_out
= cluster_size
;
133 r
= inflateInit2(&s
, -12);
137 r
= inflate(&s
, Z_FINISH
);
138 sz
= (uint8_t*) s
.next_out
- (uint8_t*) buffer2
;
140 if (r
!= Z_STREAM_END
|| sz
!= cluster_size
)
143 l
= pwrite(dfd
, buffer2
, cluster_size
, doffset
);
146 if ((uint64_t) l
!= cluster_size
)
152 static int normalize_offset(
153 const Header
*header
,
157 uint64_t *compressed_size
) {
163 if (q
& QCOW2_COMPRESSED
) {
164 uint64_t sz
, csize_shift
, csize_mask
;
169 csize_shift
= 64 - 2 - (HEADER_CLUSTER_BITS(header
) - 8);
170 csize_mask
= (1ULL << (HEADER_CLUSTER_BITS(header
) - 8)) - 1;
171 sz
= (((q
>> csize_shift
) & csize_mask
) + 1) * 512 - (q
& 511);
172 q
&= ((1ULL << csize_shift
) - 1);
175 *compressed_size
= sz
;
182 *compressed_size
= 0;
185 if (q
& QCOW2_ZERO
) {
186 /* We make no distinction between zero blocks and holes */
195 return q
> 0; /* returns positive if not a hole */
198 static int verify_header(const Header
*header
) {
201 if (HEADER_MAGIC(header
) != QCOW2_MAGIC
)
204 if (!IN_SET(HEADER_VERSION(header
), 2, 3))
207 if (HEADER_CRYPT_METHOD(header
) != 0)
210 if (HEADER_CLUSTER_BITS(header
) < 9) /* 512K */
213 if (HEADER_CLUSTER_BITS(header
) > 21) /* 2MB */
216 if (HEADER_SIZE(header
) % HEADER_CLUSTER_SIZE(header
) != 0)
219 if (HEADER_L1_SIZE(header
) > 32*1024*1024) /* 32MB */
222 if (HEADER_VERSION(header
) == 3) {
224 if (header
->incompatible_features
!= 0)
227 if (HEADER_HEADER_LENGTH(header
) < sizeof(Header
))
234 int qcow2_convert(int qcow2_fd
, int raw_fd
) {
235 _cleanup_free_
void *buffer1
= NULL
, *buffer2
= NULL
;
236 _cleanup_free_ be64_t
*l1_table
= NULL
, *l2_table
= NULL
;
242 l
= pread(qcow2_fd
, &header
, sizeof(header
), 0);
245 if (l
!= sizeof(header
))
248 r
= verify_header(&header
);
252 l1_table
= new(be64_t
, HEADER_L1_SIZE(&header
));
256 l2_table
= malloc(HEADER_CLUSTER_SIZE(&header
));
260 buffer1
= malloc(HEADER_CLUSTER_SIZE(&header
));
264 buffer2
= malloc(HEADER_CLUSTER_SIZE(&header
));
268 /* Empty the file if it exists, we rely on zero bits */
269 if (ftruncate(raw_fd
, 0) < 0)
272 if (ftruncate(raw_fd
, HEADER_SIZE(&header
)) < 0)
275 sz
= sizeof(uint64_t) * HEADER_L1_SIZE(&header
);
276 l
= pread(qcow2_fd
, l1_table
, sz
, HEADER_L1_TABLE_OFFSET(&header
));
279 if ((uint64_t) l
!= sz
)
282 for (i
= 0; i
< HEADER_L1_SIZE(&header
); i
++) {
283 uint64_t l2_begin
, j
;
285 r
= normalize_offset(&header
, l1_table
[i
], &l2_begin
, NULL
, NULL
);
291 l
= pread(qcow2_fd
, l2_table
, HEADER_CLUSTER_SIZE(&header
), l2_begin
);
294 if ((uint64_t) l
!= HEADER_CLUSTER_SIZE(&header
))
297 for (j
= 0; j
< HEADER_L2_SIZE(&header
); j
++) {
298 uint64_t data_begin
, p
, compressed_size
;
301 p
= ((i
<< HEADER_L2_BITS(&header
)) + j
) << HEADER_CLUSTER_BITS(&header
);
303 r
= normalize_offset(&header
, l2_table
[j
], &data_begin
, &compressed
, &compressed_size
);
310 r
= decompress_cluster(
311 qcow2_fd
, data_begin
,
313 compressed_size
, HEADER_CLUSTER_SIZE(&header
),
317 qcow2_fd
, data_begin
,
319 HEADER_CLUSTER_SIZE(&header
), buffer1
);
328 int qcow2_detect(int fd
) {
332 l
= pread(fd
, &id
, sizeof(id
), 0);
338 return htobe32(QCOW2_MAGIC
) == id
;