starred/qemu
1
0
Fork 0
mirror of https://github.com/qemu/qemu.git synced 2026-04-12 09:12:22 +00:00
Code Issues 380 Packages Projects Releases Wiki Activity

memory: Factor out common ram region initialization

Browse Source 
Introduce internal helper function to remove duplicated code from
different memory_region_init_*ram functions. Remove local err and
error_propagate and pass errp and check return value instead.
Also shorten some function prototypes while at it.

Signed-off-by: BALATON Zoltan <balaton@eik.bme.hu>
Reviewed-by: Akihiko Odaki <odaki@rsg.ci.i.u-tokyo.ac.jp>
Link: https://lore.kernel.org/r/d6db01c283149b46023ffeb9c5b368c67f6acc8d.1772924151.git.balaton@eik.bme.hu
Signed-off-by: Peter Xu <peterx@redhat.com>
This commit is contained in:
BALATON Zoltan
2026-03-08 00:06:06 +01:00
committed by Peter Xu
parent f0eca07fbd
commit 2fb627ef2f
1 changed files with 62 additions and 107 deletions
Download Patch File Download Diff File Expand all files Collapse all files

169
system/memory.c
View File

@@ -1568,39 +1568,39 @@ static void memory_region_set_ops(MemoryRegion *mr,
mr->terminates = true;
}
void memory_region_init_io(MemoryRegion *mr,
Object *owner,
const MemoryRegionOps *ops,
void *opaque,
const char *name,
uint64_t size)
void memory_region_init_io(MemoryRegion *mr, Object *owner,
const MemoryRegionOps *ops, void *opaque,
const char *name, uint64_t size)
{
memory_region_init(mr, owner, name, size);
memory_region_set_ops(mr, ops, opaque);
}
bool memory_region_init_ram_flags_nomigrate(MemoryRegion *mr,
Object *owner,
const char *name,
uint64_t size,
uint32_t ram_flags,
Error **errp)
static bool memory_region_set_ram_block(MemoryRegion *mr, RAMBlock *rb)
{
Error *err = NULL;
memory_region_init(mr, owner, name, size);
mr->ram = true;
mr->terminates = true;
mr->destructor = memory_region_destructor_ram;
mr->ram_block = qemu_ram_alloc(size, ram_flags, mr, &err);
if (err) {
mr->ram_block = rb;
if (!rb) {
mr->size = int128_zero();
object_unparent(OBJECT(mr));
error_propagate(errp, err);
return false;
}
return true;
}
bool memory_region_init_ram_flags_nomigrate(MemoryRegion *mr, Object *owner,
const char *name, uint64_t size,
uint32_t ram_flags, Error **errp)
{
RAMBlock *rb;
memory_region_init(mr, owner, name, size);
rb = qemu_ram_alloc(size, ram_flags, mr, errp);
return memory_region_set_ram_block(mr, rb);
}
bool memory_region_init_resizeable_ram(MemoryRegion *mr,
Object *owner,
const char *name,
@@ -1611,116 +1611,74 @@ bool memory_region_init_resizeable_ram(MemoryRegion *mr,
void *host),
Error **errp)
{
Error *err = NULL;
RAMBlock *rb;
memory_region_init(mr, owner, name, size);
mr->ram = true;
mr->terminates = true;
mr->destructor = memory_region_destructor_ram;
mr->ram_block = qemu_ram_alloc_resizeable(size, max_size, resized,
mr, &err);
if (err) {
mr->size = int128_zero();
object_unparent(OBJECT(mr));
error_propagate(errp, err);
return false;
}
return true;
rb = qemu_ram_alloc_resizeable(size, max_size, resized, mr, errp);
return memory_region_set_ram_block(mr, rb);
}
#if defined(CONFIG_POSIX) && !defined(EMSCRIPTEN)
bool memory_region_init_ram_from_file(MemoryRegion *mr,
Object *owner,
const char *name,
uint64_t size,
uint64_t align,
uint32_t ram_flags,
const char *path,
ram_addr_t offset,
bool memory_region_init_ram_from_file(MemoryRegion *mr, Object *owner,
const char *name, uint64_t size,
uint64_t align, uint32_t ram_flags,
const char *path, ram_addr_t offset,
Error **errp)
{
Error *err = NULL;
RAMBlock *rb;
memory_region_init(mr, owner, name, size);
mr->ram = true;
mr->readonly = !!(ram_flags & RAM_READONLY);
mr->terminates = true;
mr->destructor = memory_region_destructor_ram;
mr->align = align;
mr->ram_block = qemu_ram_alloc_from_file(size, mr, ram_flags, path,
offset, &err);
if (err) {
mr->size = int128_zero();
object_unparent(OBJECT(mr));
error_propagate(errp, err);
return false;
}
return true;
rb = qemu_ram_alloc_from_file(size, mr, ram_flags, path, offset, errp);
return memory_region_set_ram_block(mr, rb);
}
bool memory_region_init_ram_from_fd(MemoryRegion *mr,
Object *owner,
const char *name,
uint64_t size,
uint32_t ram_flags,
int fd,
ram_addr_t offset,
Error **errp)
bool memory_region_init_ram_from_fd(MemoryRegion *mr, Object *owner,
const char *name, uint64_t size,
uint32_t ram_flags, int fd,
ram_addr_t offset, Error **errp)
{
Error *err = NULL;
RAMBlock *rb;
memory_region_init(mr, owner, name, size);
mr->ram = true;
mr->readonly = !!(ram_flags & RAM_READONLY);
mr->terminates = true;
mr->destructor = memory_region_destructor_ram;
mr->ram_block = qemu_ram_alloc_from_fd(size, size, NULL, mr, ram_flags, fd,
offset, false, &err);
if (err) {
mr->size = int128_zero();
object_unparent(OBJECT(mr));
error_propagate(errp, err);
return false;
}
return true;
rb = qemu_ram_alloc_from_fd(size, size, NULL, mr, ram_flags, fd, offset,
false, errp);
return memory_region_set_ram_block(mr, rb);
}
#endif
void memory_region_init_ram_ptr(MemoryRegion *mr,
Object *owner,
const char *name,
uint64_t size,
void memory_region_init_ram_ptr(MemoryRegion *mr, Object *owner,
const char *name, uint64_t size,
void *ptr)
{
memory_region_init(mr, owner, name, size);
mr->ram = true;
mr->terminates = true;
mr->destructor = memory_region_destructor_ram;
RAMBlock *rb;
memory_region_init(mr, owner, name, size);
/* qemu_ram_alloc_from_ptr cannot fail with ptr != NULL. */
assert(ptr != NULL);
mr->ram_block = qemu_ram_alloc_from_ptr(size, ptr, mr, &error_abort);
rb = qemu_ram_alloc_from_ptr(size, ptr, mr, &error_abort);
memory_region_set_ram_block(mr, rb);
}
void memory_region_init_ram_device_ptr(MemoryRegion *mr,
Object *owner,
const char *name,
uint64_t size,
void memory_region_init_ram_device_ptr(MemoryRegion *mr, Object *owner,
const char *name, uint64_t size,
void *ptr)
{
memory_region_init_io(mr, owner, &ram_device_mem_ops, mr, name, size);
mr->ram = true;
mr->ram_device = true;
mr->destructor = memory_region_destructor_ram;
RAMBlock *rb;
memory_region_init_io(mr, owner, &ram_device_mem_ops, mr, name, size);
mr->ram_device = true;
/* qemu_ram_alloc_from_ptr cannot fail with ptr != NULL. */
assert(ptr != NULL);
mr->ram_block = qemu_ram_alloc_from_ptr(size, ptr, mr, &error_abort);
rb = qemu_ram_alloc_from_ptr(size, ptr, mr, &error_abort);
memory_region_set_ram_block(mr, rb);
}
void memory_region_init_alias(MemoryRegion *mr,
Object *owner,
const char *name,
MemoryRegion *orig,
hwaddr offset,
uint64_t size)
void memory_region_init_alias(MemoryRegion *mr, Object *owner,
const char *name, MemoryRegion *orig,
hwaddr offset, uint64_t size)
{
memory_region_init(mr, owner, name, size);
mr->alias = orig;
@@ -3732,21 +3690,18 @@ bool memory_region_init_rom_device(MemoryRegion *mr, Object *owner,
const char *name, uint64_t size,
Error **errp)
{
Error *err = NULL;
RAMBlock *rb;
assert(ops);
memory_region_init_io(mr, owner, ops, opaque, name, size);
mr->rom_device = true;
mr->destructor = memory_region_destructor_ram;
mr->ram_block = qemu_ram_alloc(size, 0, mr, &err);
if (err) {
mr->size = int128_zero();
object_unparent(OBJECT(mr));
error_propagate(errp, err);
return false;
rb = qemu_ram_alloc(size, 0, mr, errp);
if (memory_region_set_ram_block(mr, rb)) {
mr->ram = false;
mr->rom_device = true;
memory_region_register_ram(mr, owner);
return true;
}
memory_region_register_ram(mr, owner);
return true;
return false;
}
/*