142 lines
4.6 KiB
C
142 lines
4.6 KiB
C
/*
|
|
* QEMU Enhanced Disk Format Cluster functions
|
|
*
|
|
* Copyright IBM, Corp. 2010
|
|
*
|
|
* Authors:
|
|
* Stefan Hajnoczi <stefanha@linux.vnet.ibm.com>
|
|
* Anthony Liguori <aliguori@us.ibm.com>
|
|
*
|
|
* This work is licensed under the terms of the GNU LGPL, version 2 or later.
|
|
* See the COPYING.LIB file in the top-level directory.
|
|
*
|
|
*/
|
|
|
|
#include "qemu/osdep.h"
|
|
#include "qed.h"
|
|
|
|
/**
|
|
* Count the number of contiguous data clusters
|
|
*
|
|
* @s: QED state
|
|
* @table: L2 table
|
|
* @index: First cluster index
|
|
* @n: Maximum number of clusters
|
|
* @offset: Set to first cluster offset
|
|
*
|
|
* This function scans tables for contiguous clusters. A contiguous run of
|
|
* clusters may be allocated, unallocated, or zero.
|
|
*/
|
|
static unsigned int qed_count_contiguous_clusters(BDRVQEDState *s,
|
|
QEDTable *table,
|
|
unsigned int index,
|
|
unsigned int n,
|
|
uint64_t *offset)
|
|
{
|
|
unsigned int end = MIN(index + n, s->table_nelems);
|
|
uint64_t last = table->offsets[index];
|
|
unsigned int i;
|
|
|
|
*offset = last;
|
|
|
|
for (i = index + 1; i < end; i++) {
|
|
if (qed_offset_is_unalloc_cluster(last)) {
|
|
/* Counting unallocated clusters */
|
|
if (!qed_offset_is_unalloc_cluster(table->offsets[i])) {
|
|
break;
|
|
}
|
|
} else if (qed_offset_is_zero_cluster(last)) {
|
|
/* Counting zero clusters */
|
|
if (!qed_offset_is_zero_cluster(table->offsets[i])) {
|
|
break;
|
|
}
|
|
} else {
|
|
/* Counting allocated clusters */
|
|
if (table->offsets[i] != last + s->header.cluster_size) {
|
|
break;
|
|
}
|
|
last = table->offsets[i];
|
|
}
|
|
}
|
|
return i - index;
|
|
}
|
|
|
|
/**
|
|
* Find the offset of a data cluster
|
|
*
|
|
* @s: QED state
|
|
* @request: L2 cache entry
|
|
* @pos: Byte position in device
|
|
* @len: Number of bytes (may be shortened on return)
|
|
* @img_offset: Contains offset in the image file on success
|
|
*
|
|
* This function translates a position in the block device to an offset in the
|
|
* image file. The translated offset or unallocated range in the image file is
|
|
* reported back in *img_offset and *len.
|
|
*
|
|
* If the L2 table exists, request->l2_table points to the L2 table cache entry
|
|
* and the caller must free the reference when they are finished. The cache
|
|
* entry is exposed in this way to avoid callers having to read the L2 table
|
|
* again later during request processing. If request->l2_table is non-NULL it
|
|
* will be unreferenced before taking on the new cache entry.
|
|
*
|
|
* On success QED_CLUSTER_FOUND is returned and img_offset/len are a contiguous
|
|
* range in the image file.
|
|
*
|
|
* On failure QED_CLUSTER_L2 or QED_CLUSTER_L1 is returned for missing L2 or L1
|
|
* table offset, respectively. len is number of contiguous unallocated bytes.
|
|
*
|
|
* Called with table_lock held.
|
|
*/
|
|
int coroutine_fn qed_find_cluster(BDRVQEDState *s, QEDRequest *request,
|
|
uint64_t pos, size_t *len,
|
|
uint64_t *img_offset)
|
|
{
|
|
uint64_t l2_offset;
|
|
uint64_t offset = 0;
|
|
unsigned int index;
|
|
unsigned int n;
|
|
int ret;
|
|
|
|
/* Limit length to L2 boundary. Requests are broken up at the L2 boundary
|
|
* so that a request acts on one L2 table at a time.
|
|
*/
|
|
*len = MIN(*len, (((pos >> s->l1_shift) + 1) << s->l1_shift) - pos);
|
|
|
|
l2_offset = s->l1_table->offsets[qed_l1_index(s, pos)];
|
|
if (qed_offset_is_unalloc_cluster(l2_offset)) {
|
|
*img_offset = 0;
|
|
return QED_CLUSTER_L1;
|
|
}
|
|
if (!qed_check_table_offset(s, l2_offset)) {
|
|
*img_offset = *len = 0;
|
|
return -EINVAL;
|
|
}
|
|
|
|
ret = qed_read_l2_table(s, request, l2_offset);
|
|
if (ret) {
|
|
goto out;
|
|
}
|
|
|
|
index = qed_l2_index(s, pos);
|
|
n = qed_bytes_to_clusters(s, qed_offset_into_cluster(s, pos) + *len);
|
|
n = qed_count_contiguous_clusters(s, request->l2_table->table,
|
|
index, n, &offset);
|
|
|
|
if (qed_offset_is_unalloc_cluster(offset)) {
|
|
ret = QED_CLUSTER_L2;
|
|
} else if (qed_offset_is_zero_cluster(offset)) {
|
|
ret = QED_CLUSTER_ZERO;
|
|
} else if (qed_check_cluster_offset(s, offset)) {
|
|
ret = QED_CLUSTER_FOUND;
|
|
} else {
|
|
ret = -EINVAL;
|
|
}
|
|
|
|
*len = MIN(*len,
|
|
n * s->header.cluster_size - qed_offset_into_cluster(s, pos));
|
|
|
|
out:
|
|
*img_offset = offset;
|
|
return ret;
|
|
}
|