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

rcu: Use automatic rc_read unlock in core memory/exec code 

Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Message-Id: <20191007143642.301445-6-dgilbert@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
This commit is contained in:
Dr. David Alan Gilbert 2019-10-07 15:36:41 +01:00
parent 987ab2a549
commit 694ea274d9
3 changed files with 125 additions and 158 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

64
exec.c
View File

@ -1037,16 +1037,14 @@ void tb_invalidate_phys_addr(AddressSpace *as, hwaddr addr, MemTxAttrs attrs)
return; return;
} }
rcu_read_lock(); RCU_READ_LOCK_GUARD();
mr = address_space_translate(as, addr, &addr, &l, false, attrs); mr = address_space_translate(as, addr, &addr, &l, false, attrs);
if (!(memory_region_is_ram(mr) if (!(memory_region_is_ram(mr)
|| memory_region_is_romd(mr))) { || memory_region_is_romd(mr))) {
rcu_read_unlock();
return; return;
} }
ram_addr = memory_region_get_ram_addr(mr) + addr; ram_addr = memory_region_get_ram_addr(mr) + addr;
tb_invalidate_phys_page_range(ram_addr, ram_addr + 1); tb_invalidate_phys_page_range(ram_addr, ram_addr + 1);
rcu_read_unlock();
} }
static void breakpoint_invalidate(CPUState *cpu, target_ulong pc) static void breakpoint_invalidate(CPUState *cpu, target_ulong pc)
@ -1332,14 +1330,13 @@ static void tlb_reset_dirty_range_all(ram_addr_t start, ram_addr_t length)
end = TARGET_PAGE_ALIGN(start + length); end = TARGET_PAGE_ALIGN(start + length);
start &= TARGET_PAGE_MASK; start &= TARGET_PAGE_MASK;
rcu_read_lock(); RCU_READ_LOCK_GUARD();
block = qemu_get_ram_block(start); block = qemu_get_ram_block(start);
assert(block == qemu_get_ram_block(end - 1)); assert(block == qemu_get_ram_block(end - 1));
start1 = (uintptr_t)ramblock_ptr(block, start - block->offset); start1 = (uintptr_t)ramblock_ptr(block, start - block->offset);
CPU_FOREACH(cpu) { CPU_FOREACH(cpu) {
tlb_reset_dirty(cpu, start1, length); tlb_reset_dirty(cpu, start1, length);
} }
rcu_read_unlock();
} }
/* Note: start and end must be within the same ram block. */ /* Note: start and end must be within the same ram block. */
@ -1360,8 +1357,7 @@ bool cpu_physical_memory_test_and_clear_dirty(ram_addr_t start,
end = TARGET_PAGE_ALIGN(start + length) >> TARGET_PAGE_BITS; end = TARGET_PAGE_ALIGN(start + length) >> TARGET_PAGE_BITS;
page = start >> TARGET_PAGE_BITS; page = start >> TARGET_PAGE_BITS;
rcu_read_lock(); WITH_RCU_READ_LOCK_GUARD() {
blocks = atomic_rcu_read(&ram_list.dirty_memory[client]); blocks = atomic_rcu_read(&ram_list.dirty_memory[client]);
ramblock = qemu_get_ram_block(start); ramblock = qemu_get_ram_block(start);
/* Range sanity check on the ramblock */ /* Range sanity check on the ramblock */
@ -1371,7 +1367,8 @@ bool cpu_physical_memory_test_and_clear_dirty(ram_addr_t start,
while (page < end) { while (page < end) {
unsigned long idx = page / DIRTY_MEMORY_BLOCK_SIZE; unsigned long idx = page / DIRTY_MEMORY_BLOCK_SIZE;
unsigned long offset = page % DIRTY_MEMORY_BLOCK_SIZE; unsigned long offset = page % DIRTY_MEMORY_BLOCK_SIZE;
unsigned long num = MIN(end - page, DIRTY_MEMORY_BLOCK_SIZE - offset); unsigned long num = MIN(end - page,
DIRTY_MEMORY_BLOCK_SIZE - offset);
dirty |= bitmap_test_and_clear_atomic(blocks->blocks[idx], dirty |= bitmap_test_and_clear_atomic(blocks->blocks[idx],
offset, num); offset, num);
@ -1381,8 +1378,7 @@ bool cpu_physical_memory_test_and_clear_dirty(ram_addr_t start,
mr_offset = (ram_addr_t)(page << TARGET_PAGE_BITS) - ramblock->offset; mr_offset = (ram_addr_t)(page << TARGET_PAGE_BITS) - ramblock->offset;
mr_size = (end - page) << TARGET_PAGE_BITS; mr_size = (end - page) << TARGET_PAGE_BITS;
memory_region_clear_dirty_bitmap(ramblock->mr, mr_offset, mr_size); memory_region_clear_dirty_bitmap(ramblock->mr, mr_offset, mr_size);
}
rcu_read_unlock();
if (dirty && tcg_enabled()) { if (dirty && tcg_enabled()) {
tlb_reset_dirty_range_all(start, length); tlb_reset_dirty_range_all(start, length);
@ -1411,14 +1407,14 @@ DirtyBitmapSnapshot *cpu_physical_memory_snapshot_and_clear_dirty
end = last >> TARGET_PAGE_BITS; end = last >> TARGET_PAGE_BITS;
dest = 0; dest = 0;
rcu_read_lock(); WITH_RCU_READ_LOCK_GUARD() {
blocks = atomic_rcu_read(&ram_list.dirty_memory[client]); blocks = atomic_rcu_read(&ram_list.dirty_memory[client]);
while (page < end) { while (page < end) {
unsigned long idx = page / DIRTY_MEMORY_BLOCK_SIZE; unsigned long idx = page / DIRTY_MEMORY_BLOCK_SIZE;
unsigned long offset = page % DIRTY_MEMORY_BLOCK_SIZE; unsigned long offset = page % DIRTY_MEMORY_BLOCK_SIZE;
unsigned long num = MIN(end - page, DIRTY_MEMORY_BLOCK_SIZE - offset); unsigned long num = MIN(end - page,
DIRTY_MEMORY_BLOCK_SIZE - offset);
assert(QEMU_IS_ALIGNED(offset, (1 << BITS_PER_LEVEL))); assert(QEMU_IS_ALIGNED(offset, (1 << BITS_PER_LEVEL)));
assert(QEMU_IS_ALIGNED(num, (1 << BITS_PER_LEVEL))); assert(QEMU_IS_ALIGNED(num, (1 << BITS_PER_LEVEL)));
@ -1430,8 +1426,7 @@ DirtyBitmapSnapshot *cpu_physical_memory_snapshot_and_clear_dirty
page += num; page += num;
dest += num >> BITS_PER_LEVEL; dest += num >> BITS_PER_LEVEL;
} }
}
rcu_read_unlock();
if (tcg_enabled()) { if (tcg_enabled()) {
tlb_reset_dirty_range_all(start, length); tlb_reset_dirty_range_all(start, length);
@ -1643,7 +1638,7 @@ void ram_block_dump(Monitor *mon)
RAMBlock *block; RAMBlock *block;
char *psize; char *psize;
rcu_read_lock(); RCU_READ_LOCK_GUARD();
monitor_printf(mon, "%24s %8s %18s %18s %18s\n", monitor_printf(mon, "%24s %8s %18s %18s %18s\n",
"Block Name", "PSize", "Offset", "Used", "Total"); "Block Name", "PSize", "Offset", "Used", "Total");
RAMBLOCK_FOREACH(block) { RAMBLOCK_FOREACH(block) {
@ -1655,7 +1650,6 @@ void ram_block_dump(Monitor *mon)
(uint64_t)block->max_length); (uint64_t)block->max_length);
g_free(psize); g_free(psize);
} }
rcu_read_unlock();
} }
#ifdef __linux__ #ifdef __linux__
@ -2009,11 +2003,10 @@ static unsigned long last_ram_page(void)
RAMBlock *block; RAMBlock *block;
ram_addr_t last = 0; ram_addr_t last = 0;
rcu_read_lock(); RCU_READ_LOCK_GUARD();
RAMBLOCK_FOREACH(block) { RAMBLOCK_FOREACH(block) {
last = MAX(last, block->offset + block->max_length); last = MAX(last, block->offset + block->max_length);
} }
rcu_read_unlock();
return last >> TARGET_PAGE_BITS; return last >> TARGET_PAGE_BITS;
} }
@ -2100,7 +2093,7 @@ void qemu_ram_set_idstr(RAMBlock *new_block, const char *name, DeviceState *dev)
} }
pstrcat(new_block->idstr, sizeof(new_block->idstr), name); pstrcat(new_block->idstr, sizeof(new_block->idstr), name);
rcu_read_lock(); RCU_READ_LOCK_GUARD();
RAMBLOCK_FOREACH(block) { RAMBLOCK_FOREACH(block) {
if (block != new_block && if (block != new_block &&
!strcmp(block->idstr, new_block->idstr)) { !strcmp(block->idstr, new_block->idstr)) {
@ -2109,7 +2102,6 @@ void qemu_ram_set_idstr(RAMBlock *new_block, const char *name, DeviceState *dev)
abort(); abort();
} }
} }
rcu_read_unlock();
} }
/* Called with iothread lock held. */ /* Called with iothread lock held. */
@ -2651,17 +2643,16 @@ RAMBlock *qemu_ram_block_from_host(void *ptr, bool round_offset,
if (xen_enabled()) { if (xen_enabled()) {
ram_addr_t ram_addr; ram_addr_t ram_addr;
rcu_read_lock(); RCU_READ_LOCK_GUARD();
ram_addr = xen_ram_addr_from_mapcache(ptr); ram_addr = xen_ram_addr_from_mapcache(ptr);
block = qemu_get_ram_block(ram_addr); block = qemu_get_ram_block(ram_addr);
if (block) { if (block) {
*offset = ram_addr - block->offset; *offset = ram_addr - block->offset;
} }
rcu_read_unlock();
return block; return block;
} }
rcu_read_lock(); RCU_READ_LOCK_GUARD();
block = atomic_rcu_read(&ram_list.mru_block); block = atomic_rcu_read(&ram_list.mru_block);
if (block && block->host && host - block->host < block->max_length) { if (block && block->host && host - block->host < block->max_length) {
goto found; goto found;
@ -2677,7 +2668,6 @@ RAMBlock *qemu_ram_block_from_host(void *ptr, bool round_offset,
} }
} }
rcu_read_unlock();
return NULL; return NULL;
found: found:
@ -2685,7 +2675,6 @@ found:
if (round_offset) { if (round_offset) {
*offset &= TARGET_PAGE_MASK; *offset &= TARGET_PAGE_MASK;
} }
rcu_read_unlock();
return block; return block;
} }
@ -3281,10 +3270,9 @@ MemTxResult address_space_read_full(AddressSpace *as, hwaddr addr,
FlatView *fv; FlatView *fv;
if (len > 0) { if (len > 0) {
rcu_read_lock(); RCU_READ_LOCK_GUARD();
fv = address_space_to_flatview(as); fv = address_space_to_flatview(as);
result = flatview_read(fv, addr, attrs, buf, len); result = flatview_read(fv, addr, attrs, buf, len);
rcu_read_unlock();
} }
return result; return result;
@ -3298,10 +3286,9 @@ MemTxResult address_space_write(AddressSpace *as, hwaddr addr,
FlatView *fv; FlatView *fv;
if (len > 0) { if (len > 0) {
rcu_read_lock(); RCU_READ_LOCK_GUARD();
fv = address_space_to_flatview(as); fv = address_space_to_flatview(as);
result = flatview_write(fv, addr, attrs, buf, len); result = flatview_write(fv, addr, attrs, buf, len);
rcu_read_unlock();
} }
return result; return result;
@ -3341,7 +3328,7 @@ static inline MemTxResult address_space_write_rom_internal(AddressSpace *as,
hwaddr addr1; hwaddr addr1;
MemoryRegion *mr; MemoryRegion *mr;
rcu_read_lock(); RCU_READ_LOCK_GUARD();
while (len > 0) { while (len > 0) {
l = len; l = len;
mr = address_space_translate(as, addr, &addr1, &l, true, attrs); mr = address_space_translate(as, addr, &addr1, &l, true, attrs);
@ -3366,7 +3353,6 @@ static inline MemTxResult address_space_write_rom_internal(AddressSpace *as,
buf += l; buf += l;
addr += l; addr += l;
} }
rcu_read_unlock();
return MEMTX_OK; return MEMTX_OK;
} }
@ -3511,10 +3497,9 @@ bool address_space_access_valid(AddressSpace *as, hwaddr addr,
FlatView *fv; FlatView *fv;
bool result; bool result;
rcu_read_lock(); RCU_READ_LOCK_GUARD();
fv = address_space_to_flatview(as); fv = address_space_to_flatview(as);
result = flatview_access_valid(fv, addr, len, is_write, attrs); result = flatview_access_valid(fv, addr, len, is_write, attrs);
rcu_read_unlock();
return result; return result;
} }
@ -3569,13 +3554,12 @@ void *address_space_map(AddressSpace *as,
} }
l = len; l = len;
rcu_read_lock(); RCU_READ_LOCK_GUARD();
fv = address_space_to_flatview(as); fv = address_space_to_flatview(as);
mr = flatview_translate(fv, addr, &xlat, &l, is_write, attrs); mr = flatview_translate(fv, addr, &xlat, &l, is_write, attrs);
if (!memory_access_is_direct(mr, is_write)) { if (!memory_access_is_direct(mr, is_write)) {
if (atomic_xchg(&bounce.in_use, true)) { if (atomic_xchg(&bounce.in_use, true)) {
rcu_read_unlock();
return NULL; return NULL;
} }
/* Avoid unbounded allocations */ /* Avoid unbounded allocations */
@ -3591,7 +3575,6 @@ void *address_space_map(AddressSpace *as,
bounce.buffer, l); bounce.buffer, l);
} }
rcu_read_unlock();
*plen = l; *plen = l;
return bounce.buffer; return bounce.buffer;
} }
@ -3601,7 +3584,6 @@ void *address_space_map(AddressSpace *as,
*plen = flatview_extend_translation(fv, addr, len, mr, xlat, *plen = flatview_extend_translation(fv, addr, len, mr, xlat,
l, is_write, attrs); l, is_write, attrs);
ptr = qemu_ram_ptr_length(mr->ram_block, xlat, plen, true); ptr = qemu_ram_ptr_length(mr->ram_block, xlat, plen, true);
rcu_read_unlock();
return ptr; return ptr;
} }
@ -3869,13 +3851,12 @@ bool cpu_physical_memory_is_io(hwaddr phys_addr)
hwaddr l = 1; hwaddr l = 1;
bool res; bool res;
rcu_read_lock(); RCU_READ_LOCK_GUARD();
mr = address_space_translate(&address_space_memory, mr = address_space_translate(&address_space_memory,
phys_addr, &phys_addr, &l, false, phys_addr, &phys_addr, &l, false,
MEMTXATTRS_UNSPECIFIED); MEMTXATTRS_UNSPECIFIED);
res = !(memory_region_is_ram(mr) || memory_region_is_romd(mr)); res = !(memory_region_is_ram(mr) || memory_region_is_romd(mr));
rcu_read_unlock();
return res; return res;
} }
@ -3884,14 +3865,13 @@ int qemu_ram_foreach_block(RAMBlockIterFunc func, void *opaque)
RAMBlock *block; RAMBlock *block;
int ret = 0; int ret = 0;
rcu_read_lock(); RCU_READ_LOCK_GUARD();
RAMBLOCK_FOREACH(block) { RAMBLOCK_FOREACH(block) {
ret = func(block, opaque); ret = func(block, opaque);
if (ret) { if (ret) {
break; break;
} }
} }
rcu_read_unlock();
return ret; return ret;
} }

