Update version for v5.1.0 release
[qemu.git] / block / qed-cluster.c
1 /*
2 * QEMU Enhanced Disk Format Cluster functions
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 #include "qemu/osdep.h"
16 #include "qed.h"
17
18 /**
19 * Count the number of contiguous data clusters
20 *
21 * @s: QED state
22 * @table: L2 table
23 * @index: First cluster index
24 * @n: Maximum number of clusters
25 * @offset: Set to first cluster offset
26 *
27 * This function scans tables for contiguous clusters. A contiguous run of
28 * clusters may be allocated, unallocated, or zero.
29 */
30 static unsigned int qed_count_contiguous_clusters(BDRVQEDState *s,
31 QEDTable *table,
32 unsigned int index,
33 unsigned int n,
34 uint64_t *offset)
35 {
36 unsigned int end = MIN(index + n, s->table_nelems);
37 uint64_t last = table->offsets[index];
38 unsigned int i;
39
40 *offset = last;
41
42 for (i = index + 1; i < end; i++) {
43 if (qed_offset_is_unalloc_cluster(last)) {
44 /* Counting unallocated clusters */
45 if (!qed_offset_is_unalloc_cluster(table->offsets[i])) {
46 break;
47 }
48 } else if (qed_offset_is_zero_cluster(last)) {
49 /* Counting zero clusters */
50 if (!qed_offset_is_zero_cluster(table->offsets[i])) {
51 break;
52 }
53 } else {
54 /* Counting allocated clusters */
55 if (table->offsets[i] != last + s->header.cluster_size) {
56 break;
57 }
58 last = table->offsets[i];
59 }
60 }
61 return i - index;
62 }
63
64 /**
65 * Find the offset of a data cluster
66 *
67 * @s: QED state
68 * @request: L2 cache entry
69 * @pos: Byte position in device
70 * @len: Number of bytes (may be shortened on return)
71 * @img_offset: Contains offset in the image file on success
72 *
73 * This function translates a position in the block device to an offset in the
74 * image file. The translated offset or unallocated range in the image file is
75 * reported back in *img_offset and *len.
76 *
77 * If the L2 table exists, request->l2_table points to the L2 table cache entry
78 * and the caller must free the reference when they are finished. The cache
79 * entry is exposed in this way to avoid callers having to read the L2 table
80 * again later during request processing. If request->l2_table is non-NULL it
81 * will be unreferenced before taking on the new cache entry.
82 *
83 * On success QED_CLUSTER_FOUND is returned and img_offset/len are a contiguous
84 * range in the image file.
85 *
86 * On failure QED_CLUSTER_L2 or QED_CLUSTER_L1 is returned for missing L2 or L1
87 * table offset, respectively. len is number of contiguous unallocated bytes.
88 *
89 * Called with table_lock held.
90 */
91 int coroutine_fn qed_find_cluster(BDRVQEDState *s, QEDRequest *request,
92 uint64_t pos, size_t *len,
93 uint64_t *img_offset)
94 {
95 uint64_t l2_offset;
96 uint64_t offset = 0;
97 unsigned int index;
98 unsigned int n;
99 int ret;
100
101 /* Limit length to L2 boundary. Requests are broken up at the L2 boundary
102 * so that a request acts on one L2 table at a time.
103 */
104 *len = MIN(*len, (((pos >> s->l1_shift) + 1) << s->l1_shift) - pos);
105
106 l2_offset = s->l1_table->offsets[qed_l1_index(s, pos)];
107 if (qed_offset_is_unalloc_cluster(l2_offset)) {
108 *img_offset = 0;
109 return QED_CLUSTER_L1;
110 }
111 if (!qed_check_table_offset(s, l2_offset)) {
112 *img_offset = *len = 0;
113 return -EINVAL;
114 }
115
116 ret = qed_read_l2_table(s, request, l2_offset);
117 if (ret) {
118 goto out;
119 }
120
121 index = qed_l2_index(s, pos);
122 n = qed_bytes_to_clusters(s, qed_offset_into_cluster(s, pos) + *len);
123 n = qed_count_contiguous_clusters(s, request->l2_table->table,
124 index, n, &offset);
125
126 if (qed_offset_is_unalloc_cluster(offset)) {
127 ret = QED_CLUSTER_L2;
128 } else if (qed_offset_is_zero_cluster(offset)) {
129 ret = QED_CLUSTER_ZERO;
130 } else if (qed_check_cluster_offset(s, offset)) {
131 ret = QED_CLUSTER_FOUND;
132 } else {
133 ret = -EINVAL;
134 }
135
136 *len = MIN(*len,
137 n * s->header.cluster_size - qed_offset_into_cluster(s, pos));
138
139 out:
140 *img_offset = offset;
141 return ret;
142 }