ShuriZma
/
xemu
mirror of https://github.com/xemu-project/xemu.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

exec: hide mr->ram_addr from qemu_get_ram_ptr users 

Let users of qemu_get_ram_ptr and qemu_ram_ptr_length pass in an
address that is relative to the MemoryRegion.  This basically means
what address_space_translate returns.

Because the semantics of the second parameter change, rename the
function to qemu_map_ram_ptr.

Reviewed-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
This commit is contained in:
Paolo Bonzini 2016-02-22 11:02:12 +01:00
parent 07bdaa4196
commit 0878d0e11b
4 changed files with 31 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

57
exec.c
View File

@ -1822,12 +1822,13 @@ void qemu_ram_remap(ram_addr_t addr, ram_addr_t length)
* *
* Called within RCU critical section. * Called within RCU critical section.
*/ */
void *qemu_get_ram_ptr(RAMBlock *ram_block, ram_addr_t addr) void *qemu_map_ram_ptr(RAMBlock *ram_block, ram_addr_t addr)
{ {
RAMBlock *block = ram_block; RAMBlock *block = ram_block;
if (block == NULL) { if (block == NULL) {
block = qemu_get_ram_block(addr); block = qemu_get_ram_block(addr);
addr -= block->offset;
} }
if (xen_enabled() && block->host == NULL) { if (xen_enabled() && block->host == NULL) {
@ -1841,10 +1842,10 @@ void *qemu_get_ram_ptr(RAMBlock *ram_block, ram_addr_t addr)
block->host = xen_map_cache(block->offset, block->max_length, 1); block->host = xen_map_cache(block->offset, block->max_length, 1);
} }
return ramblock_ptr(block, addr - block->offset); return ramblock_ptr(block, addr);
} }
/* Return a host pointer to guest's ram. Similar to qemu_get_ram_ptr /* Return a host pointer to guest's ram. Similar to qemu_map_ram_ptr
* but takes a size argument. * but takes a size argument.
* *
* Called within RCU critical section. * Called within RCU critical section.
@ -1853,16 +1854,15 @@ static void *qemu_ram_ptr_length(RAMBlock *ram_block, ram_addr_t addr,
hwaddr *size) hwaddr *size)
{ {
RAMBlock *block = ram_block; RAMBlock *block = ram_block;
ram_addr_t offset_inside_block;
if (*size == 0) { if (*size == 0) {
return NULL; return NULL;
} }
if (block == NULL) { if (block == NULL) {
block = qemu_get_ram_block(addr); block = qemu_get_ram_block(addr);
addr -= block->offset;
} }
offset_inside_block = addr - block->offset; *size = MIN(*size, block->max_length - addr);
*size = MIN(*size, block->max_length - offset_inside_block);
if (xen_enabled() && block->host == NULL) { if (xen_enabled() && block->host == NULL) {
/* We need to check if the requested address is in the RAM /* We need to check if the requested address is in the RAM
@ -1876,7 +1876,7 @@ static void *qemu_ram_ptr_length(RAMBlock *ram_block, ram_addr_t addr,
block->host = xen_map_cache(block->offset, block->max_length, 1); block->host = xen_map_cache(block->offset, block->max_length, 1);
} }
return ramblock_ptr(block, offset_inside_block); return ramblock_ptr(block, addr);
} }
/* /*
@ -1986,13 +1986,13 @@ static void notdirty_mem_write(void *opaque, hwaddr ram_addr,
} }
switch (size) { switch (size) {
case 1: case 1:
stb_p(qemu_get_ram_ptr(NULL, ram_addr), val); stb_p(qemu_map_ram_ptr(NULL, ram_addr), val);
break; break;
case 2: case 2:
stw_p(qemu_get_ram_ptr(NULL, ram_addr), val); stw_p(qemu_map_ram_ptr(NULL, ram_addr), val);
break; break;
case 4: case 4:
stl_p(qemu_get_ram_ptr(NULL, ram_addr), val); stl_p(qemu_map_ram_ptr(NULL, ram_addr), val);
break; break;
default: default:
abort(); abort();
@ -2454,6 +2454,8 @@ static void invalidate_and_set_dirty(MemoryRegion *mr, hwaddr addr,
hwaddr length) hwaddr length)
{ {
uint8_t dirty_log_mask = memory_region_get_dirty_log_mask(mr); uint8_t dirty_log_mask = memory_region_get_dirty_log_mask(mr);
addr += memory_region_get_ram_addr(mr);
/* No early return if dirty_log_mask is or becomes 0, because /* No early return if dirty_log_mask is or becomes 0, because
* cpu_physical_memory_set_dirty_range will still call * cpu_physical_memory_set_dirty_range will still call
* xen_modified_memory. * xen_modified_memory.
@ -2566,9 +2568,8 @@ static MemTxResult address_space_write_continue(AddressSpace *as, hwaddr addr,
abort(); abort();
} }
} else { } else {
addr1 += memory_region_get_ram_addr(mr);
/* RAM case */ /* RAM case */
ptr = qemu_get_ram_ptr(mr->ram_block, addr1); ptr = qemu_map_ram_ptr(mr->ram_block, addr1);
memcpy(ptr, buf, l); memcpy(ptr, buf, l);
invalidate_and_set_dirty(mr, addr1, l); invalidate_and_set_dirty(mr, addr1, l);
} }
@ -2659,8 +2660,7 @@ MemTxResult address_space_read_continue(AddressSpace *as, hwaddr addr,
} }
} else { } else {
/* RAM case */ /* RAM case */
ptr = qemu_get_ram_ptr(mr->ram_block, ptr = qemu_map_ram_ptr(mr->ram_block, addr1);
memory_region_get_ram_addr(mr) + addr1);
memcpy(buf, ptr, l); memcpy(buf, ptr, l);
} }
@ -2743,9 +2743,8 @@ static inline void cpu_physical_memory_write_rom_internal(AddressSpace *as,
memory_region_is_romd(mr))) { memory_region_is_romd(mr))) {
l = memory_access_size(mr, l, addr1); l = memory_access_size(mr, l, addr1);
} else { } else {
addr1 += memory_region_get_ram_addr(mr);
/* ROM/RAM case */ /* ROM/RAM case */
ptr = qemu_get_ram_ptr(mr->ram_block, addr1); ptr = qemu_map_ram_ptr(mr->ram_block, addr1);
switch (type) { switch (type) {
case WRITE_DATA: case WRITE_DATA:
memcpy(ptr, buf, l); memcpy(ptr, buf, l);
@ -2903,7 +2902,6 @@ void *address_space_map(AddressSpace *as,
hwaddr done = 0; hwaddr done = 0;
hwaddr l, xlat, base; hwaddr l, xlat, base;
MemoryRegion *mr, *this_mr; MemoryRegion *mr, *this_mr;
ram_addr_t raddr;
void *ptr; void *ptr;
if (len == 0) { if (len == 0) {
@ -2938,7 +2936,6 @@ void *address_space_map(AddressSpace *as,
} }
base = xlat; base = xlat;
raddr = memory_region_get_ram_addr(mr);
for (;;) { for (;;) {
len -= l; len -= l;
@ -2957,7 +2954,7 @@ void *address_space_map(AddressSpace *as,
memory_region_ref(mr); memory_region_ref(mr);
*plen = done; *plen = done;
ptr = qemu_ram_ptr_length(mr->ram_block, raddr + base, plen); ptr = qemu_ram_ptr_length(mr->ram_block, base, plen);
rcu_read_unlock(); rcu_read_unlock();
return ptr; return ptr;
@ -2976,7 +2973,6 @@ void address_space_unmap(AddressSpace *as, void *buffer, hwaddr len,
mr = memory_region_from_host(buffer, &addr1); mr = memory_region_from_host(buffer, &addr1);
assert(mr != NULL); assert(mr != NULL);
addr1 += memory_region_get_ram_addr(mr);
if (is_write) { if (is_write) {
invalidate_and_set_dirty(mr, addr1, access_len); invalidate_and_set_dirty(mr, addr1, access_len);
} }
@ -3042,8 +3038,7 @@ static inline uint32_t address_space_ldl_internal(AddressSpace *as, hwaddr addr,
#endif #endif
} else { } else {
/* RAM case */ /* RAM case */
ptr = qemu_get_ram_ptr(mr->ram_block, ptr = qemu_map_ram_ptr(mr->ram_block, addr1);
memory_region_get_ram_addr(mr) + addr1);
switch (endian) { switch (endian) {
case DEVICE_LITTLE_ENDIAN: case DEVICE_LITTLE_ENDIAN:
val = ldl_le_p(ptr); val = ldl_le_p(ptr);
@ -3136,8 +3131,7 @@ static inline uint64_t address_space_ldq_internal(AddressSpace *as, hwaddr addr,
#endif #endif
} else { } else {
/* RAM case */ /* RAM case */
ptr = qemu_get_ram_ptr(mr->ram_block, ptr = qemu_map_ram_ptr(mr->ram_block, addr1);
memory_region_get_ram_addr(mr) + addr1);
switch (endian) { switch (endian) {
case DEVICE_LITTLE_ENDIAN: case DEVICE_LITTLE_ENDIAN:
val = ldq_le_p(ptr); val = ldq_le_p(ptr);
@ -3250,8 +3244,7 @@ static inline uint32_t address_space_lduw_internal(AddressSpace *as,
#endif #endif
} else { } else {
/* RAM case */ /* RAM case */
ptr = qemu_get_ram_ptr(mr->ram_block, ptr = qemu_map_ram_ptr(mr->ram_block, addr1);
memory_region_get_ram_addr(mr) + addr1);
switch (endian) { switch (endian) {
case DEVICE_LITTLE_ENDIAN: case DEVICE_LITTLE_ENDIAN:
val = lduw_le_p(ptr); val = lduw_le_p(ptr);
@ -3333,13 +3326,13 @@ void address_space_stl_notdirty(AddressSpace *as, hwaddr addr, uint32_t val,
r = memory_region_dispatch_write(mr, addr1, val, 4, attrs); r = memory_region_dispatch_write(mr, addr1, val, 4, attrs);
} else { } else {
addr1 += memory_region_get_ram_addr(mr); ptr = qemu_map_ram_ptr(mr->ram_block, addr1);
ptr = qemu_get_ram_ptr(mr->ram_block, addr1);
stl_p(ptr, val); stl_p(ptr, val);
dirty_log_mask = memory_region_get_dirty_log_mask(mr); dirty_log_mask = memory_region_get_dirty_log_mask(mr);
dirty_log_mask &= ~(1 << DIRTY_MEMORY_CODE); dirty_log_mask &= ~(1 << DIRTY_MEMORY_CODE);
cpu_physical_memory_set_dirty_range(addr1, 4, dirty_log_mask); cpu_physical_memory_set_dirty_range(memory_region_get_ram_addr(mr) + addr,
4, dirty_log_mask);
r = MEMTX_OK; r = MEMTX_OK;
} }
if (result) { if (result) {
@ -3388,8 +3381,7 @@ static inline void address_space_stl_internal(AddressSpace *as,
r = memory_region_dispatch_write(mr, addr1, val, 4, attrs); r = memory_region_dispatch_write(mr, addr1, val, 4, attrs);
} else { } else {
/* RAM case */ /* RAM case */
addr1 += memory_region_get_ram_addr(mr); ptr = qemu_map_ram_ptr(mr->ram_block, addr1);
ptr = qemu_get_ram_ptr(mr->ram_block, addr1);
switch (endian) { switch (endian) {
case DEVICE_LITTLE_ENDIAN: case DEVICE_LITTLE_ENDIAN:
stl_le_p(ptr, val); stl_le_p(ptr, val);
@ -3498,8 +3490,7 @@ static inline void address_space_stw_internal(AddressSpace *as,
r = memory_region_dispatch_write(mr, addr1, val, 2, attrs); r = memory_region_dispatch_write(mr, addr1, val, 2, attrs);
} else { } else {
/* RAM case */ /* RAM case */
addr1 += memory_region_get_ram_addr(mr); ptr = qemu_map_ram_ptr(mr->ram_block, addr1);
ptr = qemu_get_ram_ptr(mr->ram_block, addr1);
switch (endian) { switch (endian) {
case DEVICE_LITTLE_ENDIAN: case DEVICE_LITTLE_ENDIAN:
stw_le_p(ptr, val); stw_le_p(ptr, val);

5
include/exec/memory.h
View File

@ -1393,7 +1393,7 @@ MemTxResult address_space_read_continue(AddressSpace *as, hwaddr addr,
MemoryRegion *mr); MemoryRegion *mr);
MemTxResult address_space_read_full(AddressSpace *as, hwaddr addr, MemTxResult address_space_read_full(AddressSpace *as, hwaddr addr,
MemTxAttrs attrs, uint8_t *buf, int len); MemTxAttrs attrs, uint8_t *buf, int len);
void *qemu_get_ram_ptr(RAMBlock *ram_block, ram_addr_t addr); void *qemu_map_ram_ptr(RAMBlock *ram_block, ram_addr_t addr);
static inline bool memory_access_is_direct(MemoryRegion *mr, bool is_write) static inline bool memory_access_is_direct(MemoryRegion *mr, bool is_write)
{ {
@ -1431,8 +1431,7 @@ MemTxResult address_space_read(AddressSpace *as, hwaddr addr, MemTxAttrs attrs,
l = len; l = len;
mr = address_space_translate(as, addr, &addr1, &l, false); mr = address_space_translate(as, addr, &addr1, &l, false);
if (len == l && memory_access_is_direct(mr, false)) { if (len == l && memory_access_is_direct(mr, false)) {
addr1 += memory_region_get_ram_addr(mr); ptr = qemu_map_ram_ptr(mr->ram_block, addr1);
ptr = qemu_get_ram_ptr(mr->ram_block, addr1);
memcpy(buf, ptr, len); memcpy(buf, ptr, len);
} else { } else {
result = address_space_read_continue(as, addr, attrs, buf, len, result = address_space_read_continue(as, addr, attrs, buf, len,

4
memory.c
View File

@ -1657,10 +1657,10 @@ void *memory_region_get_ram_ptr(MemoryRegion *mr)
mr = mr->alias; mr = mr->alias;
} }
assert(mr->ram_block); assert(mr->ram_block);
ptr = qemu_get_ram_ptr(mr->ram_block, memory_region_get_ram_addr(mr)); ptr = qemu_map_ram_ptr(mr->ram_block, offset);
rcu_read_unlock(); rcu_read_unlock();
return ptr + offset; return ptr;
} }
MemoryRegion *memory_region_from_host(void *ptr, ram_addr_t *offset) MemoryRegion *memory_region_from_host(void *ptr, ram_addr_t *offset)

19
scripts/dump-guest-memory.py
View File

@ -328,23 +328,10 @@ def qlist_foreach(head, field_str):
yield var yield var
def qemu_get_ram_block(ram_addr): def qemu_map_ram_ptr(block, offset):
"""Returns the RAMBlock struct to which the given address belongs."""
ram_blocks = gdb.parse_and_eval("ram_list.blocks")
for block in qlist_foreach(ram_blocks, "next"):
if (ram_addr - block["offset"]) < block["used_length"]:
return block
raise gdb.GdbError("Bad ram offset %x" % ram_addr)
def qemu_get_ram_ptr(ram_addr):
"""Returns qemu vaddr for given guest physical address.""" """Returns qemu vaddr for given guest physical address."""
block = qemu_get_ram_block(ram_addr) return block["host"] + offset
return block["host"] + (ram_addr - block["offset"])
def memory_region_get_ram_ptr(memory_region): def memory_region_get_ram_ptr(memory_region):
@ -352,7 +339,7 @@ def memory_region_get_ram_ptr(memory_region):
return (memory_region_get_ram_ptr(memory_region["alias"].dereference()) return (memory_region_get_ram_ptr(memory_region["alias"].dereference())
+ memory_region["alias_offset"]) + memory_region["alias_offset"])
return qemu_get_ram_ptr(memory_region["ram_block"]["offset"]) return qemu_map_ram_ptr(memory_region["ram_block"], 0)
def get_guest_phys_blocks(): def get_guest_phys_blocks():