1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
5 #include "alloc-util.h"
6 #include "btrfs-util.h"
7 #include "qcow2-util.h"
8 #include "sparse-endian.h"
10 #define QCOW2_MAGIC 0x514649fb
12 #define QCOW2_COPIED (1ULL << 63)
13 #define QCOW2_COMPRESSED (1ULL << 62)
14 #define QCOW2_ZERO (1ULL << 0)
16 typedef struct _packed_ Header
{
20 be64_t backing_file_offset
;
21 be32_t backing_file_size
;
28 be64_t l1_table_offset
;
30 be64_t refcount_table_offset
;
31 be32_t refcount_table_clusters
;
34 be64_t snapshots_offset
;
36 /* The remainder is only present on QCOW3 */
37 be64_t incompatible_features
;
38 be64_t compatible_features
;
39 be64_t autoclear_features
;
41 be32_t refcount_order
;
45 #define HEADER_MAGIC(header) be32toh((header)->magic)
46 #define HEADER_VERSION(header) be32toh((header)->version)
47 #define HEADER_CLUSTER_BITS(header) be32toh((header)->cluster_bits)
48 #define HEADER_CLUSTER_SIZE(header) (1ULL << HEADER_CLUSTER_BITS(header))
49 #define HEADER_L2_BITS(header) (HEADER_CLUSTER_BITS(header) - 3)
50 #define HEADER_SIZE(header) be64toh((header)->size)
51 #define HEADER_CRYPT_METHOD(header) be32toh((header)->crypt_method)
52 #define HEADER_L1_SIZE(header) be32toh((header)->l1_size)
53 #define HEADER_L2_SIZE(header) (HEADER_CLUSTER_SIZE(header)/sizeof(uint64_t))
54 #define HEADER_L1_TABLE_OFFSET(header) be64toh((header)->l1_table_offset)
56 static uint32_t HEADER_HEADER_LENGTH(const Header
*h
) {
57 if (HEADER_VERSION(h
) < 3)
58 return offsetof(Header
, incompatible_features
);
60 return be32toh(h
->header_length
);
63 static int copy_cluster(
64 int sfd
, uint64_t soffset
,
65 int dfd
, uint64_t doffset
,
66 uint64_t cluster_size
,
72 r
= reflink_range(sfd
, soffset
, dfd
, doffset
, cluster_size
);
76 l
= pread(sfd
, buffer
, cluster_size
, soffset
);
79 if ((uint64_t) l
!= cluster_size
)
82 l
= pwrite(dfd
, buffer
, cluster_size
, doffset
);
85 if ((uint64_t) l
!= cluster_size
)
91 static int decompress_cluster(
92 int sfd
, uint64_t soffset
,
93 int dfd
, uint64_t doffset
,
94 uint64_t compressed_size
,
95 uint64_t cluster_size
,
99 _cleanup_free_
void *large_buffer
= NULL
;
105 if (compressed_size
> cluster_size
) {
106 /* The usual cluster buffer doesn't suffice, let's
107 * allocate a larger one, temporarily */
109 large_buffer
= malloc(compressed_size
);
113 buffer1
= large_buffer
;
116 l
= pread(sfd
, buffer1
, compressed_size
, soffset
);
119 if ((uint64_t) l
!= compressed_size
)
123 s
.avail_in
= compressed_size
;
124 s
.next_out
= buffer2
;
125 s
.avail_out
= cluster_size
;
127 r
= inflateInit2(&s
, -12);
131 r
= inflate(&s
, Z_FINISH
);
132 sz
= (uint8_t*) s
.next_out
- (uint8_t*) buffer2
;
134 if (r
!= Z_STREAM_END
|| sz
!= cluster_size
)
137 l
= pwrite(dfd
, buffer2
, cluster_size
, doffset
);
140 if ((uint64_t) l
!= cluster_size
)
146 static int normalize_offset(
147 const Header
*header
,
151 uint64_t *compressed_size
) {
157 if (q
& QCOW2_COMPRESSED
) {
158 uint64_t sz
, csize_shift
, csize_mask
;
163 csize_shift
= 64 - 2 - (HEADER_CLUSTER_BITS(header
) - 8);
164 csize_mask
= (1ULL << (HEADER_CLUSTER_BITS(header
) - 8)) - 1;
165 sz
= (((q
>> csize_shift
) & csize_mask
) + 1) * 512 - (q
& 511);
166 q
&= ((1ULL << csize_shift
) - 1);
169 *compressed_size
= sz
;
176 *compressed_size
= 0;
179 if (q
& QCOW2_ZERO
) {
180 /* We make no distinction between zero blocks and holes */
189 return q
> 0; /* returns positive if not a hole */
192 static int verify_header(const Header
*header
) {
195 if (HEADER_MAGIC(header
) != QCOW2_MAGIC
)
198 if (!IN_SET(HEADER_VERSION(header
), 2, 3))
201 if (HEADER_CRYPT_METHOD(header
) != 0)
204 if (HEADER_CLUSTER_BITS(header
) < 9) /* 512K */
207 if (HEADER_CLUSTER_BITS(header
) > 21) /* 2MB */
210 if (HEADER_SIZE(header
) % HEADER_CLUSTER_SIZE(header
) != 0)
213 if (HEADER_L1_SIZE(header
) > 32*1024*1024) /* 32MB */
216 if (HEADER_VERSION(header
) == 3) {
218 if (header
->incompatible_features
!= 0)
221 if (HEADER_HEADER_LENGTH(header
) < sizeof(Header
))
228 int qcow2_convert(int qcow2_fd
, int raw_fd
) {
229 _cleanup_free_
void *buffer1
= NULL
, *buffer2
= NULL
;
230 _cleanup_free_ be64_t
*l1_table
= NULL
, *l2_table
= NULL
;
236 l
= pread(qcow2_fd
, &header
, sizeof(header
), 0);
239 if (l
!= sizeof(header
))
242 r
= verify_header(&header
);
246 l1_table
= new(be64_t
, HEADER_L1_SIZE(&header
));
250 l2_table
= malloc(HEADER_CLUSTER_SIZE(&header
));
254 buffer1
= malloc(HEADER_CLUSTER_SIZE(&header
));
258 buffer2
= malloc(HEADER_CLUSTER_SIZE(&header
));
262 /* Empty the file if it exists, we rely on zero bits */
263 if (ftruncate(raw_fd
, 0) < 0)
266 if (ftruncate(raw_fd
, HEADER_SIZE(&header
)) < 0)
269 sz
= sizeof(uint64_t) * HEADER_L1_SIZE(&header
);
270 l
= pread(qcow2_fd
, l1_table
, sz
, HEADER_L1_TABLE_OFFSET(&header
));
273 if ((uint64_t) l
!= sz
)
276 for (i
= 0; i
< HEADER_L1_SIZE(&header
); i
++) {
277 uint64_t l2_begin
, j
;
279 r
= normalize_offset(&header
, l1_table
[i
], &l2_begin
, NULL
, NULL
);
285 l
= pread(qcow2_fd
, l2_table
, HEADER_CLUSTER_SIZE(&header
), l2_begin
);
288 if ((uint64_t) l
!= HEADER_CLUSTER_SIZE(&header
))
291 for (j
= 0; j
< HEADER_L2_SIZE(&header
); j
++) {
292 uint64_t data_begin
, p
, compressed_size
;
295 p
= ((i
<< HEADER_L2_BITS(&header
)) + j
) << HEADER_CLUSTER_BITS(&header
);
297 r
= normalize_offset(&header
, l2_table
[j
], &data_begin
, &compressed
, &compressed_size
);
304 r
= decompress_cluster(
305 qcow2_fd
, data_begin
,
307 compressed_size
, HEADER_CLUSTER_SIZE(&header
),
311 qcow2_fd
, data_begin
,
313 HEADER_CLUSTER_SIZE(&header
), buffer1
);
322 int qcow2_detect(int fd
) {
326 l
= pread(fd
, &id
, sizeof(id
), 0);
332 return htobe32(QCOW2_MAGIC
) == id
;