Coverage Report

Created: 2026-11-20 08:13

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/qemu/block/qed.h
Line
Count
Source
1
/*
2
 * QEMU Enhanced Disk Format
3
 *
4
 * Copyright IBM, Corp. 2010
5
 *
6
 * Authors:
7
 *  Stefan Hajnoczi   <stefanha@linux.vnet.ibm.com>
8
 *  Anthony Liguori   <aliguori@us.ibm.com>
9
 *
10
 * This work is licensed under the terms of the GNU LGPL, version 2 or later.
11
 * See the COPYING.LIB file in the top-level directory.
12
 *
13
 */
14
15
#ifndef BLOCK_QED_H
16
#define BLOCK_QED_H
17
18
#include "block/block_int.h"
19
#include "qemu/cutils.h"
20
21
/* The layout of a QED file is as follows:
22
 *
23
 * +--------+----------+----------+----------+-----+
24
 * | header | L1 table | cluster0 | cluster1 | ... |
25
 * +--------+----------+----------+----------+-----+
26
 *
27
 * There is a 2-level pagetable for cluster allocation:
28
 *
29
 *                     +----------+
30
 *                     | L1 table |
31
 *                     +----------+
32
 *                ,------'  |  '------.
33
 *           +----------+   |    +----------+
34
 *           | L2 table |  ...   | L2 table |
35
 *           +----------+        +----------+
36
 *       ,------'  |  '------.
37
 *  +----------+   |    +----------+
38
 *  |   Data   |  ...   |   Data   |
39
 *  +----------+        +----------+
40
 *
41
 * The L1 table is fixed size and always present.  L2 tables are allocated on
42
 * demand.  The L1 table size determines the maximum possible image size; it
43
 * can be influenced using the cluster_size and table_size values.
44
 *
45
 * All fields are little-endian on disk.
46
 */
