![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to qed-cluster.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / block|
Return to qed-cluster.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / block |
1.1 root 1: /*
2: * QEMU Enhanced Disk Format Cluster functions
3: *
4: * Copyright IBM, Corp. 2010
5: *
6: * Authors:
7: * Stefan Hajnoczi <[email protected]>
8: * Anthony Liguori <[email protected]>
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 "qed.h"
16:
17: /**
18: * Count the number of contiguous data clusters
19: *
20: * @s: QED state
21: * @table: L2 table
22: * @index: First cluster index
23: * @n: Maximum number of clusters
24: * @offset: Set to first cluster offset
25: *
26: * This function scans tables for contiguous allocated or free clusters.
27: */
28: static unsigned int qed_count_contiguous_clusters(BDRVQEDState *s,
29: QEDTable *table,
30: unsigned int index,
31: unsigned int n,
32: uint64_t *offset)
33: {
34: unsigned int end = MIN(index + n, s->table_nelems);
35: uint64_t last = table->offsets[index];
36: unsigned int i;
37:
38: *offset = last;
39:
40: for (i = index + 1; i < end; i++) {
41: if (last == 0) {
42: /* Counting free clusters */
43: if (table->offsets[i] != 0) {
44: break;
45: }
46: } else {
47: /* Counting allocated clusters */
48: if (table->offsets[i] != last + s->header.cluster_size) {
49: break;
50: }
51: last = table->offsets[i];
52: }
53: }
54: return i - index;
55: }
56:
57: typedef struct {
58: BDRVQEDState *s;
59: uint64_t pos;
60: size_t len;
61:
62: QEDRequest *request;
63:
64: /* User callback */
65: QEDFindClusterFunc *cb;
66: void *opaque;
67: } QEDFindClusterCB;
68:
69: static void qed_find_cluster_cb(void *opaque, int ret)
70: {
71: QEDFindClusterCB *find_cluster_cb = opaque;
72: BDRVQEDState *s = find_cluster_cb->s;
73: QEDRequest *request = find_cluster_cb->request;
74: uint64_t offset = 0;
75: size_t len = 0;
76: unsigned int index;
77: unsigned int n;
78:
79: if (ret) {
80: goto out;
81: }
82:
83: index = qed_l2_index(s, find_cluster_cb->pos);
84: n = qed_bytes_to_clusters(s,
85: qed_offset_into_cluster(s, find_cluster_cb->pos) +
86: find_cluster_cb->len);
87: n = qed_count_contiguous_clusters(s, request->l2_table->table,
88: index, n, &offset);
89:
90: ret = offset ? QED_CLUSTER_FOUND : QED_CLUSTER_L2;
91: len = MIN(find_cluster_cb->len, n * s->header.cluster_size -
92: qed_offset_into_cluster(s, find_cluster_cb->pos));
93:
94: if (offset && !qed_check_cluster_offset(s, offset)) {
95: ret = -EINVAL;
96: }
97:
98: out:
99: find_cluster_cb->cb(find_cluster_cb->opaque, ret, offset, len);
100: qemu_free(find_cluster_cb);
101: }
102:
103: /**
104: * Find the offset of a data cluster
105: *
106: * @s: QED state
107: * @request: L2 cache entry
108: * @pos: Byte position in device
109: * @len: Number of bytes
110: * @cb: Completion function
111: * @opaque: User data for completion function
112: *
113: * This function translates a position in the block device to an offset in the
114: * image file. It invokes the cb completion callback to report back the
115: * translated offset or unallocated range in the image file.
116: *
117: * If the L2 table exists, request->l2_table points to the L2 table cache entry
118: * and the caller must free the reference when they are finished. The cache
119: * entry is exposed in this way to avoid callers having to read the L2 table
120: * again later during request processing. If request->l2_table is non-NULL it
121: * will be unreferenced before taking on the new cache entry.
122: */
123: void qed_find_cluster(BDRVQEDState *s, QEDRequest *request, uint64_t pos,
124: size_t len, QEDFindClusterFunc *cb, void *opaque)
125: {
126: QEDFindClusterCB *find_cluster_cb;
127: uint64_t l2_offset;
128:
129: /* Limit length to L2 boundary. Requests are broken up at the L2 boundary
130: * so that a request acts on one L2 table at a time.
131: */
132: len = MIN(len, (((pos >> s->l1_shift) + 1) << s->l1_shift) - pos);
133:
134: l2_offset = s->l1_table->offsets[qed_l1_index(s, pos)];
135: if (!l2_offset) {
136: cb(opaque, QED_CLUSTER_L1, 0, len);
137: return;
138: }
139: if (!qed_check_table_offset(s, l2_offset)) {
140: cb(opaque, -EINVAL, 0, 0);
141: return;
142: }
143:
144: find_cluster_cb = qemu_malloc(sizeof(*find_cluster_cb));
145: find_cluster_cb->s = s;
146: find_cluster_cb->pos = pos;
147: find_cluster_cb->len = len;
148: find_cluster_cb->cb = cb;
149: find_cluster_cb->opaque = opaque;
150: find_cluster_cb->request = request;
151:
152: qed_read_l2_table(s, request, l2_offset,
153: qed_find_cluster_cb, find_cluster_cb);
154: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.