memory: Factor out common ram region initialization
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>
BALATON Zoltan committed
Mar 8, 2026 at 00:06 UTC
2fb627ef2f486bce4d9f87da573948a33e1ffbd8
1 file changed
+61
-106
system/memory.c
+61
-106
@@ -1568,39 +1568,39 @@ static void memory_region_set_ops(MemoryRegion *mr,
1568
mr->terminates = true;
1569
}
1570
1571
-void memory_region_init_io(MemoryRegion *mr,
1572
- Object *owner,
1573
- const MemoryRegionOps *ops,
1574
- void *opaque,
1575
- const char *name,
1576
- uint64_t size)
1571
+void memory_region_init_io(MemoryRegion *mr, Object *owner,
1572
+ const MemoryRegionOps *ops, void *opaque,
1573
+ const char *name, uint64_t size)
1574
{
1575
memory_region_init(mr, owner, name, size);
1576
memory_region_set_ops(mr, ops, opaque);
1577
}
1578
1582
-bool memory_region_init_ram_flags_nomigrate(MemoryRegion *mr,
1583
- Object *owner,
1584
- const char *name,
1585
- uint64_t size,
1586
- uint32_t ram_flags,
1587
- Error **errp)
1579
+static bool memory_region_set_ram_block(MemoryRegion *mr, RAMBlock *rb)
1580
{
1589
- Error *err = NULL;
1590
- memory_region_init(mr, owner, name, size);
1581
mr->ram = true;
1582
mr->terminates = true;
1583
mr->destructor = memory_region_destructor_ram;
1594
- mr->ram_block = qemu_ram_alloc(size, ram_flags, mr, &err);
1595
- if (err) {
1584
+ mr->ram_block = rb;
1585
+ if (!rb) {
1586
mr->size = int128_zero();
1587
object_unparent(OBJECT(mr));
1598
- error_propagate(errp, err);
1588
return false;
1589
}
1590
return true;
1591
}
1592
1593
+bool memory_region_init_ram_flags_nomigrate(MemoryRegion *mr, Object *owner,
1594
+ const char *name, uint64_t size,
1595
+ uint32_t ram_flags, Error **errp)
1596
+{
1597
+ RAMBlock *rb;
1598
+
1599
+ memory_region_init(mr, owner, name, size);
1600
+ rb = qemu_ram_alloc(size, ram_flags, mr, errp);
1601
+ return memory_region_set_ram_block(mr, rb);
1602
+}
1603
+
1604
bool memory_region_init_resizeable_ram(MemoryRegion *mr,
1605
Object *owner,
1606
const char *name,
@@ -1611,116 +1611,74 @@ bool memory_region_init_resizeable_ram(MemoryRegion *mr,
1611
void *host),
1612
Error **errp)
1613
{
1614
- Error *err = NULL;
1614
+ RAMBlock *rb;
1615
+
1616
memory_region_init(mr, owner, name, size);
1616
- mr->ram = true;
1617
- mr->terminates = true;
1618
- mr->destructor = memory_region_destructor_ram;
1619
- mr->ram_block = qemu_ram_alloc_resizeable(size, max_size, resized,
1620
- mr, &err);
1621
- if (err) {
1622
- mr->size = int128_zero();
1623
- object_unparent(OBJECT(mr));
1624
- error_propagate(errp, err);
1625
- return false;
1626
- }
1627
- return true;
1617
+ rb = qemu_ram_alloc_resizeable(size, max_size, resized, mr, errp);
1618
+ return memory_region_set_ram_block(mr, rb);
1619
}
1620
1621
#if defined(CONFIG_POSIX) && !defined(EMSCRIPTEN)
1631
-bool memory_region_init_ram_from_file(MemoryRegion *mr,
1632
- Object *owner,
1633
- const char *name,
1634
- uint64_t size,
1635
- uint64_t align,
1636
- uint32_t ram_flags,
1637
- const char *path,
1638
- ram_addr_t offset,
1622
+bool memory_region_init_ram_from_file(MemoryRegion *mr, Object *owner,
1623
+ const char *name, uint64_t size,
1624
+ uint64_t align, uint32_t ram_flags,
1625
+ const char *path, ram_addr_t offset,
1626
Error **errp)
1627
{
1641
- Error *err = NULL;
1628
+ RAMBlock *rb;
1629
+
1630
memory_region_init(mr, owner, name, size);
1643
- mr->ram = true;
1631
mr->readonly = !!(ram_flags & RAM_READONLY);
1645
- mr->terminates = true;
1646
- mr->destructor = memory_region_destructor_ram;
1632
mr->align = align;
1648
- mr->ram_block = qemu_ram_alloc_from_file(size, mr, ram_flags, path,
1649
- offset, &err);
1650
- if (err) {
1651
- mr->size = int128_zero();
1652
- object_unparent(OBJECT(mr));
1653
- error_propagate(errp, err);
1654
- return false;
1655
- }
1656
- return true;
1633
+ rb = qemu_ram_alloc_from_file(size, mr, ram_flags, path, offset, errp);
1634
+ return memory_region_set_ram_block(mr, rb);
1635
}
1636
1659
-bool memory_region_init_ram_from_fd(MemoryRegion *mr,
1660
- Object *owner,
1661
- const char *name,
1662
- uint64_t size,
1663
- uint32_t ram_flags,
1664
- int fd,
1665
- ram_addr_t offset,
1666
- Error **errp)
1637
+bool memory_region_init_ram_from_fd(MemoryRegion *mr, Object *owner,
1638
+ const char *name, uint64_t size,
1639
+ uint32_t ram_flags, int fd,
1640
+ ram_addr_t offset, Error **errp)
1641
{
1668
- Error *err = NULL;
1642
+ RAMBlock *rb;
1643
+
1644
memory_region_init(mr, owner, name, size);
1670
- mr->ram = true;
1645
mr->readonly = !!(ram_flags & RAM_READONLY);
1672
- mr->terminates = true;
1673
- mr->destructor = memory_region_destructor_ram;
1674
- mr->ram_block = qemu_ram_alloc_from_fd(size, size, NULL, mr, ram_flags, fd,
1675
- offset, false, &err);
1676
- if (err) {
1677
- mr->size = int128_zero();
1678
- object_unparent(OBJECT(mr));
1679
- error_propagate(errp, err);
1680
- return false;
1681
- }
1682
- return true;
1646
+ rb = qemu_ram_alloc_from_fd(size, size, NULL, mr, ram_flags, fd, offset,
1647
+ false, errp);
1648
+ return memory_region_set_ram_block(mr, rb);
1649
}
1650
#endif
1651
1686
-void memory_region_init_ram_ptr(MemoryRegion *mr,
1687
- Object *owner,
1688
- const char *name,
1689
- uint64_t size,
1652
+void memory_region_init_ram_ptr(MemoryRegion *mr, Object *owner,
1653
+ const char *name, uint64_t size,
1654
void *ptr)
1655
{
1692
- memory_region_init(mr, owner, name, size);
1693
- mr->ram = true;
1694
- mr->terminates = true;
1695
- mr->destructor = memory_region_destructor_ram;
1656
+ RAMBlock *rb;
1657
1658
+ memory_region_init(mr, owner, name, size);
1659
/* qemu_ram_alloc_from_ptr cannot fail with ptr != NULL. */
1660
assert(ptr != NULL);
1699
- mr->ram_block = qemu_ram_alloc_from_ptr(size, ptr, mr, &error_abort);
1661
+ rb = qemu_ram_alloc_from_ptr(size, ptr, mr, &error_abort);
1662
+ memory_region_set_ram_block(mr, rb);
1663
}
1664
1702
-void memory_region_init_ram_device_ptr(MemoryRegion *mr,
1703
- Object *owner,
1704
- const char *name,
1705
- uint64_t size,
1665
+void memory_region_init_ram_device_ptr(MemoryRegion *mr, Object *owner,
1666
+ const char *name, uint64_t size,
1667
void *ptr)
1668
{
1669
+ RAMBlock *rb;
1670
+
1671
memory_region_init_io(mr, owner, &ram_device_mem_ops, mr, name, size);
1709
- mr->ram = true;
1672
mr->ram_device = true;
1711
- mr->destructor = memory_region_destructor_ram;
1712
-
1673
/* qemu_ram_alloc_from_ptr cannot fail with ptr != NULL. */
1674
assert(ptr != NULL);
1715
- mr->ram_block = qemu_ram_alloc_from_ptr(size, ptr, mr, &error_abort);
1675
+ rb = qemu_ram_alloc_from_ptr(size, ptr, mr, &error_abort);
1676
+ memory_region_set_ram_block(mr, rb);
1677
}
1678
1718
-void memory_region_init_alias(MemoryRegion *mr,
1719
- Object *owner,
1720
- const char *name,
1721
- MemoryRegion *orig,
1722
- hwaddr offset,
1723
- uint64_t size)
1679
+void memory_region_init_alias(MemoryRegion *mr, Object *owner,
1680
+ const char *name, MemoryRegion *orig,
1681
+ hwaddr offset, uint64_t size)
1682
{
1683
memory_region_init(mr, owner, name, size);
1684
mr->alias = orig;
@@ -3732,21 +3690,18 @@ bool memory_region_init_rom_device(MemoryRegion *mr, Object *owner,
3690
const char *name, uint64_t size,
3691
Error **errp)
3692
{
3735
- Error *err = NULL;
3693
+ RAMBlock *rb;
3694
3695
assert(ops);
3696
memory_region_init_io(mr, owner, ops, opaque, name, size);
3739
- mr->rom_device = true;
3740
- mr->destructor = memory_region_destructor_ram;
3741
- mr->ram_block = qemu_ram_alloc(size, 0, mr, &err);
3742
- if (err) {
3743
- mr->size = int128_zero();
3744
- object_unparent(OBJECT(mr));
3745
- error_propagate(errp, err);
3746
- return false;
3697
+ rb = qemu_ram_alloc(size, 0, mr, errp);
3698
+ if (memory_region_set_ram_block(mr, rb)) {
3699
+ mr->ram = false;
3700
+ mr->rom_device = true;
3701
+ memory_region_register_ram(mr, owner);
3702
+ return true;
3703
}
3748
- memory_region_register_ram(mr, owner);
3749
- return true;
3704
+ return false;
3705
}
3706
3707
/*