Error **errp)
{
KVMState *s = KVM_STATE(obj);
- Error *error = NULL;
int64_t value;
- if (!visit_type_int(v, name, &value, &error)) {
- error_propagate(errp, error);
+ if (!visit_type_int(v, name, &value, errp)) {
return;
}
Error **errp)
{
TCGState *s = TCG_STATE(obj);
- Error *error = NULL;
uint32_t value;
- if (!visit_type_uint32(v, name, &value, &error)) {
- error_propagate(errp, error);
+ if (!visit_type_uint32(v, name, &value, errp)) {
return;
}
backend->conf.peers.ccs[i] = cc;
if (i == 0) {
- if (!qemu_chr_fe_init(&s->chr, chr, &local_err)) {
- error_propagate(errp, local_err);
+ if (!qemu_chr_fe_init(&s->chr, chr, errp)) {
return;
}
}
void *opaque, Error **errp)
{
CryptoDevBackend *backend = CRYPTODEV_BACKEND(obj);
- Error *local_err = NULL;
uint32_t value;
- if (!visit_type_uint32(v, name, &value, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_uint32(v, name, &value, errp)) {
return;
}
if (!value) {
{
HostMemoryBackend *backend = MEMORY_BACKEND(o);
HostMemoryBackendFile *fb = MEMORY_BACKEND_FILE(o);
- Error *local_err = NULL;
uint64_t val;
if (host_memory_backend_mr_inited(backend)) {
return;
}
- if (!visit_type_size(v, name, &val, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_size(v, name, &val, errp)) {
return;
}
fb->align = val;
void *opaque, Error **errp)
{
HostMemoryBackendMemfd *m = MEMORY_BACKEND_MEMFD(obj);
- Error *local_err = NULL;
uint64_t value;
if (host_memory_backend_mr_inited(MEMORY_BACKEND(obj))) {
return;
}
- if (!visit_type_size(v, name, &value, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_size(v, name, &value, errp)) {
return;
}
if (!value) {
void *opaque, Error **errp)
{
HostMemoryBackend *backend = MEMORY_BACKEND(obj);
- Error *local_err = NULL;
uint64_t value;
if (host_memory_backend_mr_inited(backend)) {
return;
}
- if (!visit_type_size(v, name, &value, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_size(v, name, &value, errp)) {
return;
}
if (!value) {
const char *name, void *opaque, Error **errp)
{
HostMemoryBackend *backend = MEMORY_BACKEND(obj);
- Error *local_err = NULL;
uint32_t value;
- if (!visit_type_uint32(v, name, &value, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_uint32(v, name, &value, errp)) {
return;
}
if (value <= 0) {
Error **errp)
{
DeviceState *dev = DEVICE(obj);
- Error *local_err = NULL;
Property *prop = opaque;
TPMBackend *s, **be = qdev_get_prop_ptr(dev, prop);
char *str;
return;
}
- if (!visit_type_str(v, name, &str, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_str(v, name, &str, errp)) {
return;
}
if (bs->open_flags & BDRV_O_INACTIVE) {
bs->open_flags &= ~BDRV_O_INACTIVE;
bdrv_get_cumulative_perm(bs, &perm, &shared_perm);
- ret = bdrv_check_perm(bs, NULL, perm, shared_perm, NULL, NULL, &local_err);
+ ret = bdrv_check_perm(bs, NULL, perm, shared_perm, NULL, NULL, errp);
if (ret < 0) {
bs->open_flags |= BDRV_O_INACTIVE;
- error_propagate(errp, local_err);
return;
}
bdrv_set_perm(bs, perm, shared_perm);
BDRVCURLState *s = bs->opaque;
CURLState *state = NULL;
QemuOpts *opts;
- Error *local_err = NULL;
const char *file;
const char *cookie;
const char *cookie_secret;
qemu_mutex_init(&s->mutex);
opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
- if (!qemu_opts_absorb_qdict(opts, options, &local_err)) {
- error_propagate(errp, local_err);
+ if (!qemu_opts_absorb_qdict(opts, options, errp)) {
goto out_noclean;
}
Error **errp)
{
BDRVRawState *s = bs->opaque;
- Error *local_err = NULL;
int ret;
#if defined(__APPLE__) && defined(__MACH__)
s->type = FTYPE_FILE;
- ret = raw_open_common(bs, options, flags, 0, true, &local_err);
+ ret = raw_open_common(bs, options, flags, 0, true, errp);
if (ret < 0) {
- error_propagate(errp, local_err);
#if defined(__APPLE__) && defined(__MACH__)
if (*bsd_path) {
filename = bsd_path;
Error **errp)
{
BDRVRawState *s = bs->opaque;
- Error *local_err = NULL;
int ret;
s->type = FTYPE_CD;
- ret = raw_open_common(bs, options, flags, 0, true, &local_err);
+ ret = raw_open_common(bs, options, flags, 0, true, errp);
if (ret) {
- error_propagate(errp, local_err);
return ret;
}
}
/* Create and open the file (protocol layer) */
- ret = bdrv_create_file(filename, opts, &local_err);
+ ret = bdrv_create_file(filename, opts, errp);
if (ret < 0) {
- error_propagate(errp, local_err);
goto done;
}
}
/* Create and open the file (protocol layer) */
- ret = bdrv_create_file(filename, opts, &local_err);
+ ret = bdrv_create_file(filename, opts, errp);
if (ret < 0) {
- error_propagate(errp, local_err);
goto fail;
}
}
/* Create and open the file (protocol layer) */
- ret = bdrv_create_file(filename, opts, &local_err);
+ ret = bdrv_create_file(filename, opts, errp);
if (ret < 0) {
- error_propagate(errp, local_err);
goto fail;
}
ThrottleGroup *tg = THROTTLE_GROUP(obj);
ThrottleConfig *cfg;
ThrottleParamInfo *info = opaque;
- Error *local_err = NULL;
int64_t value;
/* If we have finished initialization, don't accept individual property
return;
}
- if (!visit_type_int64(v, name, &value, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_int64(v, name, &value, errp)) {
return;
}
if (value < 0) {
}
/* Create and open the file (protocol layer) */
- ret = bdrv_create_file(filename, opts, &local_err);
+ ret = bdrv_create_file(filename, opts, errp);
if (ret < 0) {
- error_propagate(errp, local_err);
goto fail;
}
BlockBackend *blk = NULL;
Error *local_err = NULL;
- ret = bdrv_create_file(filename, opts, &local_err);
+ ret = bdrv_create_file(filename, opts, errp);
if (ret < 0) {
- error_propagate(errp, local_err);
goto exit;
}
}
/* Create and open the file (protocol layer) */
- ret = bdrv_create_file(filename, opts, &local_err);
+ ret = bdrv_create_file(filename, opts, errp);
if (ret < 0) {
- error_propagate(errp, local_err);
goto fail;
}
goto err_no_opts;
}
- if (!qemu_opts_absorb_qdict(opts, bs_opts, &error)) {
- error_propagate(errp, error);
+ if (!qemu_opts_absorb_qdict(opts, bs_opts, errp)) {
goto early_err;
}
for (i = 0; i < ARRAY_SIZE(opt_renames); i++) {
if (!qemu_opt_rename(all_opts, opt_renames[i].from,
- opt_renames[i].to, &local_err)) {
- error_propagate(errp, local_err);
+ opt_renames[i].to, errp)) {
return NULL;
}
}
{
AwA10State *s = AW_A10(dev);
SysBusDevice *sysbusdev;
- Error *err = NULL;
- if (!qdev_realize(DEVICE(&s->cpu), NULL, &err)) {
- error_propagate(errp, err);
+ if (!qdev_realize(DEVICE(&s->cpu), NULL, errp)) {
return;
}
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->intc), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->intc), errp)) {
return;
}
sysbusdev = SYS_BUS_DEVICE(&s->intc);
qdev_get_gpio_in(DEVICE(&s->cpu), ARM_CPU_FIQ));
qdev_pass_gpios(DEVICE(&s->intc), dev, NULL);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->timer), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->timer), errp)) {
return;
}
sysbusdev = SYS_BUS_DEVICE(&s->timer);
qemu_check_nic_model(&nd_table[0], TYPE_AW_EMAC);
qdev_set_nic_properties(DEVICE(&s->emac), &nd_table[0]);
}
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->emac), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->emac), errp)) {
return;
}
sysbusdev = SYS_BUS_DEVICE(&s->emac);
sysbus_mmio_map(sysbusdev, 0, AW_A10_EMAC_BASE);
sysbus_connect_irq(sysbusdev, 0, qdev_get_gpio_in(dev, 55));
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->sata), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->sata), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->sata), 0, AW_A10_SATA_BASE);
*/
if (extract32(info->cpuwait_rst, i, 1)) {
if (!object_property_set_bool(cpuobj, "start-powered-off", true,
- &err)) {
- error_propagate(errp, err);
+ errp)) {
return;
}
}
if (!s->cpu_fpu[i]) {
- if (!object_property_set_bool(cpuobj, "vfp", false, &err)) {
- error_propagate(errp, err);
+ if (!object_property_set_bool(cpuobj, "vfp", false, errp)) {
return;
}
}
if (!s->cpu_dsp[i]) {
- if (!object_property_set_bool(cpuobj, "dsp", false, &err)) {
- error_propagate(errp, err);
+ if (!object_property_set_bool(cpuobj, "dsp", false, errp)) {
return;
}
}
object_property_set_link(cpuobj, "memory",
OBJECT(&s->cpu_container[i]), &error_abort);
object_property_set_link(cpuobj, "idau", OBJECT(s), &error_abort);
- if (!sysbus_realize(SYS_BUS_DEVICE(cpuobj), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(cpuobj), errp)) {
return;
}
/*
* CPU must exist and have been parented into the cluster before
* the cluster is realized.
*/
- if (!qdev_realize(DEVICE(&s->cluster[i]), NULL, &err)) {
- error_propagate(errp, err);
+ if (!qdev_realize(DEVICE(&s->cluster[i]), NULL, errp)) {
return;
}
int cpunum;
if (!object_property_set_int(splitter, "num-lines",
- info->num_cpus, &err)) {
- error_propagate(errp, err);
+ info->num_cpus, errp)) {
return;
}
- if (!qdev_realize(DEVICE(splitter), NULL, &err)) {
- error_propagate(errp, err);
+ if (!qdev_realize(DEVICE(splitter), NULL, errp)) {
return;
}
for (cpunum = 0; cpunum < info->num_cpus; cpunum++) {
}
/* Security controller */
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->secctl), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->secctl), errp)) {
return;
}
sbd_secctl = SYS_BUS_DEVICE(&s->secctl);
* that will be an output from the ARMSSE to the system.
*/
if (!object_property_set_int(OBJECT(&s->sec_resp_splitter),
- "num-lines", 3, &err)) {
- error_propagate(errp, err);
+ "num-lines", 3, errp)) {
return;
}
- if (!qdev_realize(DEVICE(&s->sec_resp_splitter), NULL, &err)) {
- error_propagate(errp, err);
+ if (!qdev_realize(DEVICE(&s->sec_resp_splitter), NULL, errp)) {
return;
}
dev_splitter = DEVICE(&s->sec_resp_splitter);
}
object_property_set_link(OBJECT(&s->mpc[i]), "downstream",
OBJECT(&s->sram[i]), &error_abort);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->mpc[i]), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->mpc[i]), errp)) {
return;
}
/* Map the upstream end of the MPC into the right place... */
/* We must OR together lines from the MPC splitters to go to the NVIC */
if (!object_property_set_int(OBJECT(&s->mpc_irq_orgate), "num-lines",
IOTS_NUM_EXP_MPC + info->sram_banks,
- &err)) {
- error_propagate(errp, err);
+ errp)) {
return;
}
- if (!qdev_realize(DEVICE(&s->mpc_irq_orgate), NULL, &err)) {
- error_propagate(errp, err);
+ if (!qdev_realize(DEVICE(&s->mpc_irq_orgate), NULL, errp)) {
return;
}
qdev_connect_gpio_out(DEVICE(&s->mpc_irq_orgate), 0,
* map its upstream ends to the right place in the container.
*/
qdev_prop_set_uint32(DEVICE(&s->timer0), "pclk-frq", s->mainclk_frq);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->timer0), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->timer0), errp)) {
return;
}
sysbus_connect_irq(SYS_BUS_DEVICE(&s->timer0), 0,
&error_abort);
qdev_prop_set_uint32(DEVICE(&s->timer1), "pclk-frq", s->mainclk_frq);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->timer1), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->timer1), errp)) {
return;
}
sysbus_connect_irq(SYS_BUS_DEVICE(&s->timer1), 0,
&error_abort);
qdev_prop_set_uint32(DEVICE(&s->dualtimer), "pclk-frq", s->mainclk_frq);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->dualtimer), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->dualtimer), errp)) {
return;
}
sysbus_connect_irq(SYS_BUS_DEVICE(&s->dualtimer), 0,
int cpunum;
SysBusDevice *mhu_sbd = SYS_BUS_DEVICE(&s->mhu[i]);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->mhu[i]), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->mhu[i]), errp)) {
return;
}
port = g_strdup_printf("port[%d]", i + 3);
}
}
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->apb_ppc0), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->apb_ppc0), errp)) {
return;
}
* ORed together to give a single combined PPC interrupt to the NVIC.
*/
if (!object_property_set_int(OBJECT(&s->ppc_irq_orgate),
- "num-lines", NUM_PPCS, &err)) {
- error_propagate(errp, err);
+ "num-lines", NUM_PPCS, errp)) {
return;
}
- if (!qdev_realize(DEVICE(&s->ppc_irq_orgate), NULL, &err)) {
- error_propagate(errp, err);
+ if (!qdev_realize(DEVICE(&s->ppc_irq_orgate), NULL, errp)) {
return;
}
qdev_connect_gpio_out(DEVICE(&s->ppc_irq_orgate), 0,
qdev_prop_set_string(DEVICE(&s->cachectrl[i]), "name", name);
g_free(name);
qdev_prop_set_uint64(DEVICE(&s->cachectrl[i]), "size", 0x1000);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->cachectrl[i]), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->cachectrl[i]), errp)) {
return;
}
qdev_prop_set_string(DEVICE(&s->cpusecctrl[i]), "name", name);
g_free(name);
qdev_prop_set_uint64(DEVICE(&s->cpusecctrl[i]), "size", 0x1000);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->cpusecctrl[i]), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->cpusecctrl[i]), errp)) {
return;
}
MemoryRegion *mr;
qdev_prop_set_uint32(DEVICE(&s->cpuid[i]), "CPUID", i);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->cpuid[i]), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->cpuid[i]), errp)) {
return;
}
* 0x4002f000: S32K timer
*/
qdev_prop_set_uint32(DEVICE(&s->s32ktimer), "pclk-frq", S32KCLK);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->s32ktimer), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->s32ktimer), errp)) {
return;
}
sysbus_connect_irq(SYS_BUS_DEVICE(&s->s32ktimer), 0,
object_property_set_link(OBJECT(&s->apb_ppc1), "port[0]", OBJECT(mr),
&error_abort);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->apb_ppc1), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->apb_ppc1), errp)) {
return;
}
mr = sysbus_mmio_get_region(SYS_BUS_DEVICE(&s->apb_ppc1), 0);
"cfg_sec_resp", 0));
if (!object_property_set_int(OBJECT(&s->sysinfo), "SYS_VERSION",
- info->sys_version, &err)) {
- error_propagate(errp, err);
+ info->sys_version, errp)) {
return;
}
if (!object_property_set_int(OBJECT(&s->sysinfo), "SYS_CONFIG",
- armsse_sys_config_value(s, info), &err)) {
- error_propagate(errp, err);
+ armsse_sys_config_value(s, info), errp)) {
return;
}
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->sysinfo), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->sysinfo), errp)) {
return;
}
/* System information registers */
s->init_svtor, &error_abort);
object_property_set_int(OBJECT(&s->sysctl), "INITSVTOR1_RST",
s->init_svtor, &error_abort);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->sysctl), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->sysctl), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->sysctl), 0, 0x50021000);
/* This OR gate wires together outputs from the secure watchdogs to NMI */
if (!object_property_set_int(OBJECT(&s->nmi_orgate), "num-lines", 2,
- &err)) {
- error_propagate(errp, err);
+ errp)) {
return;
}
- if (!qdev_realize(DEVICE(&s->nmi_orgate), NULL, &err)) {
- error_propagate(errp, err);
+ if (!qdev_realize(DEVICE(&s->nmi_orgate), NULL, errp)) {
return;
}
qdev_connect_gpio_out(DEVICE(&s->nmi_orgate), 0,
qdev_get_gpio_in_named(DEVICE(&s->armv7m), "NMI", 0));
qdev_prop_set_uint32(DEVICE(&s->s32kwatchdog), "wdogclk-frq", S32KCLK);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->s32kwatchdog), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->s32kwatchdog), errp)) {
return;
}
sysbus_connect_irq(SYS_BUS_DEVICE(&s->s32kwatchdog), 0,
/* 0x40080000 .. 0x4008ffff : ARMSSE second Base peripheral region */
qdev_prop_set_uint32(DEVICE(&s->nswatchdog), "wdogclk-frq", s->mainclk_frq);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->nswatchdog), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->nswatchdog), errp)) {
return;
}
sysbus_connect_irq(SYS_BUS_DEVICE(&s->nswatchdog), 0,
sysbus_mmio_map(SYS_BUS_DEVICE(&s->nswatchdog), 0, 0x40081000);
qdev_prop_set_uint32(DEVICE(&s->swatchdog), "wdogclk-frq", s->mainclk_frq);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->swatchdog), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->swatchdog), errp)) {
return;
}
sysbus_connect_irq(SYS_BUS_DEVICE(&s->swatchdog), 0,
for (i = 0; i < ARRAY_SIZE(s->ppc_irq_splitter); i++) {
Object *splitter = OBJECT(&s->ppc_irq_splitter[i]);
- if (!object_property_set_int(splitter, "num-lines", 2, &err)) {
- error_propagate(errp, err);
+ if (!object_property_set_int(splitter, "num-lines", 2, errp)) {
return;
}
- if (!qdev_realize(DEVICE(splitter), NULL, &err)) {
- error_propagate(errp, err);
+ if (!qdev_realize(DEVICE(splitter), NULL, errp)) {
return;
}
}
DeviceState *dev_splitter = DEVICE(splitter);
if (!object_property_set_int(OBJECT(splitter), "num-lines", 2,
- &err)) {
- error_propagate(errp, err);
+ errp)) {
return;
}
- if (!qdev_realize(DEVICE(splitter), NULL, &err)) {
- error_propagate(errp, err);
+ if (!qdev_realize(DEVICE(splitter), NULL, errp)) {
return;
}
}
if (object_property_find(OBJECT(s->cpu), "init-svtor", NULL)) {
if (!object_property_set_uint(OBJECT(s->cpu), "init-svtor",
- s->init_svtor, &err)) {
- error_propagate(errp, err);
+ s->init_svtor, errp)) {
return;
}
}
if (object_property_find(OBJECT(s->cpu), "start-powered-off", NULL)) {
if (!object_property_set_bool(OBJECT(s->cpu), "start-powered-off",
- s->start_powered_off, &err)) {
- error_propagate(errp, err);
+ s->start_powered_off, errp)) {
return;
}
}
if (object_property_find(OBJECT(s->cpu), "vfp", NULL)) {
- if (!object_property_set_bool(OBJECT(s->cpu), "vfp", s->vfp, &err)) {
- error_propagate(errp, err);
+ if (!object_property_set_bool(OBJECT(s->cpu), "vfp", s->vfp, errp)) {
return;
}
}
if (object_property_find(OBJECT(s->cpu), "dsp", NULL)) {
- if (!object_property_set_bool(OBJECT(s->cpu), "dsp", s->dsp, &err)) {
- error_propagate(errp, err);
+ if (!object_property_set_bool(OBJECT(s->cpu), "dsp", s->dsp, errp)) {
return;
}
}
s->cpu->env.nvic = &s->nvic;
s->nvic.cpu = s->cpu;
- if (!qdev_realize(DEVICE(s->cpu), NULL, &err)) {
- error_propagate(errp, err);
+ if (!qdev_realize(DEVICE(s->cpu), NULL, errp)) {
return;
}
/* Note that we must realize the NVIC after the CPU */
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->nvic), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->nvic), errp)) {
return;
}
SysBusDevice *sbd = SYS_BUS_DEVICE(&s->bitband[i]);
if (!object_property_set_int(obj, "base",
- bitband_input_addr[i], &err)) {
- error_propagate(errp, err);
+ bitband_input_addr[i], errp)) {
return;
}
object_property_set_link(obj, "source-memory",
OBJECT(s->board_memory), &error_abort);
- if (!sysbus_realize(SYS_BUS_DEVICE(obj), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(obj), errp)) {
return;
}
* is needed when using -kernel
*/
- if (!qdev_realize(DEVICE(&s->cpu[i]), NULL, &err)) {
- error_propagate(errp, err);
+ if (!qdev_realize(DEVICE(&s->cpu[i]), NULL, errp)) {
return;
}
}
sc->memmap[ASPEED_SRAM], &s->sram);
/* SCU */
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->scu), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->scu), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->scu), 0, sc->memmap[ASPEED_SCU]);
/* RTC */
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->rtc), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->rtc), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->rtc), 0, sc->memmap[ASPEED_RTC]);
/* Timer */
object_property_set_link(OBJECT(&s->timerctrl), "scu", OBJECT(&s->scu),
&error_abort);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->timerctrl), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->timerctrl), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->timerctrl), 0,
/* I2C */
object_property_set_link(OBJECT(&s->i2c), "dram", OBJECT(s->dram_mr),
&error_abort);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->i2c), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->i2c), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->i2c), 0, sc->memmap[ASPEED_I2C]);
object_property_set_link(OBJECT(&s->fmc), "dram", OBJECT(s->dram_mr),
&error_abort);
if (!object_property_set_int(OBJECT(&s->fmc), "sdram-base",
- sc->memmap[ASPEED_SDRAM], &err)) {
- error_propagate(errp, err);
+ sc->memmap[ASPEED_SDRAM], errp)) {
return;
}
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->fmc), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->fmc), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->fmc), 0, sc->memmap[ASPEED_FMC]);
object_property_set_link(OBJECT(&s->spi[i]), "dram",
OBJECT(s->dram_mr), &error_abort);
object_property_set_int(OBJECT(&s->spi[i]), "num-cs", 1, &error_abort);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->spi[i]), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->spi[i]), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->spi[i]), 0,
/* EHCI */
for (i = 0; i < sc->ehcis_num; i++) {
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->ehci[i]), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->ehci[i]), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->ehci[i]), 0,
}
/* SDMC - SDRAM Memory Controller */
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->sdmc), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->sdmc), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->sdmc), 0, sc->memmap[ASPEED_SDMC]);
object_property_set_link(OBJECT(&s->wdt[i]), "scu", OBJECT(&s->scu),
&error_abort);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->wdt[i]), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->wdt[i]), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->wdt[i]), 0,
for (i = 0; i < sc->macs_num; i++) {
object_property_set_bool(OBJECT(&s->ftgmac100[i]), "aspeed", true,
&error_abort);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->ftgmac100[i]), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->ftgmac100[i]), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->ftgmac100[i]), 0,
object_property_set_link(OBJECT(&s->mii[i]), "nic",
OBJECT(&s->ftgmac100[i]), &error_abort);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->mii[i]), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->mii[i]), errp)) {
return;
}
}
/* XDMA */
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->xdma), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->xdma), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->xdma), 0,
aspeed_soc_get_irq(s, ASPEED_XDMA));
/* GPIO */
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->gpio), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->gpio), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->gpio), 0, sc->memmap[ASPEED_GPIO]);
sysbus_connect_irq(SYS_BUS_DEVICE(&s->gpio), 0,
aspeed_soc_get_irq(s, ASPEED_GPIO));
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->gpio_1_8v), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->gpio_1_8v), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->gpio_1_8v), 0,
aspeed_soc_get_irq(s, ASPEED_GPIO_1_8V));
/* SDHCI */
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->sdhci), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->sdhci), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->sdhci), 0,
aspeed_soc_get_irq(s, ASPEED_SDHCI));
/* eMMC */
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->emmc), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->emmc), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->emmc), 0, sc->memmap[ASPEED_EMMC]);
/* CPU */
for (i = 0; i < sc->num_cpus; i++) {
- if (!qdev_realize(DEVICE(&s->cpu[i]), NULL, &err)) {
- error_propagate(errp, err);
+ if (!qdev_realize(DEVICE(&s->cpu[i]), NULL, errp)) {
return;
}
}
sc->memmap[ASPEED_SRAM], &s->sram);
/* SCU */
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->scu), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->scu), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->scu), 0, sc->memmap[ASPEED_SCU]);
/* VIC */
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->vic), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->vic), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->vic), 0, sc->memmap[ASPEED_VIC]);
qdev_get_gpio_in(DEVICE(&s->cpu), ARM_CPU_FIQ));
/* RTC */
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->rtc), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->rtc), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->rtc), 0, sc->memmap[ASPEED_RTC]);
/* Timer */
object_property_set_link(OBJECT(&s->timerctrl), "scu", OBJECT(&s->scu),
&error_abort);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->timerctrl), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->timerctrl), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->timerctrl), 0,
/* I2C */
object_property_set_link(OBJECT(&s->i2c), "dram", OBJECT(s->dram_mr),
&error_abort);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->i2c), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->i2c), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->i2c), 0, sc->memmap[ASPEED_I2C]);
object_property_set_link(OBJECT(&s->fmc), "dram", OBJECT(s->dram_mr),
&error_abort);
if (!object_property_set_int(OBJECT(&s->fmc), "sdram-base",
- sc->memmap[ASPEED_SDRAM], &err)) {
- error_propagate(errp, err);
+ sc->memmap[ASPEED_SDRAM], errp)) {
return;
}
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->fmc), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->fmc), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->fmc), 0, sc->memmap[ASPEED_FMC]);
/* SPI */
for (i = 0; i < sc->spis_num; i++) {
object_property_set_int(OBJECT(&s->spi[i]), "num-cs", 1, &error_abort);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->spi[i]), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->spi[i]), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->spi[i]), 0,
/* EHCI */
for (i = 0; i < sc->ehcis_num; i++) {
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->ehci[i]), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->ehci[i]), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->ehci[i]), 0,
}
/* SDMC - SDRAM Memory Controller */
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->sdmc), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->sdmc), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->sdmc), 0, sc->memmap[ASPEED_SDMC]);
object_property_set_link(OBJECT(&s->wdt[i]), "scu", OBJECT(&s->scu),
&error_abort);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->wdt[i]), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->wdt[i]), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->wdt[i]), 0,
for (i = 0; i < sc->macs_num; i++) {
object_property_set_bool(OBJECT(&s->ftgmac100[i]), "aspeed", true,
&error_abort);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->ftgmac100[i]), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->ftgmac100[i]), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->ftgmac100[i]), 0,
}
/* XDMA */
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->xdma), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->xdma), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->xdma), 0,
aspeed_soc_get_irq(s, ASPEED_XDMA));
/* GPIO */
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->gpio), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->gpio), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->gpio), 0, sc->memmap[ASPEED_GPIO]);
aspeed_soc_get_irq(s, ASPEED_GPIO));
/* SDHCI */
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->sdhci), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->sdhci), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->sdhci), 0,
}
/* Interrupt Controller */
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->ic), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->ic), errp)) {
return;
}
sysbus_pass_irq(SYS_BUS_DEVICE(s), SYS_BUS_DEVICE(&s->ic));
/* Sys Timer */
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->systmr), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->systmr), errp)) {
return;
}
memory_region_add_subregion(&s->peri_mr, ST_OFFSET,
/* UART0 */
qdev_prop_set_chr(DEVICE(&s->uart0), "chardev", serial_hd(0));
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->uart0), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->uart0), errp)) {
return;
}
/* AUX / UART1 */
qdev_prop_set_chr(DEVICE(&s->aux), "chardev", serial_hd(1));
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->aux), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->aux), errp)) {
return;
}
INTERRUPT_AUX));
/* Mailboxes */
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->mboxes), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->mboxes), errp)) {
return;
}
}
if (!object_property_set_uint(OBJECT(&s->fb), "vcram-base",
- ram_size - vcram_size, &err)) {
- error_propagate(errp, err);
+ ram_size - vcram_size, errp)) {
return;
}
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->fb), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->fb), errp)) {
return;
}
qdev_get_gpio_in(DEVICE(&s->mboxes), MBOX_CHAN_FB));
/* Property channel */
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->property), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->property), errp)) {
return;
}
qdev_get_gpio_in(DEVICE(&s->mboxes), MBOX_CHAN_PROPERTY));
/* Random Number Generator */
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->rng), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->rng), errp)) {
return;
}
BCM2835_SDHC_CAPAREG, &error_abort);
object_property_set_bool(OBJECT(&s->sdhci), "pending-insert-quirk", true,
&error_abort);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->sdhci), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->sdhci), errp)) {
return;
}
INTERRUPT_ARASANSDIO));
/* SDHOST */
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->sdhost), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->sdhost), errp)) {
return;
}
INTERRUPT_SDIO));
/* DMA Channels */
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->dma), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->dma), errp)) {
return;
}
}
/* THERMAL */
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->thermal), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->thermal), errp)) {
return;
}
memory_region_add_subregion(&s->peri_mr, THERMAL_OFFSET,
sysbus_mmio_get_region(SYS_BUS_DEVICE(&s->thermal), 0));
/* GPIO */
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->gpio), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->gpio), errp)) {
return;
}
object_property_add_alias(OBJECT(s), "sd-bus", OBJECT(&s->gpio), "sd-bus");
/* Mphi */
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->mphi), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->mphi), errp)) {
return;
}
INTERRUPT_HOSTPORT));
/* DWC2 */
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->dwc2), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->dwc2), errp)) {
return;
}
BCM283XClass *bc = BCM283X_GET_CLASS(dev);
const BCM283XInfo *info = bc->info;
Object *obj;
- Error *err = NULL;
int n;
/* common peripherals from bcm2835 */
object_property_add_const_link(OBJECT(&s->peripherals), "ram", obj);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->peripherals), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->peripherals), errp)) {
return;
}
info->peri_base, 1);
/* bcm2836 interrupt controller (and mailboxes, etc.) */
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->control), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->control), errp)) {
return;
}
/* set periphbase/CBAR value for CPU-local registers */
if (!object_property_set_int(OBJECT(&s->cpu[n].core), "reset-cbar",
- info->peri_base, &err)) {
- error_propagate(errp, err);
+ info->peri_base, errp)) {
return;
}
if (!object_property_set_bool(OBJECT(&s->cpu[n].core),
"start-powered-off",
n >= s->enabled_cpus,
- &err)) {
- error_propagate(errp, err);
+ errp)) {
return;
}
- if (!qdev_realize(DEVICE(&s->cpu[n].core), NULL, &err)) {
- error_propagate(errp, err);
+ if (!qdev_realize(DEVICE(&s->cpu[n].core), NULL, errp)) {
return;
}
static void digic_realize(DeviceState *dev, Error **errp)
{
DigicState *s = DIGIC(dev);
- Error *err = NULL;
SysBusDevice *sbd;
int i;
if (!object_property_set_bool(OBJECT(&s->cpu), "reset-hivecs", true,
- &err)) {
- error_propagate(errp, err);
+ errp)) {
return;
}
- if (!qdev_realize(DEVICE(&s->cpu), NULL, &err)) {
- error_propagate(errp, err);
+ if (!qdev_realize(DEVICE(&s->cpu), NULL, errp)) {
return;
}
for (i = 0; i < DIGIC4_NB_TIMERS; i++) {
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->timer[i]), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->timer[i]), errp)) {
return;
}
}
qdev_prop_set_chr(DEVICE(&s->uart), "chardev", serial_hd(0));
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->uart), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->uart), errp)) {
return;
}
uint8_t i;
Error *err = NULL;
- if (!qdev_realize(DEVICE(&s->cpu), NULL, &err)) {
- error_propagate(errp, err);
+ if (!qdev_realize(DEVICE(&s->cpu), NULL, errp)) {
return;
}
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->avic), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->avic), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->avic), 0, FSL_IMX25_AVIC_ADDR);
sysbus_connect_irq(SYS_BUS_DEVICE(&s->avic), 1,
qdev_get_gpio_in(DEVICE(&s->cpu), ARM_CPU_FIQ));
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->ccm), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->ccm), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->ccm), 0, FSL_IMX25_CCM_ADDR);
qdev_prop_set_chr(DEVICE(&s->uart[i]), "chardev", serial_hd(i));
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->uart[i]), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->uart[i]), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->uart[i]), 0, serial_table[i].addr);
s->gpt[i].ccm = IMX_CCM(&s->ccm);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->gpt[i]), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->gpt[i]), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->gpt[i]), 0, gpt_table[i].addr);
s->epit[i].ccm = IMX_CCM(&s->ccm);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->epit[i]), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->epit[i]), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->epit[i]), 0, epit_table[i].addr);
qdev_set_nic_properties(DEVICE(&s->fec), &nd_table[0]);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->fec), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->fec), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->fec), 0, FSL_IMX25_FEC_ADDR);
sysbus_connect_irq(SYS_BUS_DEVICE(&s->fec), 0,
qdev_get_gpio_in(DEVICE(&s->avic), FSL_IMX25_FEC_IRQ));
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->rngc), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->rngc), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->rngc), 0, FSL_IMX25_RNGC_ADDR);
{ FSL_IMX25_I2C3_ADDR, FSL_IMX25_I2C3_IRQ }
};
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->i2c[i]), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->i2c[i]), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->i2c[i]), 0, i2c_table[i].addr);
{ FSL_IMX25_GPIO4_ADDR, FSL_IMX25_GPIO4_IRQ }
};
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->gpio[i]), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->gpio[i]), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->gpio[i]), 0, gpio_table[i].addr);
IMX25_ESDHC_CAPABILITIES, &error_abort);
object_property_set_uint(OBJECT(&s->esdhc[i]), "vendor",
SDHCI_VENDOR_IMX, &error_abort);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->esdhc[i]), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->esdhc[i]), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->esdhc[i]), 0, esdhc_table[i].addr);
uint16_t i;
Error *err = NULL;
- if (!qdev_realize(DEVICE(&s->cpu), NULL, &err)) {
- error_propagate(errp, err);
+ if (!qdev_realize(DEVICE(&s->cpu), NULL, errp)) {
return;
}
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->avic), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->avic), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->avic), 0, FSL_IMX31_AVIC_ADDR);
sysbus_connect_irq(SYS_BUS_DEVICE(&s->avic), 1,
qdev_get_gpio_in(DEVICE(&s->cpu), ARM_CPU_FIQ));
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->ccm), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->ccm), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->ccm), 0, FSL_IMX31_CCM_ADDR);
qdev_prop_set_chr(DEVICE(&s->uart[i]), "chardev", serial_hd(i));
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->uart[i]), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->uart[i]), errp)) {
return;
}
s->gpt.ccm = IMX_CCM(&s->ccm);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->gpt), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->gpt), errp)) {
return;
}
s->epit[i].ccm = IMX_CCM(&s->ccm);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->epit[i]), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->epit[i]), errp)) {
return;
}
};
/* Initialize the I2C */
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->i2c[i]), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->i2c[i]), errp)) {
return;
}
/* Map I2C memory */
object_property_set_bool(OBJECT(&s->gpio[i]), "has-edge-sel", false,
&error_abort);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->gpio[i]), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->gpio[i]), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->gpio[i]), 0, gpio_table[i].addr);
true, &error_abort);
}
- if (!qdev_realize(DEVICE(&s->cpu[i]), NULL, &err)) {
- error_propagate(errp, err);
+ if (!qdev_realize(DEVICE(&s->cpu[i]), NULL, errp)) {
return;
}
}
object_property_set_int(OBJECT(&s->a9mpcore), "num-irq",
FSL_IMX6_MAX_IRQ + GIC_INTERNAL, &error_abort);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->a9mpcore), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->a9mpcore), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->a9mpcore), 0, FSL_IMX6_A9MPCORE_ADDR);
qdev_get_gpio_in(DEVICE(&s->cpu[i]), ARM_CPU_FIQ));
}
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->ccm), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->ccm), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->ccm), 0, FSL_IMX6_CCM_ADDR);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->src), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->src), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->src), 0, FSL_IMX6_SRC_ADDR);
qdev_prop_set_chr(DEVICE(&s->uart[i]), "chardev", serial_hd(i));
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->uart[i]), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->uart[i]), errp)) {
return;
}
s->gpt.ccm = IMX_CCM(&s->ccm);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->gpt), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->gpt), errp)) {
return;
}
s->epit[i].ccm = IMX_CCM(&s->ccm);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->epit[i]), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->epit[i]), errp)) {
return;
}
{ FSL_IMX6_I2C3_ADDR, FSL_IMX6_I2C3_IRQ }
};
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->i2c[i]), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->i2c[i]), errp)) {
return;
}
&error_abort);
object_property_set_bool(OBJECT(&s->gpio[i]), "has-upper-pin-irq",
true, &error_abort);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->gpio[i]), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->gpio[i]), errp)) {
return;
}
IMX6_ESDHC_CAPABILITIES, &error_abort);
object_property_set_uint(OBJECT(&s->esdhc[i]), "vendor",
SDHCI_VENDOR_IMX, &error_abort);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->esdhc[i]), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->esdhc[i]), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->esdhc[i]), 0, esdhc_table[i].addr);
};
/* Initialize the SPI */
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->spi[i]), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->spi[i]), errp)) {
return;
}
}
qdev_set_nic_properties(DEVICE(&s->eth), &nd_table[0]);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->eth), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->eth), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->eth), 0, FSL_IMX6_ENET_ADDR);
MSF2State *s = MSF2_SOC(dev_soc);
DeviceState *dev, *armv7m;
SysBusDevice *busdev;
- Error *err = NULL;
int i;
MemoryRegion *system_memory = get_system_memory();
qdev_prop_set_bit(armv7m, "enable-bitband", true);
object_property_set_link(OBJECT(&s->armv7m), "memory",
OBJECT(get_system_memory()), &error_abort);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->armv7m), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->armv7m), errp)) {
return;
}
dev = DEVICE(&s->timer);
/* APB0 clock is the timer input clock */
qdev_prop_set_uint32(dev, "clock-frequency", s->m3clk / s->apb0div);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->timer), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->timer), errp)) {
return;
}
busdev = SYS_BUS_DEVICE(dev);
dev = DEVICE(&s->sysreg);
qdev_prop_set_uint32(dev, "apb0divisor", s->apb0div);
qdev_prop_set_uint32(dev, "apb1divisor", s->apb1div);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->sysreg), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->sysreg), errp)) {
return;
}
busdev = SYS_BUS_DEVICE(dev);
for (i = 0; i < MSF2_NUM_SPIS; i++) {
gchar *bus_name;
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->spi[i]), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->spi[i]), errp)) {
return;
}
dev = DEVICE(&s->emac);
object_property_set_link(OBJECT(&s->emac), "ahb-bus",
OBJECT(get_system_memory()), &error_abort);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->emac), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->emac), errp)) {
return;
}
busdev = SYS_BUS_DEVICE(dev);
object_property_set_link(OBJECT(&s->cpu), "memory", OBJECT(&s->container),
&error_abort);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->cpu), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->cpu), errp)) {
return;
}
memory_region_add_subregion(&s->container, NRF51_SRAM_BASE, &s->sram);
/* UART */
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->uart), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->uart), errp)) {
return;
}
mr = sysbus_mmio_get_region(SYS_BUS_DEVICE(&s->uart), 0);
BASE_TO_IRQ(NRF51_UART_BASE)));
/* RNG */
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->rng), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->rng), errp)) {
return;
}
/* UICR, FICR, NVMC, FLASH */
if (!object_property_set_uint(OBJECT(&s->nvm), "flash-size",
- s->flash_size, &err)) {
- error_propagate(errp, err);
+ s->flash_size, errp)) {
return;
}
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->nvm), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->nvm), errp)) {
return;
}
memory_region_add_subregion_overlap(&s->container, NRF51_FLASH_BASE, mr, 0);
/* GPIO */
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->gpio), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->gpio), errp)) {
return;
}
/* TIMER */
for (i = 0; i < NRF51_NUM_TIMERS; i++) {
- if (!object_property_set_uint(OBJECT(&s->timer[i]), "id", i, &err)) {
- error_propagate(errp, err);
+ if (!object_property_set_uint(OBJECT(&s->timer[i]), "id", i, errp)) {
return;
}
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->timer[i]), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->timer[i]), errp)) {
return;
}
STM32F205State *s = STM32F205_SOC(dev_soc);
DeviceState *dev, *armv7m;
SysBusDevice *busdev;
- Error *err = NULL;
int i;
MemoryRegion *system_memory = get_system_memory();
qdev_prop_set_bit(armv7m, "enable-bitband", true);
object_property_set_link(OBJECT(&s->armv7m), "memory",
OBJECT(get_system_memory()), &error_abort);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->armv7m), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->armv7m), errp)) {
return;
}
/* System configuration controller */
dev = DEVICE(&s->syscfg);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->syscfg), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->syscfg), errp)) {
return;
}
busdev = SYS_BUS_DEVICE(dev);
for (i = 0; i < STM_NUM_USARTS; i++) {
dev = DEVICE(&(s->usart[i]));
qdev_prop_set_chr(dev, "chardev", serial_hd(i));
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->usart[i]), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->usart[i]), errp)) {
return;
}
busdev = SYS_BUS_DEVICE(dev);
for (i = 0; i < STM_NUM_TIMERS; i++) {
dev = DEVICE(&(s->timer[i]));
qdev_prop_set_uint64(dev, "clock-frequency", 1000000000);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->timer[i]), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->timer[i]), errp)) {
return;
}
busdev = SYS_BUS_DEVICE(dev);
/* ADC 1 to 3 */
object_property_set_int(OBJECT(s->adc_irqs), "num-lines", STM_NUM_ADCS,
&error_abort);
- if (!qdev_realize(DEVICE(s->adc_irqs), NULL, &err)) {
- error_propagate(errp, err);
+ if (!qdev_realize(DEVICE(s->adc_irqs), NULL, errp)) {
return;
}
qdev_connect_gpio_out(DEVICE(s->adc_irqs), 0,
for (i = 0; i < STM_NUM_ADCS; i++) {
dev = DEVICE(&(s->adc[i]));
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->adc[i]), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->adc[i]), errp)) {
return;
}
busdev = SYS_BUS_DEVICE(dev);
/* SPI 1 and 2 */
for (i = 0; i < STM_NUM_SPIS; i++) {
dev = DEVICE(&(s->spi[i]));
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->spi[i]), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->spi[i]), errp)) {
return;
}
busdev = SYS_BUS_DEVICE(dev);
qdev_prop_set_bit(armv7m, "enable-bitband", true);
object_property_set_link(OBJECT(&s->armv7m), "memory",
OBJECT(system_memory), &error_abort);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->armv7m), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->armv7m), errp)) {
return;
}
/* System configuration controller */
dev = DEVICE(&s->syscfg);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->syscfg), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->syscfg), errp)) {
return;
}
busdev = SYS_BUS_DEVICE(dev);
for (i = 0; i < STM_NUM_USARTS; i++) {
dev = DEVICE(&(s->usart[i]));
qdev_prop_set_chr(dev, "chardev", serial_hd(i));
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->usart[i]), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->usart[i]), errp)) {
return;
}
busdev = SYS_BUS_DEVICE(dev);
for (i = 0; i < STM_NUM_TIMERS; i++) {
dev = DEVICE(&(s->timer[i]));
qdev_prop_set_uint64(dev, "clock-frequency", 1000000000);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->timer[i]), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->timer[i]), errp)) {
return;
}
busdev = SYS_BUS_DEVICE(dev);
/* ADC device, the IRQs are ORed together */
if (!object_initialize_child_with_props(OBJECT(s), "adc-orirq",
&s->adc_irqs, sizeof(s->adc_irqs),
- TYPE_OR_IRQ, &err, NULL)) {
- error_propagate(errp, err);
+ TYPE_OR_IRQ, errp, NULL)) {
return;
}
object_property_set_int(OBJECT(&s->adc_irqs), "num-lines", STM_NUM_ADCS,
&error_abort);
- if (!qdev_realize(DEVICE(&s->adc_irqs), NULL, &err)) {
- error_propagate(errp, err);
+ if (!qdev_realize(DEVICE(&s->adc_irqs), NULL, errp)) {
return;
}
qdev_connect_gpio_out(DEVICE(&s->adc_irqs), 0,
for (i = 0; i < STM_NUM_ADCS; i++) {
dev = DEVICE(&(s->adc[i]));
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->adc[i]), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->adc[i]), errp)) {
return;
}
busdev = SYS_BUS_DEVICE(dev);
/* SPI devices */
for (i = 0; i < STM_NUM_SPIS; i++) {
dev = DEVICE(&(s->spi[i]));
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->spi[i]), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->spi[i]), errp)) {
return;
}
busdev = SYS_BUS_DEVICE(dev);
/* EXTI device */
dev = DEVICE(&s->exti);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->exti), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->exti), errp)) {
return;
}
busdev = SYS_BUS_DEVICE(dev);
static void xlnx_zynqmp_create_rpu(MachineState *ms, XlnxZynqMPState *s,
const char *boot_cpu, Error **errp)
{
- Error *err = NULL;
int i;
int num_rpus = MIN(ms->smp.cpus - XLNX_ZYNQMP_NUM_APU_CPUS,
XLNX_ZYNQMP_NUM_RPU_CPUS);
object_property_set_bool(OBJECT(&s->rpu_cpu[i]), "reset-hivecs", true,
&error_abort);
- if (!qdev_realize(DEVICE(&s->rpu_cpu[i]), NULL, &err)) {
- error_propagate(errp, err);
+ if (!qdev_realize(DEVICE(&s->rpu_cpu[i]), NULL, errp)) {
return;
}
}
GIC_BASE_ADDR, &error_abort);
object_property_set_int(OBJECT(&s->apu_cpu[i]), "core-count",
num_apus, &error_abort);
- if (!qdev_realize(DEVICE(&s->apu_cpu[i]), NULL, &err)) {
- error_propagate(errp, err);
+ if (!qdev_realize(DEVICE(&s->apu_cpu[i]), NULL, errp)) {
return;
}
}
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->gic), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->gic), errp)) {
return;
}
&error_abort);
object_property_set_int(OBJECT(&s->gem[i]), "num-priority-queues", 2,
&error_abort);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->gem[i]), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->gem[i]), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->gem[i]), 0, gem_addr[i]);
for (i = 0; i < XLNX_ZYNQMP_NUM_UARTS; i++) {
qdev_prop_set_chr(DEVICE(&s->uart[i]), "chardev", serial_hd(i));
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->uart[i]), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->uart[i]), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->uart[i]), 0, uart_addr[i]);
object_property_set_int(OBJECT(&s->sata), "num-ports", SATA_NUM_PORTS,
&error_abort);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->sata), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->sata), errp)) {
return;
}
* - SDIO Specification Version 3.0
* - eMMC Specification Version 4.51
*/
- if (!object_property_set_uint(sdhci, "sd-spec-version", 3, &err)) {
- error_propagate(errp, err);
+ if (!object_property_set_uint(sdhci, "sd-spec-version", 3, errp)) {
return;
}
if (!object_property_set_uint(sdhci, "capareg", SDHCI_CAPABILITIES,
- &err)) {
- error_propagate(errp, err);
+ errp)) {
return;
}
- if (!object_property_set_uint(sdhci, "uhs", UHS_I, &err)) {
- error_propagate(errp, err);
+ if (!object_property_set_uint(sdhci, "uhs", UHS_I, errp)) {
return;
}
- if (!sysbus_realize(SYS_BUS_DEVICE(sdhci), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(sdhci), errp)) {
return;
}
sysbus_mmio_map(sbd, 0, sdhci_addr[i]);
for (i = 0; i < XLNX_ZYNQMP_NUM_SPIS; i++) {
gchar *bus_name;
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->spi[i]), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->spi[i]), errp)) {
return;
}
g_free(bus_name);
}
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->qspi), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->qspi), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->qspi), 0, QSPI_ADDR);
g_free(target_bus);
}
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->dp), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->dp), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->dp), 0, DP_ADDR);
sysbus_connect_irq(SYS_BUS_DEVICE(&s->dp), 0, gic_spi[DP_IRQ]);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->dpdma), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->dpdma), errp)) {
return;
}
object_property_set_link(OBJECT(&s->dp), "dpdma", OBJECT(&s->dpdma),
sysbus_mmio_map(SYS_BUS_DEVICE(&s->dpdma), 0, DPDMA_ADDR);
sysbus_connect_irq(SYS_BUS_DEVICE(&s->dpdma), 0, gic_spi[DPDMA_IRQ]);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->ipi), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->ipi), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->ipi), 0, IPI_ADDR);
sysbus_connect_irq(SYS_BUS_DEVICE(&s->ipi), 0, gic_spi[IPI_IRQ]);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->rtc), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->rtc), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->rtc), 0, RTC_ADDR);
for (i = 0; i < XLNX_ZYNQMP_NUM_GDMA_CH; i++) {
if (!object_property_set_uint(OBJECT(&s->gdma[i]), "bus-width", 128,
- &err)) {
- error_propagate(errp, err);
+ errp)) {
return;
}
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->gdma[i]), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->gdma[i]), errp)) {
return;
}
}
for (i = 0; i < XLNX_ZYNQMP_NUM_ADMA_CH; i++) {
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->adma[i]), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->adma[i]), errp)) {
return;
}
return;
}
- if (!qdev_realize_and_unref(dev, &fdctrl->bus.bus, &local_err)) {
- error_propagate(errp, local_err);
+ if (!qdev_realize_and_unref(dev, &fdctrl->bus.bus, errp)) {
return;
}
}
DeviceState *dev = DEVICE(obj);
Property *prop = opaque;
XenBlockVdev *vdev = qdev_get_prop_ptr(dev, prop);
- Error *local_err = NULL;
char *str, *p;
const char *end;
return;
}
- if (!visit_type_str(v, name, &str, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_str(v, name, &str, errp)) {
return;
}
PCIDeviceClass *pc = PCI_DEVICE_GET_CLASS(dev);
PCIMultiSerialState *pci = DO_UPCAST(PCIMultiSerialState, dev, dev);
SerialState *s;
- Error *err = NULL;
size_t i, nports = multi_serial_get_port_count(pc);
pci->dev.config[PCI_CLASS_PROG] = pci->prog_if;
for (i = 0; i < nports; i++) {
s = pci->state + i;
- if (!qdev_realize(DEVICE(s), NULL, &err)) {
- error_propagate(errp, err);
+ if (!qdev_realize(DEVICE(s), NULL, errp)) {
multi_serial_pci_exit(dev);
return;
}
{
PCISerialState *pci = DO_UPCAST(PCISerialState, dev, dev);
SerialState *s = &pci->state;
- Error *err = NULL;
- if (!qdev_realize(DEVICE(s), NULL, &err)) {
- error_propagate(errp, err);
+ if (!qdev_realize(DEVICE(s), NULL, errp)) {
return;
}
{
SerialIO *sio = SERIAL_IO(dev);
SerialState *s = &sio->serial;
- Error *local_err = NULL;
- if (!qdev_realize(DEVICE(s), NULL, &local_err)) {
- error_propagate(errp, local_err);
+ if (!qdev_realize(DEVICE(s), NULL, errp)) {
return;
}
{
SerialMM *smm = SERIAL_MM(dev);
SerialState *s = &smm->serial;
- Error *local_err = NULL;
- if (!qdev_realize(DEVICE(s), NULL, &local_err)) {
- error_propagate(errp, local_err);
+ if (!qdev_realize(DEVICE(s), NULL, errp)) {
return;
}
Error **errp)
{
MachineState *ms = MACHINE(obj);
- Error *error = NULL;
int64_t value;
- if (!visit_type_int(v, name, &value, &error)) {
- error_propagate(errp, error);
+ if (!visit_type_int(v, name, &value, errp)) {
return;
}
{
DeviceState *dev = DEVICE(obj);
Property *prop = opaque;
- Error *local_err = NULL;
void **ptr = qdev_get_prop_ptr(dev, prop);
char *str;
BlockBackend *blk;
return;
}
- if (!visit_type_str(v, name, &str, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_str(v, name, &str, errp)) {
return;
}
Error **errp)
{
DeviceState *dev = DEVICE(obj);
- Error *local_err = NULL;
Property *prop = opaque;
CharBackend *be = qdev_get_prop_ptr(dev, prop);
Chardev *s;
return;
}
- if (!visit_type_str(v, name, &str, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_str(v, name, &str, errp)) {
return;
}
NICPeers *peers_ptr = qdev_get_prop_ptr(dev, prop);
NetClientState **ncs = peers_ptr->ncs;
NetClientState *peers[MAX_QUEUE_NUM];
- Error *local_err = NULL;
int queues, err = 0, i = 0;
char *str;
return;
}
- if (!visit_type_str(v, name, &str, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_str(v, name, &str, errp)) {
return;
}
Property *prop = opaque;
QEMUSoundCard *card = qdev_get_prop_ptr(dev, prop);
AudioState *state;
- Error *local_err = NULL;
int err = 0;
char *str;
return;
}
- if (!visit_type_str(v, name, &str, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_str(v, name, &str, errp)) {
return;
}
{
DeviceState *dev = DEVICE(obj);
Property *prop = opaque;
- Error *local_err = NULL;
bool value;
if (dev->realized) {
return;
}
- if (!visit_type_bool(v, name, &value, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_bool(v, name, &value, errp)) {
return;
}
bit_prop_set(dev, prop, value);
{
DeviceState *dev = DEVICE(obj);
Property *prop = opaque;
- Error *local_err = NULL;
bool value;
if (dev->realized) {
return;
}
- if (!visit_type_bool(v, name, &value, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_bool(v, name, &value, errp)) {
return;
}
bit64_prop_set(dev, prop, value);
DeviceState *dev = DEVICE(obj);
Property *prop = opaque;
char **ptr = qdev_get_prop_ptr(dev, prop);
- Error *local_err = NULL;
char *str;
if (dev->realized) {
return;
}
- if (!visit_type_str(v, name, &str, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_str(v, name, &str, errp)) {
return;
}
g_free(*ptr);
DeviceState *dev = DEVICE(obj);
Property *prop = opaque;
MACAddr *mac = qdev_get_prop_ptr(dev, prop);
- Error *local_err = NULL;
int i, pos;
char *str, *p;
return;
}
- if (!visit_type_str(v, name, &str, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_str(v, name, &str, errp)) {
return;
}
Property *prop = opaque;
uint32_t *ptr = qdev_get_prop_ptr(dev, prop);
uint64_t value;
- Error *local_err = NULL;
if (dev->realized) {
qdev_prop_set_after_realize(dev, name, errp);
return;
}
- if (!visit_type_size(v, name, &value, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_size(v, name, &value, errp)) {
return;
}
Property *prop = opaque;
uint32_t *ptr = qdev_get_prop_ptr(dev, prop);
uint64_t value;
- Error *local_err = NULL;
if (dev->realized) {
qdev_prop_set_after_realize(dev, name, errp);
return;
}
- if (!visit_type_size(v, name, &value, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_size(v, name, &value, errp)) {
return;
}
/* value of 0 means "unset" */
DeviceState *dev = DEVICE(obj);
Property *prop = opaque;
PCIHostDeviceAddress *addr = qdev_get_prop_ptr(dev, prop);
- Error *local_err = NULL;
char *str, *p;
char *e;
unsigned long val;
return;
}
- if (!visit_type_str(v, name, &str, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_str(v, name, &str, errp)) {
return;
}
DeviceState *dev = DEVICE(obj);
Property *prop = opaque;
QemuUUID *uuid = qdev_get_prop_ptr(dev, prop);
- Error *local_err = NULL;
char *str;
if (dev->realized) {
return;
}
- if (!visit_type_str(v, name, &str, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_str(v, name, &str, errp)) {
return;
}
Property *prop = opaque;
uint32_t *alenptr = qdev_get_prop_ptr(dev, prop);
void **arrayptr = (void *)dev + prop->arrayoffset;
- Error *local_err = NULL;
void *eltptr;
const char *arrayname;
int i;
name);
return;
}
- if (!visit_type_uint32(v, name, alenptr, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_uint32(v, name, alenptr, errp)) {
return;
}
if (!*alenptr) {
Property *prop = opaque;
PCIExpLinkSpeed *p = qdev_get_prop_ptr(dev, prop);
int speed;
- Error *local_err = NULL;
if (dev->realized) {
qdev_prop_set_after_realize(dev, name, errp);
}
if (!visit_type_enum(v, prop->name, &speed, prop->info->enum_table,
- &local_err)) {
- error_propagate(errp, local_err);
+ errp)) {
return;
}
Property *prop = opaque;
PCIExpLinkWidth *p = qdev_get_prop_ptr(dev, prop);
int width;
- Error *local_err = NULL;
if (dev->realized) {
qdev_prop_set_after_realize(dev, name, errp);
}
if (!visit_type_enum(v, prop->name, &width, prop->info->enum_table,
- &local_err)) {
- error_propagate(errp, local_err);
+ errp)) {
return;
}
DeviceState *gicdev;
SysBusDevice *busdev;
int i;
- Error *err = NULL;
bool has_el3;
bool has_el2 = false;
Object *cpuobj;
qdev_prop_set_bit(gicdev, "has-virtualization-extensions", has_el2);
}
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->gic), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->gic), errp)) {
return;
}
busdev = SYS_BUS_DEVICE(&s->gic);
DeviceState *scudev, *gicdev, *gtimerdev, *mptimerdev, *wdtdev;
SysBusDevice *scubusdev, *gicbusdev, *gtimerbusdev, *mptimerbusdev,
*wdtbusdev;
- Error *err = NULL;
int i;
bool has_el3;
Object *cpuobj;
scudev = DEVICE(&s->scu);
qdev_prop_set_uint32(scudev, "num-cpu", s->num_cpu);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->scu), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->scu), errp)) {
return;
}
scubusdev = SYS_BUS_DEVICE(&s->scu);
object_property_get_bool(cpuobj, "has_el3", &error_abort);
qdev_prop_set_bit(gicdev, "has-security-extensions", has_el3);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->gic), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->gic), errp)) {
return;
}
gicbusdev = SYS_BUS_DEVICE(&s->gic);
gtimerdev = DEVICE(&s->gtimer);
qdev_prop_set_uint32(gtimerdev, "num-cpu", s->num_cpu);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->gtimer), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->gtimer), errp)) {
return;
}
gtimerbusdev = SYS_BUS_DEVICE(&s->gtimer);
mptimerdev = DEVICE(&s->mptimer);
qdev_prop_set_uint32(mptimerdev, "num-cpu", s->num_cpu);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->mptimer), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->mptimer), errp)) {
return;
}
mptimerbusdev = SYS_BUS_DEVICE(&s->mptimer);
wdtdev = DEVICE(&s->wdt);
qdev_prop_set_uint32(wdtdev, "num-cpu", s->num_cpu);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->wdt), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->wdt), errp)) {
return;
}
wdtbusdev = SYS_BUS_DEVICE(&s->wdt);
DeviceState *gicdev = DEVICE(&s->gic);
DeviceState *mptimerdev = DEVICE(&s->mptimer);
DeviceState *wdtimerdev = DEVICE(&s->wdtimer);
- Error *err = NULL;
qdev_prop_set_uint32(scudev, "num-cpu", s->num_cpu);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->scu), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->scu), errp)) {
return;
}
ARM11MPCORE_NUM_GIC_PRIORITY_BITS);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->gic), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->gic), errp)) {
return;
}
qdev_init_gpio_in(dev, mpcore_priv_set_irq, s->num_irq - 32);
qdev_prop_set_uint32(mptimerdev, "num-cpu", s->num_cpu);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->mptimer), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->mptimer), errp)) {
return;
}
qdev_prop_set_uint32(wdtimerdev, "num-cpu", s->num_cpu);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->wdtimer), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->wdtimer), errp)) {
return;
}
void *opaque, Error **errp)
{
CPUCore *core = CPU_CORE(obj);
- Error *local_err = NULL;
int64_t value;
- if (!visit_type_int(v, name, &value, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_int(v, name, &value, errp)) {
return;
}
void *opaque, Error **errp)
{
CPUCore *core = CPU_CORE(obj);
- Error *local_err = NULL;
int64_t value;
- if (!visit_type_int(v, name, &value, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_int(v, name, &value, errp)) {
return;
}
DeviceState *priv = DEVICE(&s->priv);
DeviceState *gic;
SysBusDevice *gicbusdev;
- Error *err = NULL;
int n;
int i;
qdev_prop_set_uint32(priv, "num-cpu", s->num_cpu);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->priv), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->priv), errp)) {
return;
}
sysbus_pass_irq(sbd, SYS_BUS_DEVICE(&s->priv));
}
/* ??? IRQ routing is hardcoded to "normal" mode. */
for (n = 0; n < 4; n++) {
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->gic[n]), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->gic[n]), errp)) {
return;
}
gic = DEVICE(&s->gic[n]);
VirtIOGPUBase *g = vgpu->vgpu;
DeviceState *vdev = DEVICE(g);
int i;
- Error *local_error = NULL;
virtio_pci_force_virtio_1(vpci_dev);
- if (!qdev_realize(vdev, BUS(&vpci_dev->bus), &local_error)) {
- error_propagate(errp, local_error);
+ if (!qdev_realize(vdev, BUS(&vpci_dev->bus), errp)) {
return;
}
VirtIOVGABase *vvga = VIRTIO_VGA_BASE(vpci_dev);
VirtIOGPUBase *g = vvga->vgpu;
VGACommonState *vga = &vvga->vga;
- Error *err = NULL;
uint32_t offset;
int i;
/* init virtio bits */
virtio_pci_force_virtio_1(vpci_dev);
- if (!qdev_realize(DEVICE(g), BUS(&vpci_dev->bus), &err)) {
- error_propagate(errp, err);
+ if (!qdev_realize(DEVICE(g), BUS(&vpci_dev->bus), errp)) {
return;
}
static void aspeed_gpio_set_pin(Object *obj, Visitor *v, const char *name,
void *opaque, Error **errp)
{
- Error *local_err = NULL;
bool level;
int pin = 0xfff;
char group[4];
AspeedGPIOState *s = ASPEED_GPIO(obj);
int set_idx, group_idx = 0;
- if (!visit_type_bool(v, name, &level, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_bool(v, name, &level, errp)) {
return;
}
if (sscanf(name, "gpio%2[A-Z]%1d", group, &pin) != 2) {
Error **errp)
{
PCMachineState *pcms = PC_MACHINE(obj);
- Error *error = NULL;
uint64_t value;
- if (!visit_type_size(v, name, &value, &error)) {
- error_propagate(errp, error);
+ if (!visit_type_size(v, name, &value, errp)) {
return;
}
if (value > 4 * GiB) {
{
APICCommonState *s = APIC_COMMON(obj);
DeviceState *dev = DEVICE(obj);
- Error *local_err = NULL;
uint32_t value;
if (dev->realized) {
return;
}
- if (!visit_type_uint32(v, name, &value, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_uint32(v, name, &value, errp)) {
return;
}
static void armv7m_nvic_realize(DeviceState *dev, Error **errp)
{
NVICState *s = NVIC(dev);
- Error *err = NULL;
int regionlen;
/* The armv7m container object will have set our CPU pointer */
s->num_prio_bits = arm_feature(&s->cpu->env, ARM_FEATURE_V7) ? 8 : 2;
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->systick[M_REG_NS]), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->systick[M_REG_NS]), errp)) {
return;
}
sysbus_connect_irq(SYS_BUS_DEVICE(&s->systick[M_REG_NS]), 0,
object_initialize_child(OBJECT(dev), "systick-reg-s",
&s->systick[M_REG_S], TYPE_SYSTICK);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->systick[M_REG_S]), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->systick[M_REG_S]), errp)) {
return;
}
sysbus_connect_irq(SYS_BUS_DEVICE(&s->systick[M_REG_S]), 0,
object_property_set_int(OBJECT(xsrc), "nr-irqs", PNV_XIVE_NR_IRQS,
&error_fatal);
object_property_set_link(OBJECT(xsrc), "xive", OBJECT(xive), &error_abort);
- if (!qdev_realize(DEVICE(xsrc), NULL, &local_err)) {
- error_propagate(errp, local_err);
+ if (!qdev_realize(DEVICE(xsrc), NULL, errp)) {
return;
}
&error_fatal);
object_property_set_link(OBJECT(end_xsrc), "xive", OBJECT(xive),
&error_abort);
- if (!qdev_realize(DEVICE(end_xsrc), NULL, &local_err)) {
- error_propagate(errp, local_err);
+ if (!qdev_realize(DEVICE(end_xsrc), NULL, errp)) {
return;
}
SysBusDevice *sbd = SYS_BUS_DEVICE(dev);
RealViewGICState *s = REALVIEW_GIC(dev);
SysBusDevice *busdev;
- Error *err = NULL;
/* The GICs on the RealView boards have a fixed nonconfigurable
* number of interrupt lines, so we don't need to expose this as
* a qdev property.
int numirq = 96;
qdev_prop_set_uint32(DEVICE(&s->gic), "num-irq", numirq);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->gic), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->gic), errp)) {
return;
}
busdev = SYS_BUS_DEVICE(&s->gic);
object_property_set_int(OBJECT(xsrc), "nr-irqs", xive->nr_irqs,
&error_fatal);
object_property_set_link(OBJECT(xsrc), "xive", OBJECT(xive), &error_abort);
- if (!qdev_realize(DEVICE(xsrc), NULL, &local_err)) {
- error_propagate(errp, local_err);
+ if (!qdev_realize(DEVICE(xsrc), NULL, errp)) {
return;
}
sysbus_init_mmio(SYS_BUS_DEVICE(xive), &xsrc->esb_mmio);
&error_fatal);
object_property_set_link(OBJECT(end_xsrc), "xive", OBJECT(xive),
&error_abort);
- if (!qdev_realize(DEVICE(end_xsrc), NULL, &local_err)) {
- error_propagate(errp, local_err);
+ if (!qdev_realize(DEVICE(end_xsrc), NULL, errp)) {
return;
}
sysbus_init_mmio(SYS_BUS_DEVICE(xive), &end_xsrc->esb_mmio);
}
for (i = 0; i < ics->nr_irqs; i++) {
- Error *local_err = NULL;
int ret;
if (ics_irq_free(ics, i)) {
continue;
}
- ret = ics_set_kvm_state_one(ics, i, &local_err);
+ ret = ics_set_kvm_state_one(ics, i, errp);
if (ret < 0) {
- error_propagate(errp, local_err);
return ret;
}
}
PIIX4State *s = PIIX4_PCI_DEVICE(dev);
ISABus *isa_bus;
qemu_irq *i8259_out_irq;
- Error *err = NULL;
isa_bus = isa_bus_new(DEVICE(dev), pci_address_space(dev),
pci_address_space_io(dev), errp);
/* RTC */
qdev_prop_set_int32(DEVICE(&s->rtc), "base_year", 2000);
- if (!qdev_realize(DEVICE(&s->rtc), BUS(isa_bus), &err)) {
- error_propagate(errp, err);
+ if (!qdev_realize(DEVICE(&s->rtc), BUS(isa_bus), errp)) {
return;
}
isa_init_irq(ISA_DEVICE(&s->rtc), &s->rtc.irq, RTC_ISA_IRQ);
void *opaque, Error **errp)
{
NVDIMMDevice *nvdimm = NVDIMM(obj);
- Error *local_err = NULL;
uint64_t value;
if (nvdimm->nvdimm_mr) {
return;
}
- if (!visit_type_size(v, name, &value, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_size(v, name, &value, errp)) {
return;
}
if (value < MIN_NAMESPACE_LABEL_SIZE) {
static void xlnx_zynqmp_pmu_soc_realize(DeviceState *dev, Error **errp)
{
XlnxZynqMPPMUSoCState *s = XLNX_ZYNQMP_PMU_SOC(dev);
- Error *err = NULL;
object_property_set_uint(OBJECT(&s->cpu), "base-vectors",
XLNX_ZYNQMP_PMU_ROM_ADDR, &error_abort);
object_property_set_str(OBJECT(&s->cpu), "version", "8.40.b",
&error_abort);
object_property_set_uint(OBJECT(&s->cpu), "pvr", 0, &error_abort);
- if (!qdev_realize(DEVICE(&s->cpu), NULL, &err)) {
- error_propagate(errp, err);
+ if (!qdev_realize(DEVICE(&s->cpu), NULL, errp)) {
return;
}
&error_abort);
object_property_set_uint(OBJECT(&s->intc), "intc-positive", 0xffff,
&error_abort);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->intc), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->intc), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->intc), 0, XLNX_ZYNQMP_PMU_INTC_ADDR);
CPUMIPSState *env;
MIPSCPU *cpu;
int i;
- Error *err = NULL;
target_ulong gcr_base;
bool itu_present = false;
bool saar_present = false;
if (saar_present) {
s->itu.saar = &env->CP0_SAAR;
}
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->itu), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->itu), errp)) {
return;
}
&error_abort);
object_property_set_int(OBJECT(&s->cpc), "vp-start-running", 1,
&error_abort);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->cpc), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->cpc), errp)) {
return;
}
&error_abort);
object_property_set_int(OBJECT(&s->gic), "num-irq", 128,
&error_abort);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->gic), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->gic), errp)) {
return;
}
&error_abort);
object_property_set_link(OBJECT(&s->gcr), "cpc", OBJECT(&s->cpc.mr),
&error_abort);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->gcr), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->gcr), errp)) {
return;
}
int i;
char *sz;
int64_t value;
- Error *local_err = NULL;
AspeedSDMCState *s = ASPEED_SDMC(obj);
AspeedSDMCClass *asc = ASPEED_SDMC_GET_CLASS(s);
- if (!visit_type_int(v, name, &value, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_int(v, name, &value, errp)) {
return;
}
static void cuda_realize(DeviceState *dev, Error **errp)
{
CUDAState *s = CUDA(dev);
- Error *err = NULL;
SysBusDevice *sbd;
ADBBusState *adb_bus = &s->adb_bus;
struct tm tm;
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->mos6522_cuda), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->mos6522_cuda), errp)) {
return;
}
{
MacIOState *s = MACIO(d);
SysBusDevice *sysbus_dev;
- Error *err = NULL;
- if (!qdev_realize(DEVICE(&s->dbdma), BUS(&s->macio_bus), &err)) {
- error_propagate(errp, err);
+ if (!qdev_realize(DEVICE(&s->dbdma), BUS(&s->macio_bus), errp)) {
return;
}
sysbus_dev = SYS_BUS_DEVICE(&s->dbdma);
qdev_prop_set_chr(DEVICE(&s->escc), "chrB", serial_hd(1));
qdev_prop_set_uint32(DEVICE(&s->escc), "chnBtype", escc_serial);
qdev_prop_set_uint32(DEVICE(&s->escc), "chnAtype", escc_serial);
- if (!qdev_realize(DEVICE(&s->escc), BUS(&s->macio_bus), &err)) {
- error_propagate(errp, err);
+ if (!qdev_realize(DEVICE(&s->escc), BUS(&s->macio_bus), errp)) {
return;
}
qdev_prop_set_uint64(DEVICE(&s->cuda), "timebase-frequency",
s->frequency);
- if (!qdev_realize(DEVICE(&s->cuda), BUS(&s->macio_bus), &err)) {
- error_propagate(errp, err);
+ if (!qdev_realize(DEVICE(&s->cuda), BUS(&s->macio_bus), errp)) {
return;
}
sysbus_dev = SYS_BUS_DEVICE(&s->cuda);
sysbus_connect_irq(sysbus_dev, 1, qdev_get_gpio_in(pic_dev,
OLDWORLD_ESCCA_IRQ));
- if (!qdev_realize(DEVICE(&os->nvram), BUS(&s->macio_bus), &err)) {
- error_propagate(errp, err);
+ if (!qdev_realize(DEVICE(&os->nvram), BUS(&s->macio_bus), errp)) {
return;
}
sysbus_dev = SYS_BUS_DEVICE(&os->nvram);
object_property_set_link(OBJECT(&s->pmu), "gpio", OBJECT(sysbus_dev),
&error_abort);
qdev_prop_set_bit(DEVICE(&s->pmu), "has-adb", ns->has_adb);
- if (!qdev_realize(DEVICE(&s->pmu), BUS(&s->macio_bus), &err)) {
- error_propagate(errp, err);
+ if (!qdev_realize(DEVICE(&s->pmu), BUS(&s->macio_bus), errp)) {
return;
}
sysbus_dev = SYS_BUS_DEVICE(&s->pmu);
qdev_prop_set_uint64(DEVICE(&s->cuda), "timebase-frequency",
s->frequency);
- if (!qdev_realize(DEVICE(&s->cuda), BUS(&s->macio_bus), &err)) {
- error_propagate(errp, err);
+ if (!qdev_realize(DEVICE(&s->cuda), BUS(&s->macio_bus), errp)) {
return;
}
sysbus_dev = SYS_BUS_DEVICE(&s->cuda);
static void pmu_realize(DeviceState *dev, Error **errp)
{
PMUState *s = VIA_PMU(dev);
- Error *err = NULL;
SysBusDevice *sbd;
ADBBusState *adb_bus = &s->adb_bus;
struct tm tm;
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->mos6522_pmu), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->mos6522_pmu), errp)) {
return;
}
{
PCA955xClass *k = PCA955X_GET_CLASS(obj);
PCA955xState *s = PCA955X(obj);
- Error *local_err = NULL;
int led, rc, reg, val;
uint8_t state;
char *state_str;
- if (!visit_type_str(v, name, &state_str, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_str(v, name, &state_str, errp)) {
return;
}
rc = sscanf(name, "led%2d", &led);
void *opaque, Error **errp)
{
TMP105State *s = TMP105(obj);
- Error *local_err = NULL;
int64_t temp;
- if (!visit_type_int(v, name, &temp, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_int(v, name, &temp, errp)) {
return;
}
if (temp >= 128000 || temp < -128000) {
void *opaque, Error **errp)
{
TMP421State *s = TMP421(obj);
- Error *local_err = NULL;
int64_t temp;
bool ext_range = (s->config[0] & TMP421_CONFIG_RANGE);
int offset = ext_range * 64 * 256;
int tempid;
- if (!visit_type_int(v, name, &temp, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_int(v, name, &temp, errp)) {
return;
}
PnvPHB3 *phb = PNV_PHB3(dev);
PCIHostState *pci = PCI_HOST_BRIDGE(dev);
PnvMachineState *pnv = PNV_MACHINE(qdev_get_machine());
- Error *local_err = NULL;
int i;
if (phb->phb_id >= PNV8_CHIP_PHB3_MAX) {
&error_abort);
object_property_set_int(OBJECT(&phb->lsis), "nr-irqs", PNV_PHB3_NUM_LSI,
&error_abort);
- if (!qdev_realize(DEVICE(&phb->lsis), NULL, &local_err)) {
- error_propagate(errp, local_err);
+ if (!qdev_realize(DEVICE(&phb->lsis), NULL, errp)) {
return;
}
&error_abort);
object_property_set_int(OBJECT(&phb->msis), "nr-irqs", PHB3_MAX_MSI,
&error_abort);
- if (!qdev_realize(DEVICE(&phb->msis), NULL, &local_err)) {
- error_propagate(errp, local_err);
+ if (!qdev_realize(DEVICE(&phb->msis), NULL, errp)) {
return;
}
/* Power Bus Common Queue */
object_property_set_link(OBJECT(&phb->pbcq), "phb", OBJECT(phb),
&error_abort);
- if (!qdev_realize(DEVICE(&phb->pbcq), NULL, &local_err)) {
- error_propagate(errp, local_err);
+ if (!qdev_realize(DEVICE(&phb->pbcq), NULL, errp)) {
return;
}
PnvPHB4 *phb = PNV_PHB4(dev);
PCIHostState *pci = PCI_HOST_BRIDGE(dev);
XiveSource *xsrc = &phb->xsrc;
- Error *local_err = NULL;
int nr_irqs;
char name[32];
}
object_property_set_int(OBJECT(xsrc), "nr-irqs", nr_irqs, &error_fatal);
object_property_set_link(OBJECT(xsrc), "xive", OBJECT(phb), &error_fatal);
- if (!qdev_realize(DEVICE(xsrc), NULL, &local_err)) {
- error_propagate(errp, local_err);
+ if (!qdev_realize(DEVICE(xsrc), NULL, errp)) {
return;
}
static void pnv_pec_realize(DeviceState *dev, Error **errp)
{
PnvPhb4PecState *pec = PNV_PHB4_PEC(dev);
- Error *local_err = NULL;
char name[64];
int i;
object_property_set_int(stk_obj, "stack-no", i, &error_abort);
object_property_set_link(stk_obj, "pec", OBJECT(pec), &error_abort);
- if (!qdev_realize(DEVICE(stk_obj), NULL, &local_err)) {
- error_propagate(errp, local_err);
+ if (!qdev_realize(DEVICE(stk_obj), NULL, errp)) {
return;
}
}
static DeviceState *ppce500_init_mpic_kvm(const PPCE500MachineClass *pmc,
IrqLines *irqs, Error **errp)
{
- Error *err = NULL;
DeviceState *dev;
CPUState *cs;
dev = qdev_new(TYPE_KVM_OPENPIC);
qdev_prop_set_uint32(dev, "model", pmc->mpic_version);
- if (!sysbus_realize_and_unref(SYS_BUS_DEVICE(dev), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize_and_unref(SYS_BUS_DEVICE(dev), errp)) {
object_unparent(OBJECT(dev));
return NULL;
}
&error_fatal);
object_property_set_link(OBJECT(&chip8->psi), ICS_PROP_XICS,
OBJECT(chip8->xics), &error_abort);
- if (!qdev_realize(DEVICE(&chip8->psi), NULL, &local_err)) {
- error_propagate(errp, local_err);
+ if (!qdev_realize(DEVICE(&chip8->psi), NULL, errp)) {
return;
}
pnv_xscom_add_subregion(chip, PNV_XSCOM_PSIHB_BASE,
/* Create the simplified OCC model */
object_property_set_link(OBJECT(&chip8->occ), "psi", OBJECT(&chip8->psi),
&error_abort);
- if (!qdev_realize(DEVICE(&chip8->occ), NULL, &local_err)) {
- error_propagate(errp, local_err);
+ if (!qdev_realize(DEVICE(&chip8->occ), NULL, errp)) {
return;
}
pnv_xscom_add_subregion(chip, PNV_XSCOM_OCC_BASE, &chip8->occ.xscom_regs);
/* HOMER */
object_property_set_link(OBJECT(&chip8->homer), "chip", OBJECT(chip),
&error_abort);
- if (!qdev_realize(DEVICE(&chip8->homer), NULL, &local_err)) {
- error_propagate(errp, local_err);
+ if (!qdev_realize(DEVICE(&chip8->homer), NULL, errp)) {
return;
}
/* Homer Xscom region */
object_property_set_int(OBJECT(phb), "index", i, &error_fatal);
object_property_set_int(OBJECT(phb), "chip-id", chip->chip_id,
&error_fatal);
- if (!sysbus_realize(SYS_BUS_DEVICE(phb), &local_err)) {
- error_propagate(errp, local_err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(phb), errp)) {
return;
}
static void pnv_chip_power9_phb_realize(PnvChip *chip, Error **errp)
{
Pnv9Chip *chip9 = PNV9_CHIP(chip);
- Error *local_err = NULL;
int i, j;
int phb_id = 0;
&error_fatal);
object_property_set_link(OBJECT(pec), "system-memory",
OBJECT(get_system_memory()), &error_abort);
- if (!qdev_realize(DEVICE(pec), NULL, &local_err)) {
- error_propagate(errp, local_err);
+ if (!qdev_realize(DEVICE(pec), NULL, errp)) {
return;
}
&error_fatal);
object_property_set_link(obj, "stack", OBJECT(stack),
&error_abort);
- if (!sysbus_realize(SYS_BUS_DEVICE(obj), &local_err)) {
- error_propagate(errp, local_err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(obj), errp)) {
return;
}
PNV9_XIVE_TM_BASE(chip), &error_fatal);
object_property_set_link(OBJECT(&chip9->xive), "chip", OBJECT(chip),
&error_abort);
- if (!sysbus_realize(SYS_BUS_DEVICE(&chip9->xive), &local_err)) {
- error_propagate(errp, local_err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&chip9->xive), errp)) {
return;
}
pnv_xscom_add_subregion(chip, PNV9_XSCOM_XIVE_BASE,
/* Processor Service Interface (PSI) Host Bridge */
object_property_set_int(OBJECT(&chip9->psi), "bar", PNV9_PSIHB_BASE(chip),
&error_fatal);
- if (!qdev_realize(DEVICE(&chip9->psi), NULL, &local_err)) {
- error_propagate(errp, local_err);
+ if (!qdev_realize(DEVICE(&chip9->psi), NULL, errp)) {
return;
}
pnv_xscom_add_subregion(chip, PNV9_XSCOM_PSIHB_BASE,
/* LPC */
object_property_set_link(OBJECT(&chip9->lpc), "psi", OBJECT(&chip9->psi),
&error_abort);
- if (!qdev_realize(DEVICE(&chip9->lpc), NULL, &local_err)) {
- error_propagate(errp, local_err);
+ if (!qdev_realize(DEVICE(&chip9->lpc), NULL, errp)) {
return;
}
memory_region_add_subregion(get_system_memory(), PNV9_LPCM_BASE(chip),
/* Create the simplified OCC model */
object_property_set_link(OBJECT(&chip9->occ), "psi", OBJECT(&chip9->psi),
&error_abort);
- if (!qdev_realize(DEVICE(&chip9->occ), NULL, &local_err)) {
- error_propagate(errp, local_err);
+ if (!qdev_realize(DEVICE(&chip9->occ), NULL, errp)) {
return;
}
pnv_xscom_add_subregion(chip, PNV9_XSCOM_OCC_BASE, &chip9->occ.xscom_regs);
/* HOMER */
object_property_set_link(OBJECT(&chip9->homer), "chip", OBJECT(chip),
&error_abort);
- if (!qdev_realize(DEVICE(&chip9->homer), NULL, &local_err)) {
- error_propagate(errp, local_err);
+ if (!qdev_realize(DEVICE(&chip9->homer), NULL, errp)) {
return;
}
/* Homer Xscom region */
/* Processor Service Interface (PSI) Host Bridge */
object_property_set_int(OBJECT(&chip10->psi), "bar",
PNV10_PSIHB_BASE(chip), &error_fatal);
- if (!qdev_realize(DEVICE(&chip10->psi), NULL, &local_err)) {
- error_propagate(errp, local_err);
+ if (!qdev_realize(DEVICE(&chip10->psi), NULL, errp)) {
return;
}
pnv_xscom_add_subregion(chip, PNV10_XSCOM_PSIHB_BASE,
/* LPC */
object_property_set_link(OBJECT(&chip10->lpc), "psi",
OBJECT(&chip10->psi), &error_abort);
- if (!qdev_realize(DEVICE(&chip10->lpc), NULL, &local_err)) {
- error_propagate(errp, local_err);
+ if (!qdev_realize(DEVICE(&chip10->lpc), NULL, errp)) {
return;
}
memory_region_add_subregion(get_system_memory(), PNV10_LPCM_BASE(chip),
Error *local_err = NULL;
PnvChipClass *pcc = PNV_CHIP_GET_CLASS(pc->chip);
- if (!qdev_realize(DEVICE(cpu), NULL, &local_err)) {
- error_propagate(errp, local_err);
+ if (!qdev_realize(DEVICE(cpu), NULL, errp)) {
return;
}
{
PnvPsi *psi = PNV_PSI(dev);
ICSState *ics = &PNV8_PSI(psi)->ics;
- Error *err = NULL;
unsigned int i;
/* Create PSI interrupt control source */
if (!object_property_set_int(OBJECT(ics), "nr-irqs", PSI_NUM_INTERRUPTS,
- &err)) {
- error_propagate(errp, err);
+ errp)) {
return;
}
- if (!qdev_realize(DEVICE(ics), NULL, &err)) {
- error_propagate(errp, err);
+ if (!qdev_realize(DEVICE(ics), NULL, errp)) {
return;
}
{
PnvPsi *psi = PNV_PSI(dev);
XiveSource *xsrc = &PNV9_PSI(psi)->source;
- Error *local_err = NULL;
int i;
/* This is the only device with 4k ESB pages */
object_property_set_int(OBJECT(xsrc), "nr-irqs", PSIHB9_NUM_IRQS,
&error_fatal);
object_property_set_link(OBJECT(xsrc), "xive", OBJECT(psi), &error_abort);
- if (!qdev_realize(DEVICE(xsrc), NULL, &local_err)) {
- error_propagate(errp, local_err);
+ if (!qdev_realize(DEVICE(xsrc), NULL, errp)) {
return;
}
SpaprCapabilityInfo *cap = opaque;
SpaprMachineState *spapr = SPAPR_MACHINE(obj);
bool value;
- Error *local_err = NULL;
- if (!visit_type_bool(v, name, &value, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_bool(v, name, &value, errp)) {
return;
}
{
SpaprCapabilityInfo *cap = opaque;
SpaprMachineState *spapr = SPAPR_MACHINE(obj);
- Error *local_err = NULL;
uint8_t i;
char *val;
- if (!visit_type_str(v, name, &val, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_str(v, name, &val, errp)) {
return;
}
SpaprMachineState *spapr = SPAPR_MACHINE(obj);
uint64_t pagesize;
uint8_t val;
- Error *local_err = NULL;
- if (!visit_type_size(v, name, &pagesize, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_size(v, name, &pagesize, errp)) {
return;
}
case FDT_BEGIN_NODE:
fdt_depth++;
name = fdt_get_name(fdt, fdt_offset, &name_len);
- if (!visit_start_struct(v, name, NULL, 0, &err)) {
- error_propagate(errp, err);
+ if (!visit_start_struct(v, name, NULL, 0, errp)) {
return;
}
break;
int i;
prop = fdt_get_property_by_offset(fdt, fdt_offset, &prop_len);
name = fdt_string(fdt, fdt32_to_cpu(prop->nameoff));
- if (!visit_start_list(v, name, NULL, 0, &err)) {
- error_propagate(errp, err);
+ if (!visit_start_list(v, name, NULL, 0, errp)) {
return;
}
for (i = 0; i < prop_len; i++) {
if (!visit_type_uint8(v, NULL, (uint8_t *)&prop->data[i],
- &err)) {
- error_propagate(errp, err);
+ errp)) {
return;
}
}
spapr_irq_msi_init(spapr);
if (spapr->irq->xics) {
- Error *local_err = NULL;
Object *obj;
obj = object_new(TYPE_ICS_SPAPR);
object_property_set_link(obj, ICS_PROP_XICS, OBJECT(spapr),
&error_abort);
object_property_set_int(obj, "nr-irqs", smc->nr_xirqs, &error_abort);
- if (!qdev_realize(DEVICE(obj), NULL, &local_err)) {
- error_propagate(errp, local_err);
+ if (!qdev_realize(DEVICE(obj), NULL, errp)) {
return;
}
MachineState *ms = MACHINE(qdev_get_machine());
LowRISCIbexSoCState *s = RISCV_IBEX_SOC(dev_soc);
MemoryRegion *sys_mem = get_system_memory();
- Error *err = NULL;
object_property_set_str(OBJECT(&s->cpus), "cpu-type", ms->cpu_type,
&error_abort);
&s->flash_mem);
/* PLIC */
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->plic), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->plic), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->plic), 0, memmap[IBEX_PLIC].base);
/* UART */
qdev_prop_set_chr(DEVICE(&(s->uart)), "chardev", serial_hd(0));
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->uart), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->uart), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->uart), 0, memmap[IBEX_UART].base);
{
MachineState *ms = MACHINE(qdev_get_machine());
const struct MemmapEntry *memmap = sifive_e_memmap;
- Error *err = NULL;
-
SiFiveESoCState *s = RISCV_E_SOC(dev);
MemoryRegion *sys_mem = get_system_memory();
/* GPIO */
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->gpio), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->gpio), errp)) {
return;
}
char *plic_hart_config;
size_t plic_hart_config_len;
int i;
- Error *err = NULL;
NICInfo *nd = &nd_table[0];
sysbus_realize(SYS_BUS_DEVICE(&s->e_cpus), &error_abort);
}
object_property_set_int(OBJECT(&s->gem), "revision", GEM_REVISION,
&error_abort);
- if (!sysbus_realize(SYS_BUS_DEVICE(&s->gem), &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(SYS_BUS_DEVICE(&s->gem), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->gem), 0, memmap[SIFIVE_U_GEM].base);
DeviceState *dev = DEVICE(obj);
Property *prop = opaque;
CssDevId *dev_id = qdev_get_prop_ptr(dev, prop);
- Error *local_err = NULL;
char *str;
int num, n1, n2;
unsigned int cssid, ssid, devid;
return;
}
- if (!visit_type_str(v, name, &str, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_str(v, name, &str, errp)) {
return;
}
static void realize_event_facility(DeviceState *dev, Error **errp)
{
SCLPEventFacility *event_facility = EVENT_FACILITY(dev);
- Error *local_err = NULL;
if (!qdev_realize(DEVICE(&event_facility->quiesce),
- BUS(&event_facility->sbus), &local_err)) {
- error_propagate(errp, local_err);
+ BUS(&event_facility->sbus), errp)) {
return;
}
if (!qdev_realize(DEVICE(&event_facility->cpu_hotplug),
- BUS(&event_facility->sbus), &local_err)) {
- error_propagate(errp, local_err);
+ BUS(&event_facility->sbus), errp)) {
qdev_unrealize(DEVICE(&event_facility->quiesce));
return;
}
{
VirtIOCryptoCcw *dev = VIRTIO_CRYPTO_CCW(ccw_dev);
DeviceState *vdev = DEVICE(&dev->vdev);
- Error *err = NULL;
- if (!qdev_realize(vdev, BUS(&ccw_dev->bus), &err)) {
- error_propagate(errp, err);
+ if (!qdev_realize(vdev, BUS(&ccw_dev->bus), errp)) {
return;
}
{
VirtIORNGCcw *dev = VIRTIO_RNG_CCW(ccw_dev);
DeviceState *vdev = DEVICE(&dev->vdev);
- Error *err = NULL;
- if (!qdev_realize(vdev, BUS(&ccw_dev->bus), &err)) {
- error_propagate(errp, err);
+ if (!qdev_realize(vdev, BUS(&ccw_dev->bus), errp)) {
return;
}
const char *driver;
char *name;
DeviceState *dev;
- Error *err = NULL;
DriveInfo *dinfo;
if (blk_is_sg(blk)) {
if (serial && object_property_find(OBJECT(dev), "serial", NULL)) {
qdev_prop_set_string(dev, "serial", serial);
}
- if (!qdev_prop_set_drive_err(dev, "drive", blk, &err)) {
- error_propagate(errp, err);
+ if (!qdev_prop_set_drive_err(dev, "drive", blk, errp)) {
object_unparent(OBJECT(dev));
return NULL;
}
- if (!object_property_set_bool(OBJECT(dev), "share-rw", share_rw, &err)) {
- error_propagate(errp, err);
+ if (!object_property_set_bool(OBJECT(dev), "share-rw", share_rw, errp)) {
object_unparent(OBJECT(dev));
return NULL;
}
qdev_prop_set_enum(dev, "rerror", rerror);
qdev_prop_set_enum(dev, "werror", werror);
- if (!qdev_realize_and_unref(dev, &bus->qbus, &err)) {
- error_propagate(errp, err);
+ if (!qdev_realize_and_unref(dev, &bus->qbus, errp)) {
object_unparent(OBJECT(dev));
return NULL;
}
static void aspeed_sdhci_realize(DeviceState *dev, Error **errp)
{
- Error *err = NULL;
SysBusDevice *sbd = SYS_BUS_DEVICE(dev);
AspeedSDHCIState *sdhci = ASPEED_SDHCI(dev);
Object *sdhci_slot = OBJECT(&sdhci->slots[i]);
SysBusDevice *sbd_slot = SYS_BUS_DEVICE(&sdhci->slots[i]);
- if (!object_property_set_int(sdhci_slot, "sd-spec-version", 2, &err)) {
- error_propagate(errp, err);
+ if (!object_property_set_int(sdhci_slot, "sd-spec-version", 2, errp)) {
return;
}
if (!object_property_set_uint(sdhci_slot, "capareg",
- ASPEED_SDHCI_CAPABILITIES, &err)) {
- error_propagate(errp, err);
+ ASPEED_SDHCI_CAPABILITIES, errp)) {
return;
}
- if (!sysbus_realize(sbd_slot, &err)) {
- error_propagate(errp, err);
+ if (!sysbus_realize(sbd_slot, errp)) {
return;
}
void smbios_entry_add(QemuOpts *opts, Error **errp)
{
- Error *err = NULL;
const char *val;
assert(!smbios_immutable);
int size;
struct smbios_table *table; /* legacy mode only */
- if (!qemu_opts_validate(opts, qemu_smbios_file_opts, &err)) {
- error_propagate(errp, err);
+ if (!qemu_opts_validate(opts, qemu_smbios_file_opts, errp)) {
return;
}
switch (type) {
case 0:
- if (!qemu_opts_validate(opts, qemu_smbios_type0_opts, &err)) {
- error_propagate(errp, err);
+ if (!qemu_opts_validate(opts, qemu_smbios_type0_opts, errp)) {
return;
}
save_opt(&type0.vendor, opts, "vendor");
}
return;
case 1:
- if (!qemu_opts_validate(opts, qemu_smbios_type1_opts, &err)) {
- error_propagate(errp, err);
+ if (!qemu_opts_validate(opts, qemu_smbios_type1_opts, errp)) {
return;
}
save_opt(&type1.manufacturer, opts, "manufacturer");
}
return;
case 2:
- if (!qemu_opts_validate(opts, qemu_smbios_type2_opts, &err)) {
- error_propagate(errp, err);
+ if (!qemu_opts_validate(opts, qemu_smbios_type2_opts, errp)) {
return;
}
save_opt(&type2.manufacturer, opts, "manufacturer");
save_opt(&type2.location, opts, "location");
return;
case 3:
- if (!qemu_opts_validate(opts, qemu_smbios_type3_opts, &err)) {
- error_propagate(errp, err);
+ if (!qemu_opts_validate(opts, qemu_smbios_type3_opts, errp)) {
return;
}
save_opt(&type3.manufacturer, opts, "manufacturer");
save_opt(&type3.sku, opts, "sku");
return;
case 4:
- if (!qemu_opts_validate(opts, qemu_smbios_type4_opts, &err)) {
- error_propagate(errp, err);
+ if (!qemu_opts_validate(opts, qemu_smbios_type4_opts, errp)) {
return;
}
save_opt(&type4.sock_pfx, opts, "sock_pfx");
save_opt(&type4.part, opts, "part");
return;
case 11:
- if (!qemu_opts_validate(opts, qemu_smbios_type11_opts, &err)) {
- error_propagate(errp, err);
+ if (!qemu_opts_validate(opts, qemu_smbios_type11_opts, errp)) {
return;
}
save_opt_list(&type11.nvalues, &type11.values, opts, "value");
return;
case 17:
- if (!qemu_opts_validate(opts, qemu_smbios_type17_opts, &err)) {
- error_propagate(errp, err);
+ if (!qemu_opts_validate(opts, qemu_smbios_type17_opts, errp)) {
return;
}
save_opt(&type17.loc_pfx, opts, "loc_pfx");
DeviceState *dev = DEVICE(obj);
Property *prop = opaque;
uint8_t value, *ptr = qdev_get_prop_ptr(dev, prop);
- Error *local_err = NULL;
if (dev->realized) {
qdev_prop_set_after_realize(dev, name, errp);
return;
}
- if (!visit_type_uint8(v, name, &value, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_uint8(v, name, &value, errp)) {
return;
}
{
#ifdef CONFIG_KVM
int irq_fd = event_notifier_get_fd(&vdev->intx.interrupt);
- Error *err = NULL;
if (vdev->no_kvm_intx || !kvm_irqfds_enabled() ||
vdev->intx.route.mode != PCI_INTX_ENABLED ||
if (vfio_set_irq_signaling(&vdev->vbasedev, VFIO_PCI_INTX_IRQ_INDEX, 0,
VFIO_IRQ_SET_ACTION_UNMASK,
event_notifier_get_fd(&vdev->intx.unmask),
- &err)) {
- error_propagate(errp, err);
+ errp)) {
goto fail_vfio;
}
if (!pdev->failover_pair_id) {
error_setg(&vdev->migration_blocker,
"VFIO device doesn't support migration");
- ret = migrate_add_blocker(vdev->migration_blocker, &err);
+ ret = migrate_add_blocker(vdev->migration_blocker, errp);
if (ret) {
- error_propagate(errp, err);
error_free(vdev->migration_blocker);
vdev->migration_blocker = NULL;
return;
Error **errp)
{
VirtIOBalloon *s = opaque;
- Error *local_err = NULL;
int64_t value;
- if (!visit_type_int(v, name, &value, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_int(v, name, &value, errp)) {
return;
}
{
VirtIORngPCI *vrng = VIRTIO_RNG_PCI(vpci_dev);
DeviceState *vdev = DEVICE(&vrng->vdev);
- Error *err = NULL;
- if (!qdev_realize(vdev, BUS(&vpci_dev->bus), &err)) {
- error_propagate(errp, err);
+ if (!qdev_realize(vdev, BUS(&vpci_dev->bus), errp)) {
return;
}
{
VirtIODevice *vdev = VIRTIO_DEVICE(dev);
VirtIORNG *vrng = VIRTIO_RNG(dev);
- Error *local_err = NULL;
if (vrng->conf.period_ms <= 0) {
error_setg(errp, "'period' parameter expects a positive integer");
Object *default_backend = object_new(TYPE_RNG_BUILTIN);
if (!user_creatable_complete(USER_CREATABLE(default_backend),
- &local_err)) {
- error_propagate(errp, local_err);
+ errp)) {
object_unref(default_backend);
return;
}
iothread->stopping = false;
iothread->running = true;
- iothread->ctx = aio_context_new(&local_error);
+ iothread->ctx = aio_context_new(errp);
if (!iothread->ctx) {
- error_propagate(errp, local_error);
return;
}
IOThread *iothread = IOTHREAD(obj);
PollParamInfo *info = opaque;
int64_t *field = (void *)iothread + info->offset;
- Error *local_err = NULL;
int64_t value;
- if (!visit_type_int64(v, name, &value, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_int64(v, name, &value, errp)) {
return;
}
Error **errp)
{
CompareState *s = COLO_COMPARE(obj);
- Error *local_err = NULL;
uint32_t value;
- if (!visit_type_uint32(v, name, &value, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_uint32(v, name, &value, errp)) {
return;
}
if (!value) {
Error **errp)
{
CompareState *s = COLO_COMPARE(obj);
- Error *local_err = NULL;
uint32_t value;
- if (!visit_type_uint32(v, name, &value, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_uint32(v, name, &value, errp)) {
return;
}
if (!value) {
void *opaque, Error **errp)
{
NetFilterDumpState *nfds = FILTER_DUMP(obj);
- Error *local_err = NULL;
uint32_t value;
- if (!visit_type_uint32(v, name, &value, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_uint32(v, name, &value, errp)) {
return;
}
if (value == 0) {
Error **errp)
{
FilterBufferState *s = FILTER_BUFFER(obj);
- Error *local_err = NULL;
uint32_t value;
- if (!visit_type_uint32(v, name, &value, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_uint32(v, name, &value, errp)) {
return;
}
if (!value) {
return -1;
}
- fd = monitor_fd_param(cur_mon, tap->fd, &err);
+ fd = monitor_fd_param(cur_mon, tap->fd, errp);
if (fd == -1) {
- error_propagate(errp, err);
return -1;
}
Error **errp)
{
StringInputVisitor *siv = to_siv(v);
- Error *err = NULL;
uint64_t val;
assert(siv->lm == LM_NONE);
- if (!parse_option_size(name, siv->string, &val, &err)) {
- error_propagate(errp, err);
+ if (!parse_option_size(name, siv->string, &val, errp)) {
return false;
}
Error **errp)
{
Object *obj = opaque;
- Error *err = NULL;
if (strcmp(name, "driver") == 0)
return 0;
if (strcmp(name, "bus") == 0)
return 0;
- if (!object_property_parse(obj, name, value, &err)) {
- error_propagate(errp, err);
+ if (!object_property_parse(obj, name, value, errp)) {
return -1;
}
return 0;
void qmp_device_add(QDict *qdict, QObject **ret_data, Error **errp)
{
- Error *local_err = NULL;
QemuOpts *opts;
DeviceState *dev;
qemu_opts_del(opts);
return;
}
- dev = qdev_device_add(opts, &local_err);
+ dev = qdev_device_add(opts, errp);
if (!dev) {
- error_propagate(errp, local_err);
qemu_opts_del(opts);
return;
}
}
server = os_version.wProductType != VER_NT_WORKSTATION;
- product_name = ga_get_win_product_name(&local_err);
+ product_name = ga_get_win_product_name(errp);
if (product_name == NULL) {
- error_propagate(errp, local_err);
return NULL;
}
va_list vargs)
{
const char *propname;
- Error *local_err = NULL;
propname = va_arg(vargs, char *);
while (propname != NULL) {
const char *value = va_arg(vargs, char *);
g_assert(value != NULL);
- if (!object_property_parse(obj, propname, value, &local_err)) {
- error_propagate(errp, local_err);
+ if (!object_property_parse(obj, propname, value, errp)) {
return false;
}
propname = va_arg(vargs, char *);
{
StringProperty *prop = opaque;
char *value;
- Error *local_err = NULL;
- if (!visit_type_str(v, name, &value, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_str(v, name, &value, errp)) {
return;
}
{
BoolProperty *prop = opaque;
bool value;
- Error *local_err = NULL;
- if (!visit_type_bool(v, name, &value, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_bool(v, name, &value, errp)) {
return;
}
{
EnumProperty *prop = opaque;
int value;
- Error *err = NULL;
- if (!visit_type_enum(v, name, &value, prop->lookup, &err)) {
- error_propagate(errp, err);
+ if (!visit_type_enum(v, name, &value, prop->lookup, errp)) {
return;
}
prop->set(obj, value, errp);
{
uint8_t *field = opaque;
uint8_t value;
- Error *local_err = NULL;
- if (!visit_type_uint8(v, name, &value, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_uint8(v, name, &value, errp)) {
return;
}
{
uint16_t *field = opaque;
uint16_t value;
- Error *local_err = NULL;
- if (!visit_type_uint16(v, name, &value, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_uint16(v, name, &value, errp)) {
return;
}
{
uint32_t *field = opaque;
uint32_t value;
- Error *local_err = NULL;
- if (!visit_type_uint32(v, name, &value, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_uint32(v, name, &value, errp)) {
return;
}
{
uint64_t *field = opaque;
uint64_t value;
- Error *local_err = NULL;
- if (!visit_type_uint64(v, name, &value, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_uint64(v, name, &value, errp)) {
return;
}
const char *name, const char *value,
const char *skip, Error **errp)
{
- Error *local_err = NULL;
-
if (g_str_equal(name, skip)) {
return 0;
}
- if (!object_property_parse(obj, name, value, &local_err)) {
- error_propagate(errp, local_err);
+ if (!object_property_parse(obj, name, value, errp)) {
return -1;
}
void *opaque, Error **errp)
{
ARMCPU *cpu = ARM_CPU(obj);
- Error *err = NULL;
uint32_t max_vq;
- if (!visit_type_uint32(v, name, &max_vq, &err)) {
- error_propagate(errp, err);
+ if (!visit_type_uint32(v, name, &max_vq, errp)) {
return;
}
{
ARMCPU *cpu = ARM_CPU(obj);
uint32_t vq = atoi(&name[3]) / 128;
- Error *err = NULL;
bool value;
- if (!visit_type_bool(v, name, &value, &err)) {
- error_propagate(errp, err);
+ if (!visit_type_bool(v, name, &value, errp)) {
return;
}
void *opaque, Error **errp)
{
ARMCPU *cpu = ARM_CPU(obj);
- Error *err = NULL;
bool value;
uint64_t t;
- if (!visit_type_bool(v, name, &value, &err)) {
- error_propagate(errp, err);
+ if (!visit_type_bool(v, name, &value, errp)) {
return;
}
Error *err = NULL;
visitor = qobject_input_visitor_new(model->props);
- if (!visit_start_struct(visitor, NULL, NULL, 0, &err)) {
+ if (!visit_start_struct(visitor, NULL, NULL, 0, errp)) {
visit_free(visitor);
object_unref(obj);
- error_propagate(errp, err);
return NULL;
}
CPUX86State *env = &cpu->env;
const int64_t min = 0;
const int64_t max = 0xff + 0xf;
- Error *local_err = NULL;
int64_t value;
- if (!visit_type_int(v, name, &value, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_int(v, name, &value, errp)) {
return;
}
if (value < min || value > max) {
CPUX86State *env = &cpu->env;
const int64_t min = 0;
const int64_t max = 0xff;
- Error *local_err = NULL;
int64_t value;
- if (!visit_type_int(v, name, &value, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_int(v, name, &value, errp)) {
return;
}
if (value < min || value > max) {
CPUX86State *env = &cpu->env;
const int64_t min = 0;
const int64_t max = 0xf;
- Error *local_err = NULL;
int64_t value;
- if (!visit_type_int(v, name, &value, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_int(v, name, &value, errp)) {
return;
}
if (value < min || value > max) {
X86CPU *cpu = X86_CPU(obj);
const int64_t min = 0;
const int64_t max = INT64_MAX;
- Error *local_err = NULL;
int64_t value;
- if (!visit_type_int(v, name, &value, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_int(v, name, &value, errp)) {
return;
}
if (value < min || value > max) {
DeviceState *dev = DEVICE(obj);
X86CPU *cpu = X86_CPU(obj);
BitProperty *fp = opaque;
- Error *local_err = NULL;
bool value;
if (dev->realized) {
return;
}
- if (!visit_type_bool(v, name, &value, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_bool(v, name, &value, errp)) {
return;
}
static void ppc_compat_prop_set(Object *obj, Visitor *v, const char *name,
void *opaque, Error **errp)
{
- Error *local_err = NULL;
char *value;
uint32_t compat_pvr;
- if (!visit_type_str(v, name, &value, &local_err)) {
- error_propagate(errp, local_err);
+ if (!visit_type_str(v, name, &value, errp)) {
return;
}
if (qdict) {
visitor = qobject_input_visitor_new(info->props);
- if (!visit_start_struct(visitor, NULL, NULL, 0, &err)) {
- error_propagate(errp, err);
+ if (!visit_start_struct(visitor, NULL, NULL, 0, errp)) {
visit_free(visitor);
object_unref(obj);
return;
static void set_feature(Object *obj, Visitor *v, const char *name,
void *opaque, Error **errp)
{
- Error *err = NULL;
S390Feat feat = (S390Feat) opaque;
DeviceState *dev = DEVICE(obj);
S390CPU *cpu = S390_CPU(obj);
return;
}
- if (!visit_type_bool(v, name, &value, &err)) {
- error_propagate(errp, err);
+ if (!visit_type_bool(v, name, &value, errp)) {
return;
}
if (value) {
static void set_feature_group(Object *obj, Visitor *v, const char *name,
void *opaque, Error **errp)
{
- Error *err = NULL;
S390FeatGroup group = (S390FeatGroup) opaque;
const S390FeatGroupDef *def = s390_feat_group_def(group);
DeviceState *dev = DEVICE(obj);
return;
}
- if (!visit_type_bool(v, name, &value, &err)) {
- error_propagate(errp, err);
+ if (!visit_type_bool(v, name, &value, errp)) {
return;
}
if (value) {
const int64_t min = MIN_NWINDOWS;
const int64_t max = MAX_NWINDOWS;
SPARCCPU *cpu = SPARC_CPU(obj);
- Error *err = NULL;
int64_t value;
- if (!visit_type_int(v, name, &value, &err)) {
- error_propagate(errp, err);
+ if (!visit_type_int(v, name, &value, errp)) {
return;
}
const char *id;
const TPMBackendClass *be;
TPMBackend *drv;
- Error *local_err = NULL;
int i;
if (!QLIST_EMPTY(&tpm_backends)) {
}
/* validate backend specific opts */
- if (!qemu_opts_validate(opts, be->opts, &local_err)) {
- error_propagate(errp, local_err);
+ if (!qemu_opts_validate(opts, be->opts, errp)) {
return 1;
}
{
int ret;
GSource *src;
- Error *local_error = NULL;
init_clocks(qemu_timer_notify_cb);
return ret;
}
- qemu_aio_context = aio_context_new(&local_error);
+ qemu_aio_context = aio_context_new(errp);
if (!qemu_aio_context) {
- error_propagate(errp, local_error);
return -EMFILE;
}
qemu_notify_bh = qemu_bh_new(notify_event_cb, NULL);
QemuOpts *subopts;
QDict *subqdict;
QList *list = NULL;
- Error *local_err = NULL;
size_t orig_size, enum_size;
char *prefix;
goto out;
}
- if (!qemu_opts_absorb_qdict(subopts, subqdict, &local_err)) {
- error_propagate(errp, local_err);
+ if (!qemu_opts_absorb_qdict(subopts, subqdict, errp)) {
goto out;
}
goto out;
}
- if (!qemu_opts_absorb_qdict(subopts, section, &local_err)) {
- error_propagate(errp, local_err);
+ if (!qemu_opts_absorb_qdict(subopts, section, errp)) {
qemu_opts_del(subopts);
goto out;
}
Error **errp)
{
const QemuOptDesc *desc;
- Error *local_err = NULL;
desc = find_desc_by_name(opt->opts->list->desc, opt->name);
if (!desc && !opts_accepts_any(opt->opts)) {
}
opt->desc = desc;
- if (!qemu_opt_parse(opt, &local_err)) {
- error_propagate(errp, local_err);
+ if (!qemu_opt_parse(opt, errp)) {
return false;
}
const char *firstname;
char *id = opts_parse_id(params);
QemuOpts *opts;
- Error *local_err = NULL;
assert(!permit_abbrev || list->implied_opt_name);
firstname = permit_abbrev ? list->implied_opt_name : NULL;
* (if unlikely) future misuse:
*/
assert(!defaults || list->merge_lists);
- opts = qemu_opts_create(list, id, !defaults, &local_err);
+ opts = qemu_opts_create(list, id, !defaults, errp);
g_free(id);
if (opts == NULL) {
- error_propagate(errp, local_err);
return NULL;
}
if (!opts_do_parse(opts, params, firstname, defaults, help_wanted,
- &local_err)) {
- error_propagate(errp, local_err);
+ errp)) {
qemu_opts_del(opts);
return NULL;
}
QemuOpts *qemu_opts_from_qdict(QemuOptsList *list, const QDict *qdict,
Error **errp)
{
- Error *local_err = NULL;
QemuOpts *opts;
const QDictEntry *entry;
for (entry = qdict_first(qdict);
entry;
entry = qdict_next(qdict, entry)) {
- if (!qemu_opts_from_qdict_entry(opts, entry, &local_err)) {
- error_propagate(errp, local_err);
+ if (!qemu_opts_from_qdict_entry(opts, entry, errp)) {
qemu_opts_del(opts);
return NULL;
}
entry = qdict_first(qdict);
while (entry != NULL) {
- Error *local_err = NULL;
-
next = qdict_next(qdict, entry);
if (find_desc_by_name(opts->list->desc, entry->key)) {
- if (!qemu_opts_from_qdict_entry(opts, entry, &local_err)) {
- error_propagate(errp, local_err);
+ if (!qemu_opts_from_qdict_entry(opts, entry, errp)) {
return false;
}
qdict_del(qdict, entry->key);
bool qemu_opts_validate(QemuOpts *opts, const QemuOptDesc *desc, Error **errp)
{
QemuOpt *opt;
- Error *local_err = NULL;
assert(opts_accepts_any(opts));
return false;
}
- if (!qemu_opt_parse(opt, &local_err)) {
- error_propagate(errp, local_err);
+ if (!qemu_opt_parse(opt, errp)) {
return false;
}
}
projects / mirror_qemu.git / commitdiff