47
0
#define  QED_DEFAULT_CLUSTER_SIZE  65536
48
enum {
49
    QED_MAGIC = 'Q' | 'E' << 8 | 'D' << 16 | '\0' << 24,
50
51
    /* The image supports a backing file */
52
    QED_F_BACKING_FILE = 0x01,
53
54
    /* The image needs a consistency check before use */
55
    QED_F_NEED_CHECK = 0x02,
56
57
    /* The backing file format must not be probed, treat as raw image */
58
    QED_F_BACKING_FORMAT_NO_PROBE = 0x04,
59
60
    /* Feature bits must be used when the on-disk format changes */
61
    QED_FEATURE_MASK = QED_F_BACKING_FILE | /* supported feature bits */
62
                       QED_F_NEED_CHECK |
63
                       QED_F_BACKING_FORMAT_NO_PROBE,
64
    QED_COMPAT_FEATURE_MASK = 0,            /* supported compat feature bits */
65
    QED_AUTOCLEAR_FEATURE_MASK = 0,         /* supported autoclear feature bits */
66
67
    /* Data is stored in groups of sectors called clusters.  Cluster size must
68
     * be large to avoid keeping too much metadata.  I/O requests that have
69
     * sub-cluster size will require read-modify-write.
70
     */
71
    QED_MIN_CLUSTER_SIZE = 4 * 1024, /* in bytes */
72
    QED_MAX_CLUSTER_SIZE = 64 * 1024 * 1024,
73
74
    /* Allocated clusters are tracked using a 2-level pagetable.  Table size is
75
     * a multiple of clusters so large maximum image sizes can be supported
76
     * without jacking up the cluster size too much.
77
     */
78
    QED_MIN_TABLE_SIZE = 1,        /* in clusters */
79
    QED_MAX_TABLE_SIZE = 16,
80
    QED_DEFAULT_TABLE_SIZE = 4,
81
82
    /* Delay to flush and clean image after last allocating write completes */
83
    QED_NEED_CHECK_TIMEOUT = 5,    /* in seconds */
84
};
85
86
typedef struct {
87
    uint32_t magic;                 /* QED\0 */
88
89
    uint32_t cluster_size;          /* in bytes */
90
    uint32_t table_size;            /* for L1 and L2 tables, in clusters */
91
    uint32_t header_size;           /* in clusters */
92
93
    uint64_t features;              /* format feature bits */
94
    uint64_t compat_features;       /* compatible feature bits */
95
    uint64_t autoclear_features;    /* self-resetting feature bits */
96
97
    uint64_t l1_table_offset;       /* in bytes */
98
    uint64_t image_size;            /* total logical image size, in bytes */
99
100
    /* if (features & QED_F_BACKING_FILE) */
101
    uint32_t backing_filename_offset; /* in bytes from start of header */
102
    uint32_t backing_filename_size;   /* in bytes */
103
} QEMU_PACKED QEDHeader;
104
105
typedef struct {
106
    uint64_t offsets[0];            /* in bytes */
107
} QEDTable;
108
109
/* The L2 cache is a simple write-through cache for L2 structures */
110
typedef struct CachedL2Table {
111
    QEDTable *table;
112
    uint64_t offset;    /* offset=0 indicates an invalidate entry */
113
    QTAILQ_ENTRY(CachedL2Table) node;
114
    int ref;
115
} CachedL2Table;
116
117
typedef struct {
118
    QTAILQ_HEAD(, CachedL2Table) entries;
119
    unsigned int n_entries;
120
} L2TableCache;
121
122
typedef struct QEDRequest {
123
    CachedL2Table *l2_table;
124
} QEDRequest;
125
126
enum {
127
    QED_AIOCB_WRITE = 0x0001,       /* read or write? */
128
    QED_AIOCB_ZERO  = 0x0002,       /* zero write, used with QED_AIOCB_WRITE */
129
};
130
131
typedef struct QEDAIOCB {
132
    BlockDriverState *bs;
133
    QSIMPLEQ_ENTRY(QEDAIOCB) next;  /* next request */
134
    int flags;                      /* QED_AIOCB_* bits ORed together */
135
    uint64_t end_pos;               /* request end on block device, in bytes */
136
137
    /* User scatter-gather list */
138
    QEMUIOVector *qiov;
139
    size_t qiov_offset;             /* byte count already processed */
140
141
    /* Current cluster scatter-gather list */
142
    QEMUIOVector cur_qiov;
143
    uint64_t cur_pos;               /* position on block device, in bytes */
144
    uint64_t cur_cluster;           /* cluster offset in image file */
145
    unsigned int cur_nclusters;     /* number of clusters being accessed */
146
    int find_cluster_ret;           /* used for L1/L2 update */
147
148
    QEDRequest request;
149
} QEDAIOCB;
150
151
typedef struct {
152
    BlockDriverState *bs;           /* device */
153
154
    /* Written only by an allocating write or the timer handler (the latter
155
     * while allocating reqs are plugged).
156
     */
157
    QEDHeader header;               /* always cpu-endian */
158
159
    /* Protected by table_lock.  */
160
    CoMutex table_lock;
161
    QEDTable *l1_table;
162
    L2TableCache l2_cache;          /* l2 table cache */
163
    uint32_t table_nelems;
164
    uint32_t l1_shift;
165
    uint32_t l2_shift;
166
    uint32_t l2_mask;
167
    uint64_t file_size;             /* length of image file, in bytes */
168
169
    /* Allocating write request queue */
170
    QEDAIOCB *allocating_acb;
171
    CoQueue allocating_write_reqs;
172
    bool allocating_write_reqs_plugged;
173
174
    /* Periodic flush and clear need check flag */
175
    QEMUTimer *need_check_timer;
176
} BDRVQEDState;
177
178
enum {
179
    QED_CLUSTER_FOUND,         /* cluster found */
180
    QED_CLUSTER_ZERO,          /* zero cluster found */
181
    QED_CLUSTER_L2,            /* cluster missing in L2 */
182
    QED_CLUSTER_L1,            /* cluster missing in L1 */
183
};
184
185
/**
186
 * Header functions
187
 */
188
int GRAPH_RDLOCK qed_write_header_sync(BDRVQEDState *s);
189
190
/**
191
 * L2 cache functions
192
 */
193
void qed_init_l2_cache(L2TableCache *l2_cache);
194
void qed_free_l2_cache(L2TableCache *l2_cache);
195
CachedL2Table *qed_alloc_l2_cache_entry(L2TableCache *l2_cache);
196
void qed_unref_l2_cache_entry(CachedL2Table *entry);
197
CachedL2Table *qed_find_l2_cache_entry(L2TableCache *l2_cache, uint64_t offset);
198
void qed_commit_l2_cache_entry(L2TableCache *l2_cache, CachedL2Table *l2_table);
199
200
/**
201
 * Table I/O functions
202
 */
