1 /* SPDX-License-Identifier: LGPL-2.1+ */
3 Copyright 2015 Lennart Poettering
8 #include "alloc-util.h"
9 #include "btrfs-util.h"
10 #include "qcow2-util.h"
11 #include "sparse-endian.h"
14 #define QCOW2_MAGIC 0x514649fb
16 #define QCOW2_COPIED (1ULL << 63)
17 #define QCOW2_COMPRESSED (1ULL << 62)
18 #define QCOW2_ZERO (1ULL << 0)
20 typedef struct _packed_ Header
{
24 be64_t backing_file_offset
;
25 be32_t backing_file_size
;
32 be64_t l1_table_offset
;
34 be64_t refcount_table_offset
;
35 be32_t refcount_table_clusters
;
38 be64_t snapshots_offset
;
40 /* The remainder is only present on QCOW3 */
41 be64_t incompatible_features
;
42 be64_t compatible_features
;
43 be64_t autoclear_features
;
45 be32_t refcount_order
;
49 #define HEADER_MAGIC(header) be32toh((header)->magic)
50 #define HEADER_VERSION(header) be32toh((header)->version)
51 #define HEADER_CLUSTER_BITS(header) be32toh((header)->cluster_bits)
52 #define HEADER_CLUSTER_SIZE(header) (1ULL << HEADER_CLUSTER_BITS(header))
53 #define HEADER_L2_BITS(header) (HEADER_CLUSTER_BITS(header) - 3)
54 #define HEADER_SIZE(header) be64toh((header)->size)
55 #define HEADER_CRYPT_METHOD(header) be32toh((header)->crypt_method)
56 #define HEADER_L1_SIZE(header) be32toh((header)->l1_size)
57 #define HEADER_L2_SIZE(header) (HEADER_CLUSTER_SIZE(header)/sizeof(uint64_t))
58 #define HEADER_L1_TABLE_OFFSET(header) be64toh((header)->l1_table_offset)
60 static uint32_t HEADER_HEADER_LENGTH(const Header
*h
) {
61 if (HEADER_VERSION(h
) < 3)
62 return offsetof(Header
, incompatible_features
);
64 return be32toh(h
->header_length
);
67 static int copy_cluster(
68 int sfd
, uint64_t soffset
,
69 int dfd
, uint64_t doffset
,
70 uint64_t cluster_size
,
76 r
= btrfs_clone_range(sfd
, soffset
, dfd
, doffset
, cluster_size
);
80 l
= pread(sfd
, buffer
, cluster_size
, soffset
);
83 if ((uint64_t) l
!= cluster_size
)
86 l
= pwrite(dfd
, buffer
, cluster_size
, doffset
);
89 if ((uint64_t) l
!= cluster_size
)
95 static int decompress_cluster(
96 int sfd
, uint64_t soffset
,
97 int dfd
, uint64_t doffset
,
98 uint64_t compressed_size
,
99 uint64_t cluster_size
,
103 _cleanup_free_
void *large_buffer
= NULL
;
109 if (compressed_size
> cluster_size
) {
110 /* The usual cluster buffer doesn't suffice, let's
111 * allocate a larger one, temporarily */
113 large_buffer
= malloc(compressed_size
);
117 buffer1
= large_buffer
;
120 l
= pread(sfd
, buffer1
, compressed_size
, soffset
);
123 if ((uint64_t) l
!= compressed_size
)
127 s
.avail_in
= compressed_size
;
128 s
.next_out
= buffer2
;
129 s
.avail_out
= cluster_size
;
131 r
= inflateInit2(&s
, -12);
135 r
= inflate(&s
, Z_FINISH
);
136 sz
= (uint8_t*) s
.next_out
- (uint8_t*) buffer2
;
138 if (r
!= Z_STREAM_END
|| sz
!= cluster_size
)
141 l
= pwrite(dfd
, buffer2
, cluster_size
, doffset
);
144 if ((uint64_t) l
!= cluster_size
)
150 static int normalize_offset(
151 const Header
*header
,
155 uint64_t *compressed_size
) {
161 if (q
& QCOW2_COMPRESSED
) {
162 uint64_t sz
, csize_shift
, csize_mask
;
167 csize_shift
= 64 - 2 - (HEADER_CLUSTER_BITS(header
) - 8);
168 csize_mask
= (1ULL << (HEADER_CLUSTER_BITS(header
) - 8)) - 1;
169 sz
= (((q
>> csize_shift
) & csize_mask
) + 1) * 512 - (q
& 511);
170 q
&= ((1ULL << csize_shift
) - 1);
173 *compressed_size
= sz
;
180 *compressed_size
= 0;
183 if (q
& QCOW2_ZERO
) {
184 /* We make no distinction between zero blocks and holes */
193 return q
> 0; /* returns positive if not a hole */
196 static int verify_header(const Header
*header
) {
199 if (HEADER_MAGIC(header
) != QCOW2_MAGIC
)
202 if (!IN_SET(HEADER_VERSION(header
), 2, 3))
205 if (HEADER_CRYPT_METHOD(header
) != 0)
208 if (HEADER_CLUSTER_BITS(header
) < 9) /* 512K */
211 if (HEADER_CLUSTER_BITS(header
) > 21) /* 2MB */
214 if (HEADER_SIZE(header
) % HEADER_CLUSTER_SIZE(header
) != 0)
217 if (HEADER_L1_SIZE(header
) > 32*1024*1024) /* 32MB */
220 if (HEADER_VERSION(header
) == 3) {
222 if (header
->incompatible_features
!= 0)
225 if (HEADER_HEADER_LENGTH(header
) < sizeof(Header
))
232 int qcow2_convert(int qcow2_fd
, int raw_fd
) {
233 _cleanup_free_
void *buffer1
= NULL
, *buffer2
= NULL
;
234 _cleanup_free_ be64_t
*l1_table
= NULL
, *l2_table
= NULL
;
240 l
= pread(qcow2_fd
, &header
, sizeof(header
), 0);
243 if (l
!= sizeof(header
))
246 r
= verify_header(&header
);
250 l1_table
= new(be64_t
, HEADER_L1_SIZE(&header
));
254 l2_table
= malloc(HEADER_CLUSTER_SIZE(&header
));
258 buffer1
= malloc(HEADER_CLUSTER_SIZE(&header
));
262 buffer2
= malloc(HEADER_CLUSTER_SIZE(&header
));
266 /* Empty the file if it exists, we rely on zero bits */
267 if (ftruncate(raw_fd
, 0) < 0)
270 if (ftruncate(raw_fd
, HEADER_SIZE(&header
)) < 0)
273 sz
= sizeof(uint64_t) * HEADER_L1_SIZE(&header
);
274 l
= pread(qcow2_fd
, l1_table
, sz
, HEADER_L1_TABLE_OFFSET(&header
));
277 if ((uint64_t) l
!= sz
)
280 for (i
= 0; i
< HEADER_L1_SIZE(&header
); i
++) {
281 uint64_t l2_begin
, j
;
283 r
= normalize_offset(&header
, l1_table
[i
], &l2_begin
, NULL
, NULL
);
289 l
= pread(qcow2_fd
, l2_table
, HEADER_CLUSTER_SIZE(&header
), l2_begin
);
292 if ((uint64_t) l
!= HEADER_CLUSTER_SIZE(&header
))
295 for (j
= 0; j
< HEADER_L2_SIZE(&header
); j
++) {
296 uint64_t data_begin
, p
, compressed_size
;
299 p
= ((i
<< HEADER_L2_BITS(&header
)) + j
) << HEADER_CLUSTER_BITS(&header
);
301 r
= normalize_offset(&header
, l2_table
[j
], &data_begin
, &compressed
, &compressed_size
);
308 r
= decompress_cluster(
309 qcow2_fd
, data_begin
,
311 compressed_size
, HEADER_CLUSTER_SIZE(&header
),
315 qcow2_fd
, data_begin
,
317 HEADER_CLUSTER_SIZE(&header
), buffer1
);
326 int qcow2_detect(int fd
) {
330 l
= pread(fd
, &id
, sizeof(id
), 0);
336 return htobe32(QCOW2_MAGIC
) == id
;