32
include/exec/ram_addr.h
View File

@ -193,8 +193,7 @@ static inline bool cpu_physical_memory_get_dirty(ram_addr_t start,
end = TARGET_PAGE_ALIGN(start + length) >> TARGET_PAGE_BITS; end = TARGET_PAGE_ALIGN(start + length) >> TARGET_PAGE_BITS;
page = start >> TARGET_PAGE_BITS; page = start >> TARGET_PAGE_BITS;
rcu_read_lock(); WITH_RCU_READ_LOCK_GUARD() {
blocks = atomic_rcu_read(&ram_list.dirty_memory[client]); blocks = atomic_rcu_read(&ram_list.dirty_memory[client]);
idx = page / DIRTY_MEMORY_BLOCK_SIZE; idx = page / DIRTY_MEMORY_BLOCK_SIZE;
@ -203,7 +202,8 @@ static inline bool cpu_physical_memory_get_dirty(ram_addr_t start,
while (page < end) { while (page < end) {
unsigned long next = MIN(end, base + DIRTY_MEMORY_BLOCK_SIZE); unsigned long next = MIN(end, base + DIRTY_MEMORY_BLOCK_SIZE);
unsigned long num = next - base; unsigned long num = next - base;
unsigned long found = find_next_bit(blocks->blocks[idx], num, offset); unsigned long found = find_next_bit(blocks->blocks[idx],
num, offset);
if (found < num) { if (found < num) {
dirty = true; dirty = true;
break; break;
@ -214,8 +214,7 @@ static inline bool cpu_physical_memory_get_dirty(ram_addr_t start,
offset = 0; offset = 0;
base += DIRTY_MEMORY_BLOCK_SIZE; base += DIRTY_MEMORY_BLOCK_SIZE;
} }
}
rcu_read_unlock();
return dirty; return dirty;
} }
@ -234,7 +233,7 @@ static inline bool cpu_physical_memory_all_dirty(ram_addr_t start,
end = TARGET_PAGE_ALIGN(start + length) >> TARGET_PAGE_BITS; end = TARGET_PAGE_ALIGN(start + length) >> TARGET_PAGE_BITS;
page = start >> TARGET_PAGE_BITS; page = start >> TARGET_PAGE_BITS;
rcu_read_lock(); RCU_READ_LOCK_GUARD();
blocks = atomic_rcu_read(&ram_list.dirty_memory[client]); blocks = atomic_rcu_read(&ram_list.dirty_memory[client]);
@ -256,8 +255,6 @@ static inline bool cpu_physical_memory_all_dirty(ram_addr_t start,
base += DIRTY_MEMORY_BLOCK_SIZE; base += DIRTY_MEMORY_BLOCK_SIZE;
} }
rcu_read_unlock();
return dirty; return dirty;
} }
@ -309,13 +306,11 @@ static inline void cpu_physical_memory_set_dirty_flag(ram_addr_t addr,
idx = page / DIRTY_MEMORY_BLOCK_SIZE; idx = page / DIRTY_MEMORY_BLOCK_SIZE;
offset = page % DIRTY_MEMORY_BLOCK_SIZE; offset = page % DIRTY_MEMORY_BLOCK_SIZE;
rcu_read_lock(); RCU_READ_LOCK_GUARD();
blocks = atomic_rcu_read(&ram_list.dirty_memory[client]); blocks = atomic_rcu_read(&ram_list.dirty_memory[client]);
set_bit_atomic(offset, blocks->blocks[idx]); set_bit_atomic(offset, blocks->blocks[idx]);
rcu_read_unlock();
} }
static inline void cpu_physical_memory_set_dirty_range(ram_addr_t start, static inline void cpu_physical_memory_set_dirty_range(ram_addr_t start,
@ -334,8 +329,7 @@ static inline void cpu_physical_memory_set_dirty_range(ram_addr_t start,
end = TARGET_PAGE_ALIGN(start + length) >> TARGET_PAGE_BITS; end = TARGET_PAGE_ALIGN(start + length) >> TARGET_PAGE_BITS;
page = start >> TARGET_PAGE_BITS; page = start >> TARGET_PAGE_BITS;
rcu_read_lock(); WITH_RCU_READ_LOCK_GUARD() {
for (i = 0; i < DIRTY_MEMORY_NUM; i++) { for (i = 0; i < DIRTY_MEMORY_NUM; i++) {
blocks[i] = atomic_rcu_read(&ram_list.dirty_memory[i]); blocks[i] = atomic_rcu_read(&ram_list.dirty_memory[i]);
} }
@ -364,8 +358,7 @@ static inline void cpu_physical_memory_set_dirty_range(ram_addr_t start,
offset = 0; offset = 0;
base += DIRTY_MEMORY_BLOCK_SIZE; base += DIRTY_MEMORY_BLOCK_SIZE;
} }
}
rcu_read_unlock();
xen_hvm_modified_memory(start, length); xen_hvm_modified_memory(start, length);
} }
@ -396,8 +389,7 @@ static inline void cpu_physical_memory_set_dirty_lebitmap(unsigned long *bitmap,
offset = BIT_WORD((start >> TARGET_PAGE_BITS) % offset = BIT_WORD((start >> TARGET_PAGE_BITS) %
DIRTY_MEMORY_BLOCK_SIZE); DIRTY_MEMORY_BLOCK_SIZE);
rcu_read_lock(); WITH_RCU_READ_LOCK_GUARD() {
for (i = 0; i < DIRTY_MEMORY_NUM; i++) { for (i = 0; i < DIRTY_MEMORY_NUM; i++) {
blocks[i] = atomic_rcu_read(&ram_list.dirty_memory[i])->blocks; blocks[i] = atomic_rcu_read(&ram_list.dirty_memory[i])->blocks;
} }
@ -414,7 +406,8 @@ static inline void cpu_physical_memory_set_dirty_lebitmap(unsigned long *bitmap,
} }
if (tcg_enabled()) { if (tcg_enabled()) {
atomic_or(&blocks[DIRTY_MEMORY_CODE][idx][offset], temp); atomic_or(&blocks[DIRTY_MEMORY_CODE][idx][offset],
temp);
} }
} }
@ -423,8 +416,7 @@ static inline void cpu_physical_memory_set_dirty_lebitmap(unsigned long *bitmap,
idx++; idx++;
} }
} }
}
rcu_read_unlock();
xen_hvm_modified_memory(start, pages << TARGET_PAGE_BITS); xen_hvm_modified_memory(start, pages << TARGET_PAGE_BITS);
} else { } else {

15
memory.c
View File

@ -779,14 +779,13 @@ FlatView *address_space_get_flatview(AddressSpace *as)
{ {
FlatView *view; FlatView *view;
rcu_read_lock(); RCU_READ_LOCK_GUARD();
do { do {
view = address_space_to_flatview(as); view = address_space_to_flatview(as);
/* If somebody has replaced as->current_map concurrently, /* If somebody has replaced as->current_map concurrently,
* flatview_ref returns false. * flatview_ref returns false.
*/ */
} while (!flatview_ref(view)); } while (!flatview_ref(view));
rcu_read_unlock();
return view; return view;
} }
@ -2166,12 +2165,11 @@ int memory_region_get_fd(MemoryRegion *mr)
{ {
int fd; int fd;
rcu_read_lock(); RCU_READ_LOCK_GUARD();
while (mr->alias) { while (mr->alias) {
mr = mr->alias; mr = mr->alias;
} }
fd = mr->ram_block->fd; fd = mr->ram_block->fd;
rcu_read_unlock();
return fd; return fd;
} }
@ -2181,14 +2179,13 @@ void *memory_region_get_ram_ptr(MemoryRegion *mr)
void *ptr; void *ptr;
uint64_t offset = 0; uint64_t offset = 0;
rcu_read_lock(); RCU_READ_LOCK_GUARD();
while (mr->alias) { while (mr->alias) {
offset += mr->alias_offset; offset += mr->alias_offset;
mr = mr->alias; mr = mr->alias;
} }
assert(mr->ram_block); assert(mr->ram_block);
ptr = qemu_map_ram_ptr(mr->ram_block, offset); ptr = qemu_map_ram_ptr(mr->ram_block, offset);
rcu_read_unlock();
return ptr; return ptr;
} }
@ -2578,12 +2575,11 @@ MemoryRegionSection memory_region_find(MemoryRegion *mr,
hwaddr addr, uint64_t size) hwaddr addr, uint64_t size)
{ {
MemoryRegionSection ret; MemoryRegionSection ret;
rcu_read_lock(); RCU_READ_LOCK_GUARD();
ret = memory_region_find_rcu(mr, addr, size); ret = memory_region_find_rcu(mr, addr, size);
if (ret.mr) { if (ret.mr) {
memory_region_ref(ret.mr); memory_region_ref(ret.mr);
} }
rcu_read_unlock();
return ret; return ret;
} }
@ -2591,9 +2587,8 @@ bool memory_region_present(MemoryRegion *container, hwaddr addr)
{ {
MemoryRegion *mr; MemoryRegion *mr;
rcu_read_lock(); RCU_READ_LOCK_GUARD();
mr = memory_region_find_rcu(container, addr, 1).mr; mr = memory_region_find_rcu(container, addr, 1).mr;
rcu_read_unlock();
return mr && mr != container; return mr && mr != container;
} }