1 /* SPDX-License-Identifier: LGPL-2.1+ */
5 #include "alloc-util.h"
6 #include "btrfs-util.h"
7 #include "qcow2-util.h"
8 #include "sparse-endian.h"
11 #define QCOW2_MAGIC 0x514649fb
13 #define QCOW2_COPIED (1ULL << 63)
14 #define QCOW2_COMPRESSED (1ULL << 62)
15 #define QCOW2_ZERO (1ULL << 0)
17 typedef struct _packed_ Header
{
21 be64_t backing_file_offset
;
22 be32_t backing_file_size
;
29 be64_t l1_table_offset
;
31 be64_t refcount_table_offset
;
32 be32_t refcount_table_clusters
;
35 be64_t snapshots_offset
;
37 /* The remainder is only present on QCOW3 */
38 be64_t incompatible_features
;
39 be64_t compatible_features
;
40 be64_t autoclear_features
;
42 be32_t refcount_order
;
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)
57 static uint32_t HEADER_HEADER_LENGTH(const Header
*h
) {
58 if (HEADER_VERSION(h
) < 3)
59 return offsetof(Header
, incompatible_features
);
61 return be32toh(h
->header_length
);
64 static int copy_cluster(
65 int sfd
, uint64_t soffset
,
66 int dfd
, uint64_t doffset
,
67 uint64_t cluster_size
,
73 r
= btrfs_clone_range(sfd
, soffset
, dfd
, doffset
, cluster_size
);
77 l
= pread(sfd
, buffer
, cluster_size
, soffset
);
80 if ((uint64_t) l
!= cluster_size
)
83 l
= pwrite(dfd
, buffer
, cluster_size
, doffset
);
86 if ((uint64_t) l
!= cluster_size
)
92 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
,
100 _cleanup_free_
void *large_buffer
= NULL
;
106 if (compressed_size
> cluster_size
) {
107 /* The usual cluster buffer doesn't suffice, let's
108 * allocate a larger one, temporarily */
110 large_buffer
= malloc(compressed_size
);
114 buffer1
= large_buffer
;
117 l
= pread(sfd
, buffer1
, compressed_size
, soffset
);
120 if ((uint64_t) l
!= compressed_size
)
124 s
.avail_in
= compressed_size
;
125 s
.next_out
= buffer2
;
126 s
.avail_out
= cluster_size
;
128 r
= inflateInit2(&s
, -12);
132 r
= inflate(&s
, Z_FINISH
);
133 sz
= (uint8_t*) s
.next_out
- (uint8_t*) buffer2
;
135 if (r
!= Z_STREAM_END
|| sz
!= cluster_size
)
138 l
= pwrite(dfd
, buffer2
, cluster_size
, doffset
);
141 if ((uint64_t) l
!= cluster_size
)
147 static int normalize_offset(
148 const Header
*header
,
152 uint64_t *compressed_size
) {
158 if (q
& QCOW2_COMPRESSED
) {
159 uint64_t sz
, csize_shift
, csize_mask
;
164 csize_shift
= 64 - 2 - (HEADER_CLUSTER_BITS(header
) - 8);
165 csize_mask
= (1ULL << (HEADER_CLUSTER_BITS(header
) - 8)) - 1;
166 sz
= (((q
>> csize_shift
) & csize_mask
) + 1) * 512 - (q
& 511);
167 q
&= ((1ULL << csize_shift
) - 1);
170 *compressed_size
= sz
;
177 *compressed_size
= 0;
180 if (q
& QCOW2_ZERO
) {
181 /* We make no distinction between zero blocks and holes */
190 return q
> 0; /* returns positive if not a hole */
193 static int verify_header(const Header
*header
) {
196 if (HEADER_MAGIC(header
) != QCOW2_MAGIC
)
199 if (!IN_SET(HEADER_VERSION(header
), 2, 3))
202 if (HEADER_CRYPT_METHOD(header
) != 0)
205 if (HEADER_CLUSTER_BITS(header
) < 9) /* 512K */
208 if (HEADER_CLUSTER_BITS(header
) > 21) /* 2MB */
211 if (HEADER_SIZE(header
) % HEADER_CLUSTER_SIZE(header
) != 0)
214 if (HEADER_L1_SIZE(header
) > 32*1024*1024) /* 32MB */
217 if (HEADER_VERSION(header
) == 3) {
219 if (header
->incompatible_features
!= 0)
222 if (HEADER_HEADER_LENGTH(header
) < sizeof(Header
))
229 int qcow2_convert(int qcow2_fd
, int raw_fd
) {
230 _cleanup_free_
void *buffer1
= NULL
, *buffer2
= NULL
;
231 _cleanup_free_ be64_t
*l1_table
= NULL
, *l2_table
= NULL
;
237 l
= pread(qcow2_fd
, &header
, sizeof(header
), 0);
240 if (l
!= sizeof(header
))
243 r
= verify_header(&header
);
247 l1_table
= new(be64_t
, HEADER_L1_SIZE(&header
));
251 l2_table
= malloc(HEADER_CLUSTER_SIZE(&header
));
255 buffer1
= malloc(HEADER_CLUSTER_SIZE(&header
));
259 buffer2
= malloc(HEADER_CLUSTER_SIZE(&header
));
263 /* Empty the file if it exists, we rely on zero bits */
264 if (ftruncate(raw_fd
, 0) < 0)
267 if (ftruncate(raw_fd
, HEADER_SIZE(&header
)) < 0)
270 sz
= sizeof(uint64_t) * HEADER_L1_SIZE(&header
);
271 l
= pread(qcow2_fd
, l1_table
, sz
, HEADER_L1_TABLE_OFFSET(&header
));
274 if ((uint64_t) l
!= sz
)
277 for (i
= 0; i
< HEADER_L1_SIZE(&header
); i
++) {
278 uint64_t l2_begin
, j
;
280 r
= normalize_offset(&header
, l1_table
[i
], &l2_begin
, NULL
, NULL
);
286 l
= pread(qcow2_fd
, l2_table
, HEADER_CLUSTER_SIZE(&header
), l2_begin
);
289 if ((uint64_t) l
!= HEADER_CLUSTER_SIZE(&header
))
292 for (j
= 0; j
< HEADER_L2_SIZE(&header
); j
++) {
293 uint64_t data_begin
, p
, compressed_size
;
296 p
= ((i
<< HEADER_L2_BITS(&header
)) + j
) << HEADER_CLUSTER_BITS(&header
);
298 r
= normalize_offset(&header
, l2_table
[j
], &data_begin
, &compressed
, &compressed_size
);
305 r
= decompress_cluster(
306 qcow2_fd
, data_begin
,
308 compressed_size
, HEADER_CLUSTER_SIZE(&header
),
312 qcow2_fd
, data_begin
,
314 HEADER_CLUSTER_SIZE(&header
), buffer1
);
323 int qcow2_detect(int fd
) {
327 l
= pread(fd
, &id
, sizeof(id
), 0);
333 return htobe32(QCOW2_MAGIC
) == id
;