203
int coroutine_fn GRAPH_RDLOCK qed_read_l1_table_sync(BDRVQEDState *s);
204
205
int coroutine_fn GRAPH_RDLOCK
206
qed_write_l1_table(BDRVQEDState *s, unsigned int index, unsigned int n);
207
208
int coroutine_fn GRAPH_RDLOCK
209
qed_write_l1_table_sync(BDRVQEDState *s, unsigned int index, unsigned int n);
210
211
int coroutine_fn GRAPH_RDLOCK
212
qed_read_l2_table_sync(BDRVQEDState *s, QEDRequest *request, uint64_t offset);
213
214
int coroutine_fn GRAPH_RDLOCK
215
qed_read_l2_table(BDRVQEDState *s, QEDRequest *request, uint64_t offset);
216
217
int coroutine_fn GRAPH_RDLOCK
218
qed_write_l2_table(BDRVQEDState *s, QEDRequest *request, unsigned int index,
219
                   unsigned int n, bool flush);
220
221
int coroutine_fn GRAPH_RDLOCK
222
qed_write_l2_table_sync(BDRVQEDState *s, QEDRequest *request,
223
                        unsigned int index, unsigned int n, bool flush);
224
225
/**
226
 * Cluster functions
227
 */
228
int coroutine_fn GRAPH_RDLOCK
229
qed_find_cluster(BDRVQEDState *s, QEDRequest *request, uint64_t pos,
230
                 size_t *len, uint64_t *img_offset);
231
232
/**
233
 * Consistency check
234
 */
235
int coroutine_fn GRAPH_RDLOCK
236
qed_check(BDRVQEDState *s, BdrvCheckResult *result, bool fix);
237
238
QEDTable *qed_alloc_table(BDRVQEDState *s);
239
240
/**
241
 * Round down to the start of a cluster
242
 */
243
static inline uint64_t qed_start_of_cluster(BDRVQEDState *s, uint64_t offset)
244
0
{
245
0
    return offset & ~(uint64_t)(s->header.cluster_size - 1);
246
0
}
Unexecuted instantiation: qed-check.c:qed_start_of_cluster
Unexecuted instantiation: qed-cluster.c:qed_start_of_cluster
Unexecuted instantiation: qed-l2-cache.c:qed_start_of_cluster
Unexecuted instantiation: qed-table.c:qed_start_of_cluster
Unexecuted instantiation: qed.c:qed_start_of_cluster
247
248
static inline uint64_t qed_offset_into_cluster(BDRVQEDState *s, uint64_t offset)
249
0
{
250
0
    return offset & (s->header.cluster_size - 1);
251
0
}
Unexecuted instantiation: qed-check.c:qed_offset_into_cluster
Unexecuted instantiation: qed-cluster.c:qed_offset_into_cluster
Unexecuted instantiation: qed-l2-cache.c:qed_offset_into_cluster
Unexecuted instantiation: qed-table.c:qed_offset_into_cluster
Unexecuted instantiation: qed.c:qed_offset_into_cluster
252
253
static inline uint64_t qed_bytes_to_clusters(BDRVQEDState *s, uint64_t bytes)
254
0
{
255
0
    return qed_start_of_cluster(s, bytes + (s->header.cluster_size - 1)) /
256
0
           s->header.cluster_size;
257
0
}
Unexecuted instantiation: qed-check.c:qed_bytes_to_clusters
Unexecuted instantiation: qed-cluster.c:qed_bytes_to_clusters
Unexecuted instantiation: qed-l2-cache.c:qed_bytes_to_clusters
Unexecuted instantiation: qed-table.c:qed_bytes_to_clusters
Unexecuted instantiation: qed.c:qed_bytes_to_clusters
258
259
static inline unsigned int qed_l1_index(BDRVQEDState *s, uint64_t pos)
260
0
{
261
0
    return pos >> s->l1_shift;
262
0
}
Unexecuted instantiation: qed-check.c:qed_l1_index
Unexecuted instantiation: qed-cluster.c:qed_l1_index
Unexecuted instantiation: qed-l2-cache.c:qed_l1_index
Unexecuted instantiation: qed-table.c:qed_l1_index
Unexecuted instantiation: qed.c:qed_l1_index
263
264
static inline unsigned int qed_l2_index(BDRVQEDState *s, uint64_t pos)
265
0
{
266
0
    return (pos >> s->l2_shift) & s->l2_mask;
267
0
}
Unexecuted instantiation: qed-check.c:qed_l2_index
Unexecuted instantiation: qed-cluster.c:qed_l2_index
Unexecuted instantiation: qed-l2-cache.c:qed_l2_index
Unexecuted instantiation: qed-table.c:qed_l2_index
Unexecuted instantiation: qed.c:qed_l2_index
268
269
/**
270
 * Test if a cluster offset is valid
271
 */
