AddressSpace *as;
assert(memory_region_transaction_depth);
- assert(qemu_mutex_iothread_locked());
+ assert(bql_locked());
--memory_region_transaction_depth;
if (!memory_region_transaction_depth) {
hwaddr addr, unsigned size)
{
MemoryRegion *mr = opaque;
- uint64_t data = (uint64_t)~0;
-
- switch (size) {
- case 1:
- data = *(uint8_t *)(mr->ram_block->host + addr);
- break;
- case 2:
- data = *(uint16_t *)(mr->ram_block->host + addr);
- break;
- case 4:
- data = *(uint32_t *)(mr->ram_block->host + addr);
- break;
- case 8:
- data = *(uint64_t *)(mr->ram_block->host + addr);
- break;
- }
+ uint64_t data = ldn_he_p(mr->ram_block->host + addr, size);
trace_memory_region_ram_device_read(get_cpu_index(), mr, addr, data, size);
trace_memory_region_ram_device_write(get_cpu_index(), mr, addr, data, size);
- switch (size) {
- case 1:
- *(uint8_t *)(mr->ram_block->host + addr) = (uint8_t)data;
- break;
- case 2:
- *(uint16_t *)(mr->ram_block->host + addr) = (uint16_t)data;
- break;
- case 4:
- *(uint32_t *)(mr->ram_block->host + addr) = (uint32_t)data;
- break;
- case 8:
- *(uint64_t *)(mr->ram_block->host + addr) = data;
- break;
- }
+ stn_he_p(mr->ram_block->host + addr, size, data);
}
static const MemoryRegionOps ram_device_mem_ops = {
mr->terminates = true;
}
-void memory_region_init_ram_nomigrate(MemoryRegion *mr,
+bool memory_region_init_ram_nomigrate(MemoryRegion *mr,
Object *owner,
const char *name,
uint64_t size,
Error **errp)
{
- memory_region_init_ram_flags_nomigrate(mr, owner, name, size, 0, errp);
+ return memory_region_init_ram_flags_nomigrate(mr, owner, name,
+ size, 0, errp);
}
-void memory_region_init_ram_flags_nomigrate(MemoryRegion *mr,
+bool memory_region_init_ram_flags_nomigrate(MemoryRegion *mr,
Object *owner,
const char *name,
uint64_t size,
mr->size = int128_zero();
object_unparent(OBJECT(mr));
error_propagate(errp, err);
+ return false;
}
+ return true;
}
-void memory_region_init_resizeable_ram(MemoryRegion *mr,
+bool memory_region_init_resizeable_ram(MemoryRegion *mr,
Object *owner,
const char *name,
uint64_t size,
mr->size = int128_zero();
object_unparent(OBJECT(mr));
error_propagate(errp, err);
+ return false;
}
+ return true;
}
#ifdef CONFIG_POSIX
-void memory_region_init_ram_from_file(MemoryRegion *mr,
+bool memory_region_init_ram_from_file(MemoryRegion *mr,
Object *owner,
const char *name,
uint64_t size,
mr->size = int128_zero();
object_unparent(OBJECT(mr));
error_propagate(errp, err);
+ return false;
}
+ return true;
}
-void memory_region_init_ram_from_fd(MemoryRegion *mr,
+bool memory_region_init_ram_from_fd(MemoryRegion *mr,
Object *owner,
const char *name,
uint64_t size,
mr->size = int128_zero();
object_unparent(OBJECT(mr));
error_propagate(errp, err);
+ return false;
}
+ return true;
}
#endif
/* 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_fatal);
+ mr->ram_block = qemu_ram_alloc_from_ptr(size, ptr, mr, &error_abort);
}
void memory_region_init_ram_device_ptr(MemoryRegion *mr,
/* 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_fatal);
+ mr->ram_block = qemu_ram_alloc_from_ptr(size, ptr, mr, &error_abort);
}
void memory_region_init_alias(MemoryRegion *mr,
mr->alias_offset = offset;
}
-void memory_region_init_rom_nomigrate(MemoryRegion *mr,
+bool memory_region_init_rom_nomigrate(MemoryRegion *mr,
Object *owner,
const char *name,
uint64_t size,
Error **errp)
{
- memory_region_init_ram_flags_nomigrate(mr, owner, name, size, 0, errp);
+ if (!memory_region_init_ram_flags_nomigrate(mr, owner, name,
+ size, 0, errp)) {
+ return false;
+ }
mr->readonly = true;
+
+ return true;
}
-void memory_region_init_rom_device_nomigrate(MemoryRegion *mr,
+bool memory_region_init_rom_device_nomigrate(MemoryRegion *mr,
Object *owner,
const MemoryRegionOps *ops,
void *opaque,
mr->size = int128_zero();
object_unparent(OBJECT(mr));
error_propagate(errp, err);
+ return false;
}
+ return true;
}
void memory_region_init_iommu(void *_iommu_mr,
}
}
-void memory_region_init_ram(MemoryRegion *mr,
+bool memory_region_init_ram(MemoryRegion *mr,
Object *owner,
const char *name,
uint64_t size,
Error **errp)
{
DeviceState *owner_dev;
- Error *err = NULL;
- memory_region_init_ram_nomigrate(mr, owner, name, size, &err);
- if (err) {
- error_propagate(errp, err);
- return;
+ if (!memory_region_init_ram_nomigrate(mr, owner, name, size, errp)) {
+ return false;
}
/* This will assert if owner is neither NULL nor a DeviceState.
* We only want the owner here for the purposes of defining a
*/
owner_dev = DEVICE(owner);
vmstate_register_ram(mr, owner_dev);
+
+ return true;
}
-void memory_region_init_rom(MemoryRegion *mr,
+bool memory_region_init_rom(MemoryRegion *mr,
Object *owner,
const char *name,
uint64_t size,
Error **errp)
{
DeviceState *owner_dev;
- Error *err = NULL;
- memory_region_init_rom_nomigrate(mr, owner, name, size, &err);
- if (err) {
- error_propagate(errp, err);
- return;
+ if (!memory_region_init_rom_nomigrate(mr, owner, name, size, errp)) {
+ return false;
}
/* This will assert if owner is neither NULL nor a DeviceState.
* We only want the owner here for the purposes of defining a
*/
owner_dev = DEVICE(owner);
vmstate_register_ram(mr, owner_dev);
+
+ return true;
}
-void memory_region_init_rom_device(MemoryRegion *mr,
+bool memory_region_init_rom_device(MemoryRegion *mr,
Object *owner,
const MemoryRegionOps *ops,
void *opaque,
Error **errp)
{
DeviceState *owner_dev;
- Error *err = NULL;
- memory_region_init_rom_device_nomigrate(mr, owner, ops, opaque,
- name, size, &err);
- if (err) {
- error_propagate(errp, err);
- return;
+ if (!memory_region_init_rom_device_nomigrate(mr, owner, ops, opaque,
+ name, size, errp)) {
+ return false;
}
/* This will assert if owner is neither NULL nor a DeviceState.
* We only want the owner here for the purposes of defining a
*/
owner_dev = DEVICE(owner);
vmstate_register_ram(mr, owner_dev);
+
+ return true;
}
/*