mirrors/qemu
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

memory: abstract cracking of write access ops into a function

Browse Source 
The memory API automatically cracks large reads and writes into smaller
ones when needed.  Factor out this mechanism, which is now duplicated between
memory reads and memory writes, into a function.

Signed-off-by: Avi Kivity <avi@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
This commit is contained in:
Avi Kivity 2011-08-11 10:40:25 +03:00 committed by Anthony Liguori
parent 30c2f2388a
commit 164a4dcd8d
1 changed files with 68 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

109
memory.c
View File

@ -226,6 +226,65 @@ static void flatview_simplify(FlatView *view)
}
}
static void memory_region_read_accessor(void *opaque,
target_phys_addr_t addr,
uint64_t *value,
unsigned size,
unsigned shift,
uint64_t mask)
{
MemoryRegion *mr = opaque;
uint64_t tmp;
tmp = mr->ops->read(mr->opaque, addr, size);
*value |= (tmp & mask) << shift;
}
static void memory_region_write_accessor(void *opaque,
target_phys_addr_t addr,
uint64_t *value,
unsigned size,
unsigned shift,
uint64_t mask)
{
MemoryRegion *mr = opaque;
uint64_t tmp;
tmp = (*value >> shift) & mask;
mr->ops->write(mr->opaque, addr, tmp, size);
}
static void access_with_adjusted_size(target_phys_addr_t addr,
uint64_t *value,
unsigned size,
unsigned access_size_min,
unsigned access_size_max,
void (*access)(void *opaque,
target_phys_addr_t addr,
uint64_t *value,
unsigned size,
unsigned shift,
uint64_t mask),
void *opaque)
{
uint64_t access_mask;
unsigned access_size;
unsigned i;
if (!access_size_min) {
access_size_min = 1;
}
if (!access_size_max) {
access_size_max = 4;
}
access_size = MAX(MIN(size, access_size_max), access_size_min);
access_mask = -1ULL >> (64 - access_size * 8);
for (i = 0; i < size; i += access_size) {
/* FIXME: big-endian support */
access(opaque, addr + i, value, access_size, i * 8, access_mask);
}
}
static void memory_region_prepare_ram_addr(MemoryRegion *mr);
static void as_memory_range_add(AddressSpace *as, FlatRange *fr)
@ -744,10 +803,7 @@ static uint32_t memory_region_read_thunk_n(void *_mr,
unsigned size)
{
MemoryRegion *mr = _mr;
unsigned access_size, access_size_min, access_size_max;
uint64_t access_mask;
uint32_t data = 0, tmp;
unsigned i;
uint64_t data = 0;
if (!memory_region_access_valid(mr, addr, size)) {
return -1U; /* FIXME: better signalling */
@ -758,23 +814,10 @@ static uint32_t memory_region_read_thunk_n(void *_mr,
}
/* FIXME: support unaligned access */
access_size_min = mr->ops->impl.min_access_size;
if (!access_size_min) {
access_size_min = 1;
}
access_size_max = mr->ops->impl.max_access_size;
if (!access_size_max) {
access_size_max = 4;
}
access_size = MAX(MIN(size, access_size_max), access_size_min);
access_mask = -1ULL >> (64 - access_size * 8);
addr += mr->offset;
for (i = 0; i < size; i += access_size) {
/* FIXME: big-endian support */
tmp = mr->ops->read(mr->opaque, addr + i, access_size);
data |= (tmp & access_mask) << (i * 8);
}
access_with_adjusted_size(addr + mr->offset, &data, size,
mr->ops->impl.min_access_size,
mr->ops->impl.max_access_size,
memory_region_read_accessor, mr);
return data;
}
@ -785,9 +828,6 @@ static void memory_region_write_thunk_n(void *_mr,
uint64_t data)
{
MemoryRegion *mr = _mr;
unsigned access_size, access_size_min, access_size_max;
uint64_t access_mask;
unsigned i;
if (!memory_region_access_valid(mr, addr, size)) {
return; /* FIXME: better signalling */
@ -799,23 +839,10 @@ static void memory_region_write_thunk_n(void *_mr,
}
/* FIXME: support unaligned access */
access_size_min = mr->ops->impl.min_access_size;
if (!access_size_min) {
access_size_min = 1;
}
access_size_max = mr->ops->impl.max_access_size;
if (!access_size_max) {
access_size_max = 4;
}
access_size = MAX(MIN(size, access_size_max), access_size_min);
access_mask = -1ULL >> (64 - access_size * 8);
addr += mr->offset;
for (i = 0; i < size; i += access_size) {
/* FIXME: big-endian support */
mr->ops->write(mr->opaque, addr + i, (data >> (i * 8)) & access_mask,
access_size);
}
access_with_adjusted_size(addr + mr->offset, &data, size,
mr->ops->impl.min_access_size,
mr->ops->impl.max_access_size,
memory_region_write_accessor, mr);
}
static uint32_t memory_region_read_thunk_b(void *mr, target_phys_addr_t addr)