272
static inline bool qed_check_cluster_offset(BDRVQEDState *s, uint64_t offset)
273
0
{
274
0
    uint64_t header_size = (uint64_t)s->header.header_size *
275
0
                           s->header.cluster_size;
276
277
0
    if (offset & (s->header.cluster_size - 1)) {
278
0
        return false;
279
0
    }
280
0
    return offset >= header_size && offset < s->file_size;
281
0
}
Unexecuted instantiation: qed-check.c:qed_check_cluster_offset
Unexecuted instantiation: qed-cluster.c:qed_check_cluster_offset
Unexecuted instantiation: qed-l2-cache.c:qed_check_cluster_offset
Unexecuted instantiation: qed-table.c:qed_check_cluster_offset
Unexecuted instantiation: qed.c:qed_check_cluster_offset
282
283
/**
284
 * Test if a table offset is valid
285
 */
286
static inline bool qed_check_table_offset(BDRVQEDState *s, uint64_t offset)
287
0
{
288
0
    uint64_t end_offset = offset + (s->header.table_size - 1) *
289
0
                          s->header.cluster_size;
290
291
    /* Overflow check */
292
0
    if (end_offset <= offset) {
293
0
        return false;
294
0
    }
295
296
0
    return qed_check_cluster_offset(s, offset) &&
297
0
           qed_check_cluster_offset(s, end_offset);
298
0
}
Unexecuted instantiation: qed-check.c:qed_check_table_offset
Unexecuted instantiation: qed-cluster.c:qed_check_table_offset
Unexecuted instantiation: qed-l2-cache.c:qed_check_table_offset
Unexecuted instantiation: qed-table.c:qed_check_table_offset
Unexecuted instantiation: qed.c:qed_check_table_offset
299
300
static inline bool qed_offset_is_cluster_aligned(BDRVQEDState *s,
301
                                                 uint64_t offset)
302
0
{
303
0
    if (qed_offset_into_cluster(s, offset)) {
304
0
        return false;
305
0
    }
306
0
    return true;
307
0
}
Unexecuted instantiation: qed-check.c:qed_offset_is_cluster_aligned
Unexecuted instantiation: qed-cluster.c:qed_offset_is_cluster_aligned
Unexecuted instantiation: qed-l2-cache.c:qed_offset_is_cluster_aligned
Unexecuted instantiation: qed-table.c:qed_offset_is_cluster_aligned
Unexecuted instantiation: qed.c:qed_offset_is_cluster_aligned
308
309
static inline bool qed_offset_is_unalloc_cluster(uint64_t offset)
310
0
{
311
0
    if (offset == 0) {
312
0
        return true;
313
0
    }
314
0
    return false;
315
0
}
Unexecuted instantiation: qed-check.c:qed_offset_is_unalloc_cluster
Unexecuted instantiation: qed-cluster.c:qed_offset_is_unalloc_cluster
Unexecuted instantiation: qed-l2-cache.c:qed_offset_is_unalloc_cluster
Unexecuted instantiation: qed-table.c:qed_offset_is_unalloc_cluster
Unexecuted instantiation: qed.c:qed_offset_is_unalloc_cluster
316
317
static inline bool qed_offset_is_zero_cluster(uint64_t offset)
318
0
{
319
0
    if (offset == 1) {
320
0
        return true;
321
0
    }
322
0
    return false;
323
0
}
Unexecuted instantiation: qed-check.c:qed_offset_is_zero_cluster
Unexecuted instantiation: qed-cluster.c:qed_offset_is_zero_cluster
Unexecuted instantiation: qed-l2-cache.c:qed_offset_is_zero_cluster
Unexecuted instantiation: qed-table.c:qed_offset_is_zero_cluster
Unexecuted instantiation: qed.c:qed_offset_is_zero_cluster
324
325
#endif /* BLOCK_QED_H */