ret = bdrv_open_driver(bs, drv, node_name, bs->options, flags, errp);
if (ret < 0) {
- QDECREF(bs->explicit_options);
+ qobject_unref(bs->explicit_options);
bs->explicit_options = NULL;
- QDECREF(bs->options);
+ qobject_unref(bs->options);
bs->options = NULL;
bdrv_unref(bs);
return NULL;
options = qobject_to(QDict, options_obj);
if (!options) {
- qobject_decref(options_obj);
+ qobject_unref(options_obj);
error_setg(errp, "Invalid JSON object given");
return NULL;
}
/* Options given in the filename have lower priority than options
* specified directly */
qdict_join(options, json_options, false);
- QDECREF(json_options);
+ qobject_unref(json_options);
*pfilename = NULL;
}
if (reference || qdict_haskey(options, "file.filename")) {
backing_filename[0] = '\0';
} else if (bs->backing_file[0] == '\0' && qdict_size(options) == 0) {
- QDECREF(options);
+ qobject_unref(options);
goto free_exit;
} else {
bdrv_get_full_backing_filename(bs, backing_filename, PATH_MAX,
if (local_err) {
ret = -EINVAL;
error_propagate(errp, local_err);
- QDECREF(options);
+ qobject_unref(options);
goto free_exit;
}
}
if (!bs->drv || !bs->drv->supports_backing) {
ret = -EINVAL;
error_setg(errp, "Driver doesn't support backing files");
- QDECREF(options);
+ qobject_unref(options);
goto free_exit;
}
free_exit:
g_free(backing_filename);
- QDECREF(tmp_parent_options);
+ qobject_unref(tmp_parent_options);
return ret;
}
error_setg(errp, "A block device must be specified for \"%s\"",
bdref_key);
}
- QDECREF(image_options);
+ qobject_unref(image_options);
goto done;
}
obj = NULL;
fail:
- qobject_decref(obj);
+ qobject_unref(obj);
visit_free(v);
return bs;
}
}
out:
- QDECREF(snapshot_options);
+ qobject_unref(snapshot_options);
g_free(tmp_filename);
return bs_snapshot;
}
* options is a QDict of options to pass to the block drivers, or NULL for an
* empty set of options. The reference to the QDict belongs to the block layer
* after the call (even on failure), so if the caller intends to reuse the
- * dictionary, it needs to use QINCREF() before calling bdrv_open.
+ * dictionary, it needs to use qobject_ref() before calling bdrv_open.
*
* If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
* If it is not NULL, the referenced BDS will be reused.
if (reference) {
bool options_non_empty = options ? qdict_size(options) : false;
- QDECREF(options);
+ qobject_unref(options);
if (filename || options_non_empty) {
error_setg(errp, "Cannot reference an existing block device with "
bdrv_parent_cb_change_media(bs, true);
- QDECREF(options);
+ qobject_unref(options);
/* For snapshot=on, create a temporary qcow2 overlay. bs points to the
* temporary snapshot afterwards. */
fail:
blk_unref(file);
- QDECREF(snapshot_options);
- QDECREF(bs->explicit_options);
- QDECREF(bs->options);
- QDECREF(options);
+ qobject_unref(snapshot_options);
+ qobject_unref(bs->explicit_options);
+ qobject_unref(bs->options);
+ qobject_unref(options);
bs->options = NULL;
bs->explicit_options = NULL;
bdrv_unref(bs);
close_and_fail:
bdrv_unref(bs);
- QDECREF(snapshot_options);
- QDECREF(options);
+ qobject_unref(snapshot_options);
+ qobject_unref(options);
error_propagate(errp, local_err);
return NULL;
}
old_options = qdict_clone_shallow(bs->explicit_options);
}
bdrv_join_options(bs, options, old_options);
- QDECREF(old_options);
+ qobject_unref(old_options);
explicit_options = qdict_clone_shallow(options);
qemu_opts_absorb_qdict(opts, options_copy, NULL);
update_flags_from_options(&flags, opts);
qemu_opts_del(opts);
- QDECREF(options_copy);
+ qobject_unref(options_copy);
}
/* Old values are used for options that aren't set yet */
old_options = qdict_clone_shallow(bs->options);
bdrv_join_options(bs, options, old_options);
- QDECREF(old_options);
+ qobject_unref(old_options);
/* bdrv_open_inherit() sets and clears some additional flags internally */
flags &= ~BDRV_O_PROTOCOL;
bs_entry = g_new0(BlockReopenQueueEntry, 1);
QSIMPLEQ_INSERT_TAIL(bs_queue, bs_entry, entry);
} else {
- QDECREF(bs_entry->state.options);
- QDECREF(bs_entry->state.explicit_options);
+ qobject_unref(bs_entry->state.options);
+ qobject_unref(bs_entry->state.explicit_options);
}
bs_entry->state.bs = bs;
if (ret && bs_entry->prepared) {
bdrv_reopen_abort(&bs_entry->state);
} else if (ret) {
- QDECREF(bs_entry->state.explicit_options);
+ qobject_unref(bs_entry->state.explicit_options);
}
- QDECREF(bs_entry->state.options);
+ qobject_unref(bs_entry->state.options);
g_free(bs_entry);
}
g_free(bs_queue);
}
/* set BDS specific flags now */
- QDECREF(bs->explicit_options);
+ qobject_unref(bs->explicit_options);
bs->explicit_options = reopen_state->explicit_options;
bs->open_flags = reopen_state->flags;
drv->bdrv_reopen_abort(reopen_state);
}
- QDECREF(reopen_state->explicit_options);
+ qobject_unref(reopen_state->explicit_options);
bdrv_abort_perm_update(reopen_state->bs);
}
bs->total_sectors = 0;
bs->encrypted = false;
bs->sg = false;
- QDECREF(bs->options);
- QDECREF(bs->explicit_options);
+ qobject_unref(bs->options);
+ qobject_unref(bs->explicit_options);
bs->options = NULL;
bs->explicit_options = NULL;
- QDECREF(bs->full_open_options);
+ qobject_unref(bs->full_open_options);
bs->full_open_options = NULL;
bdrv_release_named_dirty_bitmaps(bs);
continue;
}
- qobject_incref(qdict_entry_value(entry));
+ qobject_ref(qdict_entry_value(entry));
qdict_put_obj(d, qdict_entry_key(entry), qdict_entry_value(entry));
found_any = true;
}
* information before refreshing it */
bs->exact_filename[0] = '\0';
if (bs->full_open_options) {
- QDECREF(bs->full_open_options);
+ qobject_unref(bs->full_open_options);
bs->full_open_options = NULL;
}
opts = qdict_new();
append_open_options(opts, bs);
drv->bdrv_refresh_filename(bs, opts);
- QDECREF(opts);
+ qobject_unref(opts);
} else if (bs->file) {
/* Try to reconstruct valid information from the underlying file */
bool has_open_options;
bs->exact_filename[0] = '\0';
if (bs->full_open_options) {
- QDECREF(bs->full_open_options);
+ qobject_unref(bs->full_open_options);
bs->full_open_options = NULL;
}
* suffices without querying the (exact_)filename of this BDS. */
if (bs->file->bs->full_open_options) {
qdict_put_str(opts, "driver", drv->format_name);
- QINCREF(bs->file->bs->full_open_options);
+ qobject_ref(bs->file->bs->full_open_options);
qdict_put(opts, "file", bs->file->bs->full_open_options);
bs->full_open_options = opts;
} else {
- QDECREF(opts);
+ qobject_unref(opts);
}
} else if (!bs->full_open_options && qdict_size(bs->options)) {
/* There is no underlying file BDS (at least referenced by BDS.file),
QString *json = qobject_to_json(QOBJECT(bs->full_open_options));
snprintf(bs->filename, sizeof(bs->filename), "json:%s",
qstring_get_str(json));
- QDECREF(json);
+ qobject_unref(json);
}
}
opts = qdict_new();
qdict_put_str(opts, "driver", "blkdebug");
- QINCREF(bs->file->bs->full_open_options);
+ qobject_ref(bs->file->bs->full_open_options);
qdict_put(opts, "image", bs->file->bs->full_open_options);
for (e = qdict_first(options); e; e = qdict_next(options, e)) {
if (strcmp(qdict_entry_key(e), "x-image")) {
- qobject_incref(qdict_entry_value(e));
+ qobject_ref(qdict_entry_value(e));
qdict_put_obj(opts, qdict_entry_key(e), qdict_entry_value(e));
}
}
QDict *opts = qdict_new();
qdict_put_str(opts, "driver", "blkverify");
- QINCREF(bs->file->bs->full_open_options);
+ qobject_ref(bs->file->bs->full_open_options);
qdict_put(opts, "raw", bs->file->bs->full_open_options);
- QINCREF(s->test_file->bs->full_open_options);
+ qobject_ref(s->test_file->bs->full_open_options);
qdict_put(opts, "test", s->test_file->bs->full_open_options);
bs->full_open_options = opts;
ret = 0;
cleanup:
- QDECREF(cryptoopts);
+ qobject_unref(cryptoopts);
qapi_free_QCryptoBlockOpenOptions(open_opts);
return ret;
}
fail:
bdrv_unref(bs);
qapi_free_QCryptoBlockCreateOptions(create_opts);
- QDECREF(cryptoopts);
+ qobject_unref(cryptoopts);
return ret;
}
}
gsconf = NULL;
- QDECREF(backing_options);
+ qobject_unref(backing_options);
backing_options = NULL;
g_free(str);
str = NULL;
qapi_free_SocketAddress(gsconf);
qemu_opts_del(opts);
g_free(str);
- QDECREF(backing_options);
+ qobject_unref(backing_options);
errno = EINVAL;
return -errno;
}
} else {
ret = iscsi_open(bs, bs_options, 0, NULL);
}
- QDECREF(bs_options);
+ qobject_unref(bs_options);
if (ret != 0) {
goto out;
}
done:
- QDECREF(addr);
- qobject_decref(crumpled_addr);
+ qobject_unref(addr);
+ qobject_unref(crumpled_addr);
visit_free(iv);
return saddr;
}
v = qobject_input_visitor_new_keyval(crumpled);
visit_type_BlockdevOptionsNfs(v, NULL, &opts, &local_err);
visit_free(v);
- qobject_decref(crumpled);
+ qobject_unref(crumpled);
if (local_err) {
return NULL;
ret = 0;
out:
- QDECREF(options);
+ qobject_unref(options);
qapi_free_BlockdevCreateOptions(create_options);
return ret;
}
static void null_refresh_filename(BlockDriverState *bs, QDict *opts)
{
- QINCREF(opts);
+ qobject_ref(opts);
qdict_del(opts, "filename");
if (!qdict_size(opts)) {
static void nvme_refresh_filename(BlockDriverState *bs, QDict *opts)
{
- QINCREF(opts);
+ qobject_ref(opts);
qdict_del(opts, "filename");
if (!qdict_size(opts)) {
qdict_put_str(qdict, "file", bs->node_name);
qobj = qdict_crumple(qdict, errp);
- QDECREF(qdict);
+ qobject_unref(qdict);
qdict = qobject_to(QDict, qobj);
if (qdict == NULL) {
ret = -EINVAL;
ret = 0;
done:
- QDECREF(qdict);
+ qobject_unref(qdict);
bdrv_unref(bs);
qapi_free_BlockdevCreateOptions(create_options);
return ret;
visit_complete(v, &obj);
data = qdict_get(qobject_to(QDict, obj), "data");
dump_qobject(func_fprintf, f, 1, data);
- qobject_decref(obj);
+ qobject_unref(obj);
visit_free(v);
}
goto fail;
}
- QDECREF(encryptopts);
+ qobject_unref(encryptopts);
qapi_free_QCryptoBlockOpenOptions(crypto_opts);
qemu_co_mutex_init(&s->lock);
return 0;
g_free(s->cluster_cache);
g_free(s->cluster_data);
qcrypto_block_free(s->crypto);
- QDECREF(encryptopts);
+ qobject_unref(encryptopts);
qapi_free_QCryptoBlockOpenOptions(crypto_opts);
return ret;
}
qdict_put_str(qdict, "file", bs->node_name);
qobj = qdict_crumple(qdict, errp);
- QDECREF(qdict);
+ qobject_unref(qdict);
qdict = qobject_to(QDict, qobj);
if (qdict == NULL) {
ret = -EINVAL;
ret = 0;
fail:
- QDECREF(qdict);
+ qobject_unref(qdict);
bdrv_unref(bs);
qapi_free_BlockdevCreateOptions(create_options);
return ret;
ret = 0;
fail:
- QDECREF(encryptopts);
+ qobject_unref(encryptopts);
qemu_opts_del(opts);
opts = NULL;
return ret;
qemu_co_mutex_lock(&s->lock);
ret = qcow2_do_open(bs, options, flags, &local_err);
qemu_co_mutex_unlock(&s->lock);
- QDECREF(options);
+ qobject_unref(options);
if (local_err) {
error_propagate(errp, local_err);
error_prepend(errp, "Could not reopen qcow2 layer: ");
/* Now get the QAPI type BlockdevCreateOptions */
qobj = qdict_crumple(qdict, errp);
- QDECREF(qdict);
+ qobject_unref(qdict);
qdict = qobject_to(QDict, qobj);
if (qdict == NULL) {
ret = -EINVAL;
ret = 0;
finish:
- QDECREF(qdict);
+ qobject_unref(qdict);
bdrv_unref(bs);
qapi_free_BlockdevCreateOptions(create_options);
return ret;
qdict_put_str(qdict, "file", bs->node_name);
qobj = qdict_crumple(qdict, errp);
- QDECREF(qdict);
+ qobject_unref(qdict);
qdict = qobject_to(QDict, qobj);
if (qdict == NULL) {
ret = -EINVAL;
ret = bdrv_qed_co_create(create_options, errp);
fail:
- QDECREF(qdict);
+ qobject_unref(qdict);
bdrv_unref(bs);
qapi_free_BlockdevCreateOptions(create_options);
return ret;
children = qlist_new();
for (i = 0; i < s->num_children; i++) {
- QINCREF(s->children[i]->bs->full_open_options);
+ qobject_ref(s->children[i]->bs->full_open_options);
qlist_append(children, s->children[i]->bs->full_open_options);
}
done:
g_free(buf);
- QDECREF(keypairs);
+ qobject_unref(keypairs);
return;
}
key = qstring_get_str(name);
ret = rados_conf_set(cluster, key, qstring_get_str(value));
- QDECREF(value);
+ qobject_unref(value);
if (ret < 0) {
error_setg_errno(errp, -ret, "invalid conf option %s", key);
- QDECREF(name);
+ qobject_unref(name);
ret = -EINVAL;
break;
}
- QDECREF(name);
+ qobject_unref(name);
}
- QDECREF(keypairs);
+ qobject_unref(keypairs);
return ret;
}
}
exit:
- QDECREF(options);
+ qobject_unref(options);
qapi_free_BlockdevCreateOptions(create_options);
return ret;
}
v = qobject_input_visitor_new_keyval(crumpled);
visit_type_BlockdevOptionsRbd(v, NULL, &opts, &local_err);
visit_free(v);
- qobject_decref(crumpled);
+ qobject_unref(crumpled);
if (local_err) {
error_propagate(errp, local_err);
done:
visit_free(iv);
- qobject_decref(crumpled_server);
- QDECREF(server);
+ qobject_unref(crumpled_server);
+ qobject_unref(server);
return saddr;
}
if (local_err) {
error_propagate(errp, local_err);
- qobject_decref(obj);
+ qobject_unref(obj);
return -EINVAL;
}
ret = sd_prealloc(bs, 0, size, errp);
fail:
bdrv_unref(bs);
- QDECREF(qdict);
+ qobject_unref(qdict);
return ret;
}
v = qobject_input_visitor_new_keyval(crumpled);
visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err);
visit_free(v);
- qobject_decref(crumpled);
+ qobject_unref(crumpled);
if (local_err) {
error_propagate(errp, local_err);
ret = sd_co_create(create_options, errp);
fail:
qapi_free_BlockdevCreateOptions(create_options);
- QDECREF(qdict);
+ qobject_unref(qdict);
return ret;
}
bdrv_ref(file);
qdict_extract_subqdict(options, &file_options, "file.");
- QDECREF(file_options);
+ qobject_unref(file_options);
qdict_put_str(options, "file", bdrv_get_node_name(file));
drv->bdrv_close(bs);
ret = bdrv_snapshot_goto(file, snapshot_id, errp);
open_ret = drv->bdrv_open(bs, options, bs->open_flags, &local_err);
- QDECREF(options);
+ qobject_unref(options);
if (open_ret < 0) {
bdrv_unref(file);
bs->drv = NULL;
v = qobject_input_visitor_new(crumpled);
visit_type_BlockdevOptionsSsh(v, NULL, &result, &local_err);
visit_free(v);
- qobject_decref(crumpled);
+ qobject_unref(crumpled);
if (local_err) {
error_propagate(errp, local_err);
ret = ssh_co_create(create_options, errp);
out:
- QDECREF(uri_options);
+ qobject_unref(uri_options);
qapi_free_BlockdevCreateOptions(create_options);
return ret;
}
/* Create the vdi image (format layer) */
ret = vdi_co_do_create(create_options, block_size, errp);
done:
- QDECREF(qdict);
+ qobject_unref(qdict);
qapi_free_BlockdevCreateOptions(create_options);
bdrv_unref(bs_file);
return ret;
qdict_put_str(qdict, "file", bs->node_name);
qobj = qdict_crumple(qdict, errp);
- QDECREF(qdict);
+ qobject_unref(qdict);
qdict = qobject_to(QDict, qobj);
if (qdict == NULL) {
ret = -EINVAL;
ret = vhdx_co_create(create_options, errp);
fail:
- QDECREF(qdict);
+ qobject_unref(qdict);
bdrv_unref(bs);
qapi_free_BlockdevCreateOptions(create_options);
return ret;
qdict_put_str(qdict, "file", bs->node_name);
qobj = qdict_crumple(qdict, errp);
- QDECREF(qdict);
+ qobject_unref(qdict);
qdict = qobject_to(QDict, qobj);
if (qdict == NULL) {
ret = -EINVAL;
ret = vpc_co_create(create_options, errp);
fail:
- QDECREF(qdict);
+ qobject_unref(qdict);
bdrv_unref(bs);
qapi_free_BlockdevCreateOptions(create_options);
return ret;
qdict_put_str(options, "write-target.driver", "qcow");
s->qcow = bdrv_open_child(s->qcow_filename, options, "write-target", bs,
&child_vvfat_qcow, false, errp);
- QDECREF(options);
+ qobject_unref(options);
if (!s->qcow) {
ret = -EINVAL;
goto err;
out:
g_free(of_vsa_addr);
- QDECREF(backing_options);
+ qobject_unref(backing_options);
qemu_opts_del(tcp_opts);
qemu_opts_del(opts);
g_free(cacert);
blk_rs->read_only = read_only;
blk_rs->detect_zeroes = detect_zeroes;
- QDECREF(bs_opts);
+ qobject_unref(bs_opts);
} else {
if (file && !*file) {
file = NULL;
err_no_bs_opts:
qemu_opts_del(opts);
- QDECREF(interval_dict);
- QDECREF(interval_list);
+ qobject_unref(interval_dict);
+ qobject_unref(interval_list);
return blk;
early_err:
qemu_opts_del(opts);
- QDECREF(interval_dict);
- QDECREF(interval_list);
+ qobject_unref(interval_dict);
+ qobject_unref(interval_list);
err_no_opts:
- QDECREF(bs_opts);
+ qobject_unref(bs_opts);
return NULL;
}
fail:
qemu_opts_del(legacy_opts);
- QDECREF(bs_opts);
+ qobject_unref(bs_opts);
return dinfo;
}
qdict = qemu_opts_to_qdict(opts, NULL);
if (!qdict_get_try_str(qdict, "node-name")) {
- QDECREF(qdict);
+ qobject_unref(qdict);
error_report("'node-name' needs to be specified");
goto out;
}
emit(EXAMPLE_QAPI_EVENT_MY_EVENT, qmp, &err);
error_propagate(errp, err);
- QDECREF(qmp);
+ qobject_unref(qmp);
}
const QEnumLookup example_QAPIEvent_lookup = {
} else {
pm->s3_disabled = false;
}
- qobject_decref(o);
+ qobject_unref(o);
o = object_property_get_qobject(obj, ACPI_PM_PROP_S4_DISABLED, NULL);
if (o) {
pm->s4_disabled = qnum_get_uint(qobject_to(QNum, o));
} else {
pm->s4_disabled = false;
}
- qobject_decref(o);
+ qobject_unref(o);
o = object_property_get_qobject(obj, ACPI_PM_PROP_S4_VAL, NULL);
if (o) {
pm->s4_val = qnum_get_uint(qobject_to(QNum, o));
} else {
pm->s4_val = false;
}
- qobject_decref(o);
+ qobject_unref(o);
pm->pcihp_bridge_en =
object_property_get_bool(obj, "acpi-pci-hotplug-with-bridge-support",
}
}
aml_append(parent_scope, method);
- qobject_decref(bsel);
+ qobject_unref(bsel);
}
/**
return false;
}
mcfg->mcfg_base = qnum_get_uint(qobject_to(QNum, o));
- qobject_decref(o);
+ qobject_unref(o);
o = object_property_get_qobject(pci_host, PCIE_HOST_MCFG_SIZE, NULL);
assert(o);
mcfg->mcfg_size = qnum_get_uint(qobject_to(QNum, o));
- qobject_decref(o);
+ qobject_unref(o);
return true;
}
if (!drc->fdt) {
visit_type_null(v, NULL, &null, errp);
- QDECREF(null);
+ qobject_unref(null);
return;
}
if (!usbif->ports[port - 1].dev) {
goto err;
}
- QDECREF(qdict);
+ qobject_unref(qdict);
speed = usbif->ports[port - 1].dev->speed;
switch (speed) {
case USB_SPEED_LOW:
return;
err:
- QDECREF(qdict);
+ qobject_unref(qdict);
xen_pv_printf(&usbif->xendev, 0, "device %s could not be opened\n", busid);
}
static inline QNull *qnull(void)
{
- QINCREF(&qnull_);
+ qobject_ref(&qnull_);
return &qnull_;
}
* ------------------------------------
*
* - Returning references: A function that returns an object may
- * return it as either a weak or a strong reference. If the reference
- * is strong, you are responsible for calling QDECREF() on the reference
- * when you are done.
+ * return it as either a weak or a strong reference. If the
+ * reference is strong, you are responsible for calling
+ * qobject_unref() on the reference when you are done.
*
* If the reference is weak, the owner of the reference may free it at
* any time in the future. Before storing the reference anywhere, you
- * should call QINCREF() to make the reference strong.
+ * should call qobject_ref() to make the reference strong.
*
* - Transferring ownership: when you transfer ownership of a reference
* by calling a function, you are no longer responsible for calling
- * QDECREF() when the reference is no longer needed. In other words,
+ * qobject_unref() when the reference is no longer needed. In other words,
* when the function returns you must behave as if the reference to the
* passed object was weak.
*/
_obj ? container_of(&(_obj)->base, QObject, base) : NULL; \
})
-/* High-level interface for qobject_incref() */
-#define QINCREF(obj) \
- qobject_incref(QOBJECT(obj))
-
-/* High-level interface for qobject_decref() */
-#define QDECREF(obj) \
- qobject_decref(obj ? QOBJECT(obj) : NULL)
-
/* Required for qobject_to() */
#define QTYPE_CAST_TO_QNull QTYPE_QNULL
#define QTYPE_CAST_TO_QNum QTYPE_QNUM
obj->base.type = type;
}
-/**
- * qobject_incref(): Increment QObject's reference count
- */
-static inline void qobject_incref(QObject *obj)
+static inline void qobject_ref_impl(QObject *obj)
{
if (obj) {
obj->base.refcnt++;
*/
void qobject_destroy(QObject *obj);
-/**
- * qobject_decref(): Decrement QObject's reference count, deallocate
- * when it reaches zero
- */
-static inline void qobject_decref(QObject *obj)
+static inline void qobject_unref_impl(QObject *obj)
{
assert(!obj || obj->base.refcnt);
if (obj && --obj->base.refcnt == 0) {
}
}
+/**
+ * qobject_ref(): Increment QObject's reference count
+ */
+#define qobject_ref(obj) qobject_ref_impl(QOBJECT(obj))
+
+/**
+ * qobject_unref(): Decrement QObject's reference count, deallocate
+ * when it reaches zero
+ */
+#define qobject_unref(obj) qobject_unref_impl(QOBJECT(obj))
+
/**
* qobject_type(): Return the QObject's type
*/
/* TODO Rewrite "" to null instead */
if (params->has_tls_creds
&& params->tls_creds->type == QTYPE_QNULL) {
- QDECREF(params->tls_creds->u.n);
+ qobject_unref(params->tls_creds->u.n);
params->tls_creds->type = QTYPE_QSTRING;
params->tls_creds->u.s = strdup("");
}
/* TODO Rewrite "" to null instead */
if (params->has_tls_hostname
&& params->tls_hostname->type == QTYPE_QNULL) {
- QDECREF(params->tls_hostname->u.n);
+ qobject_unref(params->tls_hostname->u.n);
params->tls_hostname->type = QTYPE_QSTRING;
params->tls_hostname->u.s = strdup("");
}
void qjson_destroy(QJSON *json)
{
- QDECREF(json->str);
+ qobject_unref(json->str);
g_free(json);
}
static void qmp_request_free(QMPRequest *req)
{
- qobject_decref(req->id);
- qobject_decref(req->req);
+ qobject_unref(req->id);
+ qobject_unref(req->req);
g_free(req);
}
static void monitor_qmp_cleanup_resp_queue_locked(Monitor *mon)
{
while (!g_queue_is_empty(mon->qmp.qmp_responses)) {
- qobject_decref(g_queue_pop_head(mon->qmp.qmp_responses));
+ qobject_unref((QObject *)g_queue_pop_head(mon->qmp.qmp_responses));
}
}
rc = qemu_chr_fe_write(&mon->chr, (const uint8_t *) buf, len);
if ((rc < 0 && errno != EAGAIN) || (rc == len)) {
/* all flushed or error */
- QDECREF(mon->outbuf);
+ qobject_unref(mon->outbuf);
mon->outbuf = qstring_new();
return;
}
if (rc > 0) {
/* partial write */
QString *tmp = qstring_from_str(buf + rc);
- QDECREF(mon->outbuf);
+ qobject_unref(mon->outbuf);
mon->outbuf = tmp;
}
if (mon->out_watch == 0) {
qstring_append_chr(json, '\n');
monitor_puts(mon, qstring_get_str(json));
- QDECREF(json);
+ qobject_unref(json);
}
static void monitor_json_emitter(Monitor *mon, QObject *data)
* caller won't free the data (which will be finally freed in
* responder thread).
*/
- qobject_incref(data);
+ qobject_ref(data);
qemu_mutex_lock(&mon->qmp.qmp_queue_lock);
- g_queue_push_tail(mon->qmp.qmp_responses, (void *)data);
+ g_queue_push_tail(mon->qmp.qmp_responses, data);
qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
qemu_bh_schedule(mon_global.qmp_respond_bh);
} else {
break;
}
monitor_json_emitter_raw(response.mon, response.data);
- qobject_decref(response.data);
+ qobject_unref(response.data);
}
}
* last send. Store event for sending when timer fires,
* replacing a prior stored event if any.
*/
- QDECREF(evstate->qdict);
+ qobject_unref(evstate->qdict);
evstate->qdict = qdict;
- QINCREF(evstate->qdict);
+ qobject_ref(evstate->qdict);
} else {
/*
* Last send was (at least) evconf->rate ns ago.
evstate = g_new(MonitorQAPIEventState, 1);
evstate->event = event;
evstate->data = data;
- QINCREF(evstate->data);
+ qobject_ref(evstate->data);
evstate->qdict = NULL;
evstate->timer = timer_new_ns(event_clock_type,
monitor_qapi_event_handler,
int64_t now = qemu_clock_get_ns(event_clock_type);
monitor_qapi_event_emit(evstate->event, evstate->qdict);
- QDECREF(evstate->qdict);
+ qobject_unref(evstate->qdict);
evstate->qdict = NULL;
timer_mod_ns(evstate->timer, now + evconf->rate);
} else {
g_hash_table_remove(monitor_qapi_event_state, evstate);
- QDECREF(evstate->data);
+ qobject_unref(evstate->data);
timer_free(evstate->timer);
g_free(evstate);
}
json_message_parser_destroy(&mon->qmp.parser);
}
readline_free(mon->rs);
- QDECREF(mon->outbuf);
+ qobject_unref(mon->outbuf);
qemu_mutex_destroy(&mon->out_lock);
qemu_mutex_destroy(&mon->qmp.qmp_queue_lock);
monitor_qmp_cleanup_req_queue_locked(mon);
return qdict;
fail:
- QDECREF(qdict);
+ qobject_unref(qdict);
g_free(key);
return NULL;
}
}
cmd->cmd(mon, qdict);
- QDECREF(qdict);
+ qobject_unref(qdict);
}
static void cmd_completion(Monitor *mon, const char *name, const char *list)
if (rsp) {
if (id) {
/* This is for the qdict below. */
- qobject_incref(id);
+ qobject_ref(id);
qdict_put_obj(qobject_to(QDict, rsp), "id", id);
}
monitor_json_emitter(mon, rsp);
}
- qobject_decref(id);
- qobject_decref(rsp);
+ qobject_unref(id);
+ qobject_unref(rsp);
}
/*
if (trace_event_get_state_backends(TRACE_HANDLE_QMP_COMMAND)) {
QString *req_json = qobject_to_json(req);
trace_handle_qmp_command(mon, qstring_get_str(req_json));
- QDECREF(req_json);
+ qobject_unref(req_json);
}
old_mon = cur_mon;
monitor_resume(mon);
}
- qobject_decref(req);
+ qobject_unref(req);
}
/*
goto err;
}
- qobject_incref(id);
+ qobject_ref(id);
qdict_del(qdict, "id");
req_obj = g_new0(QMPRequest, 1);
err:
monitor_qmp_respond(mon, NULL, err, NULL);
- qobject_decref(req);
+ qobject_unref(req);
}
static void monitor_qmp_read(void *opaque, const uint8_t *buf, int size)
monitor_qmp_caps_reset(mon);
data = get_qmp_greeting(mon);
monitor_json_emitter(mon, data);
- qobject_decref(data);
+ qobject_unref(data);
mon_refcount++;
break;
case CHR_EVENT_CLOSED:
QObject **obj, Error **errp)
{
if (obj) {
- qobject_decref(*obj);
+ qobject_unref(*obj);
}
}
QNull **obj, Error **errp)
{
if (obj) {
- QDECREF(*obj);
+ qobject_unref(*obj);
}
}
args = qdict_new();
} else {
args = qdict_get_qdict(dict, "arguments");
- QINCREF(args);
+ qobject_ref(args);
}
cmd->fn(args, &ret, &local_err);
ret = QOBJECT(qdict_new());
}
- QDECREF(args);
+ qobject_unref(args);
return ret;
}
} else if (ret) {
qdict_put_obj(rsp, "return", ret);
} else {
- QDECREF(rsp);
+ qobject_unref(rsp);
return NULL;
}
return;
}
- qobject_incref(qobj);
+ qobject_ref(qobj);
*obj = qobj;
}
qobject_input_stack_object_free(tos);
}
- qobject_decref(qiv->root);
+ qobject_unref(qiv->root);
if (qiv->errname) {
g_string_free(qiv->errname, TRUE);
}
v->visitor.free = qobject_input_free;
v->root = obj;
- qobject_incref(obj);
+ qobject_ref(obj);
return v;
}
}
v = qobject_input_visitor_new_keyval(QOBJECT(args));
}
- QDECREF(args);
+ qobject_unref(args);
return v;
}
QObject **obj, Error **errp)
{
QObjectOutputVisitor *qov = to_qov(v);
- qobject_incref(*obj);
+ qobject_ref(*obj);
qobject_output_add_obj(qov, name, *obj);
}
/* Finish building, and return the root object.
* The root object is never null. The caller becomes the object's
- * owner, and should use qobject_decref() when done with it. */
+ * owner, and should use qobject_unref() when done with it. */
static void qobject_output_complete(Visitor *v, void *opaque)
{
QObjectOutputVisitor *qov = to_qov(v);
assert(qov->root && QSLIST_EMPTY(&qov->stack));
assert(opaque == qov->result);
- qobject_incref(qov->root);
+ qobject_ref(qov->root);
*qov->result = qov->root;
qov->result = NULL;
}
g_free(e);
}
- qobject_decref(qov->root);
+ qobject_unref(qov->root);
g_free(qov);
}
if (qdict_haskey(options, BDRV_OPT_FORCE_SHARE)
&& !qdict_get_bool(options, BDRV_OPT_FORCE_SHARE)) {
error_report("--force-share/-U conflicts with image options");
- QDECREF(options);
+ qobject_unref(options);
return NULL;
}
qdict_put_bool(options, BDRV_OPT_FORCE_SHARE, true);
str = qobject_to_json_pretty(obj);
assert(str != NULL);
qprintf(quiet, "%s\n", qstring_get_str(str));
- qobject_decref(obj);
+ qobject_unref(obj);
visit_free(v);
- QDECREF(str);
+ qobject_unref(str);
}
static void dump_human_image_check(ImageCheck *check, bool quiet)
str = qobject_to_json_pretty(obj);
assert(str != NULL);
printf("%s\n", qstring_get_str(str));
- qobject_decref(obj);
+ qobject_unref(obj);
visit_free(v);
- QDECREF(str);
+ qobject_unref(str);
}
static void dump_json_image_info(ImageInfo *info)
str = qobject_to_json_pretty(obj);
assert(str != NULL);
printf("%s\n", qstring_get_str(str));
- qobject_decref(obj);
+ qobject_unref(obj);
visit_free(v);
- QDECREF(str);
+ qobject_unref(str);
}
static void dump_human_image_info_list(ImageInfoList *list)
str = qobject_to_json_pretty(obj);
assert(str != NULL);
printf("%s\n", qstring_get_str(str));
- qobject_decref(obj);
+ qobject_unref(obj);
visit_free(v);
- QDECREF(str);
+ qobject_unref(str);
}
static int img_measure(int argc, char **argv)
if (qemuio_blk) {
error_report("file open already, try 'help close'");
- QDECREF(opts);
+ qobject_unref(opts);
return 1;
}
if (qdict_haskey(opts, BDRV_OPT_FORCE_SHARE)
&& !qdict_get_bool(opts, BDRV_OPT_FORCE_SHARE)) {
error_report("-U conflicts with image options");
- QDECREF(opts);
+ qobject_unref(opts);
return 1;
}
qdict_put_bool(opts, BDRV_OPT_FORCE_SHARE, true);
} else if (optind == argc) {
openfile(NULL, flags, writethrough, force_share, opts);
} else {
- QDECREF(opts);
+ qobject_unref(opts);
qemuio_command_usage(&open_cmd);
}
return 0;
response_qstr = qstring_new();
qstring_append_chr(response_qstr, QGA_SENTINEL_BYTE);
qstring_append(response_qstr, qstring_get_str(payload_qstr));
- QDECREF(payload_qstr);
+ qobject_unref(payload_qstr);
} else {
response_qstr = payload_qstr;
}
qstring_append_chr(response_qstr, '\n');
buf = qstring_get_str(response_qstr);
status = ga_channel_write_all(s->channel, buf, strlen(buf));
- QDECREF(response_qstr);
+ qobject_unref(response_qstr);
if (status != G_IO_STATUS_NORMAL) {
return -EIO;
}
if (ret < 0) {
g_warning("error sending response: %s", strerror(-ret));
}
- qobject_decref(rsp);
+ qobject_unref(rsp);
}
}
g_debug("process_event: called");
qdict = qobject_to(QDict, json_parser_parse_err(tokens, NULL, &err));
if (err || !qdict) {
- QDECREF(qdict);
+ qobject_unref(qdict);
qdict = qdict_new();
if (!err) {
g_warning("failed to parse event: unknown error");
process_command(s, qdict);
} else {
if (!qdict_haskey(qdict, "error")) {
- QDECREF(qdict);
+ qobject_unref(qdict);
qdict = qdict_new();
g_warning("unrecognized payload format");
error_setg(&err, QERR_UNSUPPORTED);
}
}
- QDECREF(qdict);
+ qobject_unref(qdict);
}
/* false return signals GAChannel to close the current client connection */
error_setg(errp, QERR_INVALID_PARAMETER_TYPE, "props", "dict");
return;
}
- QINCREF(pdict);
+ qobject_ref(pdict);
} else {
pdict = qdict_new();
}
if (obj) {
object_unref(obj);
}
- QDECREF(pdict);
+ qobject_unref(pdict);
}
void qmp_object_del(const char *id, Error **errp)
return str;
out:
- QDECREF(str);
+ qobject_unref(str);
return NULL;
}
qdict_put_obj(dict, qstring_get_str(key), value);
- QDECREF(key);
+ qobject_unref(key);
return 0;
out:
- QDECREF(key);
+ qobject_unref(key);
return -1;
}
return QOBJECT(dict);
out:
- QDECREF(dict);
+ qobject_unref(dict);
return NULL;
}
return QOBJECT(list);
out:
- QDECREF(list);
+ qobject_unref(list);
return NULL;
}
entry = qdict_find(qdict, key, bucket);
if (entry) {
/* replace key's value */
- qobject_decref(entry->value);
+ qobject_unref(entry->value);
entry->value = value;
} else {
/* allocate a new entry */
for (i = 0; i < QDICT_BUCKET_MAX; i++) {
QLIST_FOREACH(entry, &src->table[i], next) {
- qobject_incref(entry->value);
+ qobject_ref(entry->value);
qdict_put_obj(dest, entry->key, entry->value);
}
}
assert(e->key != NULL);
assert(e->value != NULL);
- qobject_decref(e->value);
+ qobject_unref(e->value);
g_free(e->key);
g_free(e);
}
val = qdict_get(src, key);
if (val) {
- qobject_incref(val);
+ qobject_ref(val);
qdict_put_obj(dst, key, val);
}
}
qdict_flatten_qlist(qobject_to(QList, value), target, new_key);
} else {
/* All other types are moved to the target unchanged. */
- qobject_incref(value);
+ qobject_ref(value);
qdict_put_obj(target, new_key, value);
}
delete = true;
} else if (prefix) {
/* All other objects are moved to the target unchanged. */
- qobject_incref(value);
+ qobject_ref(value);
qdict_put_obj(target, new_key, value);
delete = true;
}
while (entry != NULL) {
next = qdict_next(src, entry);
if (strstart(entry->key, start, &p)) {
- qobject_incref(entry->value);
+ qobject_ref(entry->value);
qdict_put_obj(*dst, p, entry->value);
qdict_del(src, entry->key);
}
qdict_extract_subqdict(src, &subqdict, prefix);
assert(qdict_size(subqdict) > 0);
} else {
- qobject_incref(subqobj);
+ qobject_ref(subqobj);
qdict_del(src, indexstr);
}
qdict_put_obj(two_level, prefix, QOBJECT(child_dict));
}
- qobject_incref(ent->value);
+ qobject_ref(ent->value);
qdict_put_obj(child_dict, suffix, ent->value);
} else {
if (child) {
prefix);
goto error;
}
- qobject_incref(ent->value);
+ qobject_ref(ent->value);
qdict_put_obj(two_level, prefix, ent->value);
}
qdict_put_obj(multi_level, ent->key, child);
} else {
- qobject_incref(ent->value);
+ qobject_ref(ent->value);
qdict_put_obj(multi_level, ent->key, ent->value);
}
}
- QDECREF(two_level);
+ qobject_unref(two_level);
two_level = NULL;
/* Step 3: detect if we need to turn our dict into list */
goto error;
}
- qobject_incref(child);
+ qobject_ref(child);
qlist_append_obj(qobject_to(QList, dst), child);
}
- QDECREF(multi_level);
+ qobject_unref(multi_level);
multi_level = NULL;
} else {
dst = QOBJECT(multi_level);
error:
g_free(prefix);
- QDECREF(multi_level);
- QDECREF(two_level);
- qobject_decref(dst);
+ qobject_unref(multi_level);
+ qobject_unref(two_level);
+ qobject_unref(dst);
return NULL;
}
next = qdict_next(src, entry);
if (overwrite || !qdict_haskey(dest, entry->key)) {
- qobject_incref(entry->value);
+ qobject_ref(entry->value);
qdict_put_obj(dest, entry->key, entry->value);
qdict_del(src, entry->key);
}
}
qobj = qdict_get(qdict, renames->from);
- qobject_incref(qobj);
+ qobject_ref(qobj);
qdict_put_obj(qdict, renames->to, qobj);
qdict_del(qdict, renames->from);
}
qkey = qstring_from_str(key);
to_json(QOBJECT(qkey), s->str, s->pretty, s->indent);
- QDECREF(qkey);
+ qobject_unref(qkey);
qstring_append(s->str, ": ");
to_json(obj, s->str, s->pretty, s->indent);
{
QList *dst = opaque;
- qobject_incref(obj);
+ qobject_ref(obj);
qlist_append_obj(dst, obj);
}
QTAILQ_FOREACH_SAFE(entry, &qlist->head, next, next_entry) {
QTAILQ_REMOVE(&qlist->head, entry, next);
- qobject_decref(entry->value);
+ qobject_unref(entry->value);
g_free(entry);
}
QString *qstr = qstring_from_str(value);
object_property_set_qobject(obj, QOBJECT(qstr), name, errp);
- QDECREF(qstr);
+ qobject_unref(qstr);
}
char *object_property_get_str(Object *obj, const char *name,
error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name, "string");
}
- qobject_decref(ret);
+ qobject_unref(ret);
return retval;
}
QBool *qbool = qbool_from_bool(value);
object_property_set_qobject(obj, QOBJECT(qbool), name, errp);
- QDECREF(qbool);
+ qobject_unref(qbool);
}
bool object_property_get_bool(Object *obj, const char *name,
retval = qbool_get_bool(qbool);
}
- qobject_decref(ret);
+ qobject_unref(ret);
return retval;
}
QNum *qnum = qnum_from_int(value);
object_property_set_qobject(obj, QOBJECT(qnum), name, errp);
- QDECREF(qnum);
+ qobject_unref(qnum);
}
int64_t object_property_get_int(Object *obj, const char *name,
retval = -1;
}
- qobject_decref(ret);
+ qobject_unref(ret);
return retval;
}
QNum *qnum = qnum_from_uint(value);
object_property_set_qobject(obj, QOBJECT(qnum), name, errp);
- QDECREF(qnum);
+ qobject_unref(qnum);
}
uint64_t object_property_get_uint(Object *obj, const char *name,
retval = 0;
}
- qobject_decref(ret);
+ qobject_unref(ret);
return retval;
}
qemu_opts_set_id(opts, (char *) id);
qemu_opt_set(opts, "qom-type", type, &error_abort);
g_free(type);
- QDECREF(pdict);
+ qobject_unref(pdict);
return obj;
}
expression Obj, Key, E;
@@
(
-- qobject_incref(QOBJECT(E));
-+ QINCREF(E);
+- qobject_ref(QOBJECT(E));
++ qobject_ref(E);
|
-- qobject_decref(QOBJECT(E));
-+ QDECREF(E);
+- qobject_unref(QOBJECT(E));
++ qobject_unref(E);
|
- qdict_put_obj(Obj, Key, QOBJECT(E));
+ qdict_put(Obj, Key, E);
''')
ret += mcgen('''
error_propagate(errp, err);
- QDECREF(qmp);
+ qobject_unref(qmp);
}
''')
return ret
"use max-cpu-compat machine property instead");
}
visit_type_null(v, name, &null, NULL);
- QDECREF(null);
+ qobject_unref(null);
}
static const PropertyInfo ppc_compat_deprecated_propinfo = {
}
if (!qdict_size(qdict)) {
- QDECREF(qdict);
+ qobject_unref(qdict);
} else {
info->props = QOBJECT(qdict);
info->has_props = true;
} else {
g_assert(!qdict_get_bool(data, "tray-open"));
}
- QDECREF(rsp);
+ qobject_unref(rsp);
}
static void test_atapi_tray(void)
"'arguments': {'id': 'cd0'}}");
atapi_wait_tray(true);
rsp = qmp_receive();
- QDECREF(rsp);
+ qobject_unref(rsp);
qmp_discard_response("{'execute': 'blockdev-remove-medium', "
"'arguments': {'id': 'cd0'}}");
"'arguments': {'id': 'cd0'}}");
atapi_wait_tray(false);
rsp = qmp_receive();
- QDECREF(rsp);
+ qobject_unref(rsp);
/* Now, to convince ATAPI we understand the media has changed... */
ahci_atapi_test_ready(ahci, port, false, SENSE_NOT_READY);
g_assert(qdict->base.refcnt == 1);
g_assert(qobject_type(QOBJECT(qdict)) == QTYPE_QDICT);
- QDECREF(qdict);
+ qobject_unref(qdict);
}
static void qdict_put_obj_test(void)
qn = qobject_to(QNum, ent->value);
g_assert_cmpint(qnum_get_int(qn), ==, num);
- QDECREF(qdict);
+ qobject_unref(qdict);
}
static void qdict_destroy_simple_test(void)
qdict_put_int(qdict, "num", 0);
qdict_put_str(qdict, "str", "foo");
- QDECREF(qdict);
+ qobject_unref(qdict);
}
static void qdict_get_test(void)
qn = qobject_to(QNum, obj);
g_assert_cmpint(qnum_get_int(qn), ==, value);
- QDECREF(tests_dict);
+ qobject_unref(tests_dict);
}
static void qdict_get_int_test(void)
ret = qdict_get_int(tests_dict, key);
g_assert(ret == value);
- QDECREF(tests_dict);
+ qobject_unref(tests_dict);
}
static void qdict_get_try_int_test(void)
ret = qdict_get_try_int(tests_dict, "string", -42);
g_assert_cmpuint(ret, ==, -42);
- QDECREF(tests_dict);
+ qobject_unref(tests_dict);
}
static void qdict_get_str_test(void)
g_assert(p != NULL);
g_assert(strcmp(p, str) == 0);
- QDECREF(tests_dict);
+ qobject_unref(tests_dict);
}
static void qdict_get_try_str_test(void)
g_assert(p != NULL);
g_assert(strcmp(p, str) == 0);
- QDECREF(tests_dict);
+ qobject_unref(tests_dict);
}
static void qdict_defaults_test(void)
qdict_copy_default(copy, dict, "bar");
g_assert_cmpstr(qdict_get_str(copy, "bar"), ==, "xyz");
- QDECREF(copy);
- QDECREF(dict);
+ qobject_unref(copy);
+ qobject_unref(dict);
}
static void qdict_haskey_not_test(void)
QDict *tests_dict = qdict_new();
g_assert(qdict_haskey(tests_dict, "test") == 0);
- QDECREF(tests_dict);
+ qobject_unref(tests_dict);
}
static void qdict_haskey_test(void)
qdict_put_int(tests_dict, key, 0);
g_assert(qdict_haskey(tests_dict, key) == 1);
- QDECREF(tests_dict);
+ qobject_unref(tests_dict);
}
static void qdict_del_test(void)
g_assert(qdict_size(tests_dict) == 0);
g_assert(qdict_haskey(tests_dict, key) == 0);
- QDECREF(tests_dict);
+ qobject_unref(tests_dict);
}
static void qobject_to_qdict_test(void)
QDict *tests_dict = qdict_new();
g_assert(qobject_to(QDict, QOBJECT(tests_dict)) == tests_dict);
- QDECREF(tests_dict);
+ qobject_unref(tests_dict);
}
static void qdict_iterapi_test(void)
g_assert(count == qdict_size(tests_dict));
- QDECREF(tests_dict);
+ qobject_unref(tests_dict);
}
static void qdict_flatten_test(void)
g_assert(qdict_size(dict3) == 8);
- QDECREF(dict3);
+ qobject_unref(dict3);
}
static void qdict_array_split_test(void)
g_assert(int1);
g_assert(qlist_empty(test_list));
- QDECREF(test_list);
+ qobject_unref(test_list);
g_assert(qdict_get_int(dict1, "a") == 42);
g_assert(qdict_get_int(dict1, "b") == 23);
g_assert(qdict_size(dict1) == 2);
- QDECREF(dict1);
+ qobject_unref(dict1);
g_assert(qdict_get_int(dict2, "x") == 0);
g_assert(qdict_size(dict2) == 1);
- QDECREF(dict2);
+ qobject_unref(dict2);
g_assert_cmpint(qnum_get_int(int1), ==, 66);
- QDECREF(int1);
+ qobject_unref(int1);
g_assert(qdict_get_int(test_dict, "4.y") == 1);
g_assert(qdict_get_int(test_dict, "o.o") == 7);
g_assert(qdict_size(test_dict) == 2);
- QDECREF(test_dict);
+ qobject_unref(test_dict);
/*
* Test the split of
g_assert(int1);
g_assert(qlist_empty(test_list));
- QDECREF(test_list);
+ qobject_unref(test_list);
g_assert_cmpint(qnum_get_int(int1), ==, 42);
- QDECREF(int1);
+ qobject_unref(int1);
g_assert(qdict_get_int(test_dict, "1") == 23);
g_assert(qdict_get_int(test_dict, "1.x") == 84);
g_assert(qdict_size(test_dict) == 2);
- QDECREF(test_dict);
+ qobject_unref(test_dict);
}
static void qdict_array_entries_test(void)
g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, 3);
g_assert_cmpint(qdict_array_entries(dict, ""), ==, -EINVAL);
- QDECREF(dict);
+ qobject_unref(dict);
dict = qdict_new();
qdict_put_int(dict, "1", 0);
qdict_put_int(dict, "2.c", 0);
g_assert_cmpint(qdict_array_entries(dict, ""), ==, 3);
- QDECREF(dict);
+ qobject_unref(dict);
}
static void qdict_join_test(void)
}
while (overwrite ^= true);
- QDECREF(dict1);
- QDECREF(dict2);
+ qobject_unref(dict1);
+ qobject_unref(dict2);
}
static void qdict_crumple_test_recursive(void)
g_assert_cmpint(qdict_size(rule), ==, 2);
g_assert_cmpstr("fred", ==, qdict_get_str(rule, "match"));
g_assert_cmpstr("allow", ==, qdict_get_str(rule, "policy"));
- QDECREF(rule);
+ qobject_unref(rule);
rule = qobject_to(QDict, qlist_pop(rules));
g_assert(rule);
g_assert_cmpint(qdict_size(rule), ==, 2);
g_assert_cmpstr("bob", ==, qdict_get_str(rule, "match"));
g_assert_cmpstr("deny", ==, qdict_get_str(rule, "policy"));
- QDECREF(rule);
+ qobject_unref(rule);
/* With recursive crumpling, we should see all names unescaped */
g_assert_cmpstr("acl0", ==, qdict_get_str(vnc, "acl.name"));
g_assert_cmpstr("acl0", ==, qdict_get_str(acl, "rule.name"));
- QDECREF(src);
- QDECREF(dst);
+ qobject_unref(src);
+ qobject_unref(dst);
}
static void qdict_crumple_test_empty(void)
g_assert_cmpint(qdict_size(dst), ==, 0);
- QDECREF(src);
- QDECREF(dst);
+ qobject_unref(src);
+ qobject_unref(dst);
}
static int qdict_count_entries(QDict *dict)
g_assert(qobject_type(qdict_get(copy, "nothing")) == QTYPE_QNULL);
g_assert_cmpint(qdict_count_entries(copy), ==, 5);
- QDECREF(copy);
+ qobject_unref(copy);
/* Simple rename of all entries */
renames = (QDictRenames[]) {
g_assert(qobject_type(qdict_get(copy, "null")) == QTYPE_QNULL);
g_assert_cmpint(qdict_count_entries(copy), ==, 5);
- QDECREF(copy);
+ qobject_unref(copy);
/* Renames are processed top to bottom */
renames = (QDictRenames[]) {
g_assert(!qdict_haskey(copy, "tmp"));
g_assert_cmpint(qdict_count_entries(copy), ==, 5);
- QDECREF(copy);
+ qobject_unref(copy);
/* Conflicting rename */
renames = (QDictRenames[]) {
g_assert(qobject_type(qdict_get(copy, "nothing")) == QTYPE_QNULL);
g_assert_cmpint(qdict_count_entries(copy), ==, 5);
- QDECREF(copy);
+ qobject_unref(copy);
/* Renames in an empty dict */
renames = (QDictRenames[]) {
{ NULL , NULL }
};
- QDECREF(dict);
+ qobject_unref(dict);
dict = qdict_new();
qdict_rename_keys(dict, renames, &error_abort);
g_assert(qdict_first(dict) == NULL);
- QDECREF(dict);
+ qobject_unref(dict);
}
static void qdict_crumple_test_bad_inputs(void)
g_assert(error != NULL);
error_free(error);
error = NULL;
- QDECREF(src);
+ qobject_unref(src);
src = qdict_new();
/* rule can't be both a list and a dict */
g_assert(error != NULL);
error_free(error);
error = NULL;
- QDECREF(src);
+ qobject_unref(src);
src = qdict_new();
/* The input should be flat, ie no dicts or lists */
g_assert(error != NULL);
error_free(error);
error = NULL;
- QDECREF(src);
+ qobject_unref(src);
src = qdict_new();
/* List indexes must not have gaps */
g_assert(error != NULL);
error_free(error);
error = NULL;
- QDECREF(src);
+ qobject_unref(src);
src = qdict_new();
/* List indexes must be in %zu format */
g_assert(error != NULL);
error_free(error);
error = NULL;
- QDECREF(src);
+ qobject_unref(src);
}
/*
g_assert(qdict_size(tests_dict) == 1);
- QDECREF(tests_dict);
+ qobject_unref(tests_dict);
}
static void qdict_get_not_exists_test(void)
QDict *tests_dict = qdict_new();
g_assert(qdict_get(tests_dict, "foo") == NULL);
- QDECREF(tests_dict);
+ qobject_unref(tests_dict);
}
/*
g_assert(strcmp(str1, str2) == 0);
- QDECREF(value);
+ qobject_unref(value);
}
// Delete everything
break;
qdict_del(qdict, key);
- QDECREF(value);
+ qobject_unref(value);
g_assert(qdict_haskey(qdict, key) == 0);
}
fclose(test_file);
g_assert(qdict_size(qdict) == 0);
- QDECREF(qdict);
+ qobject_unref(qdict);
}
int main(int argc, char **argv)
if (test_cases[i].skip == 0) {
str = qobject_to_json(obj);
g_assert_cmpstr(qstring_get_str(str), ==, test_cases[i].encoded);
- qobject_decref(obj);
+ qobject_unref(obj);
}
- QDECREF(str);
+ qobject_unref(str);
}
}
str = qobject_to_json(obj);
g_assert(strcmp(qstring_get_str(str), test_cases[i].encoded) == 0);
- qobject_decref(obj);
+ qobject_unref(obj);
- QDECREF(str);
+ qobject_unref(str);
}
}
g_assert(str);
g_assert(strcmp(qstring_get_str(str), test_cases[i].decoded) == 0);
- QDECREF(str);
+ qobject_unref(str);
}
}
} else {
g_assert(!obj);
}
- qobject_decref(obj);
+ qobject_unref(obj);
obj = QOBJECT(qstring_from_str(utf8_in));
str = qobject_to_json(obj);
} else {
g_assert(!str);
}
- QDECREF(str);
- qobject_decref(obj);
+ qobject_unref(str);
+ qobject_unref(obj);
/*
* Disabled, because qobject_from_json() is buggy, and I can't
g_assert(str);
g_assert(strcmp(qstring_get_str(str), test_cases[i].decoded) == 0);
- QDECREF(str);
+ qobject_unref(str);
}
}
str = qobject_to_json(QOBJECT(qnum));
g_assert(strcmp(qstring_get_str(str), test_cases[i].encoded) == 0);
- QDECREF(str);
+ qobject_unref(str);
}
- QDECREF(qnum);
+ qobject_unref(qnum);
}
}
str = qobject_to_json(QOBJECT(qnum));
g_assert_cmpstr(qstring_get_str(str), ==, maxu64);
- QDECREF(str);
- QDECREF(qnum);
+ qobject_unref(str);
+ qobject_unref(qnum);
qnum = qobject_to(QNum, qobject_from_json(gtu64, &error_abort));
g_assert(qnum);
str = qobject_to_json(QOBJECT(qnum));
g_assert_cmpstr(qstring_get_str(str), ==, gtu64);
- QDECREF(str);
- QDECREF(qnum);
+ qobject_unref(str);
+ qobject_unref(qnum);
qnum = qobject_to(QNum, qobject_from_json(lti64, &error_abort));
g_assert(qnum);
str = qobject_to_json(QOBJECT(qnum));
g_assert_cmpstr(qstring_get_str(str), ==, "-9223372036854775808");
- QDECREF(str);
- QDECREF(qnum);
+ qobject_unref(str);
+ qobject_unref(qnum);
}
static void float_number(void)
str = qobject_to_json(obj);
g_assert(strcmp(qstring_get_str(str), test_cases[i].encoded) == 0);
- QDECREF(str);
+ qobject_unref(str);
}
- QDECREF(qnum);
+ qobject_unref(qnum);
}
}
qnum = qobject_to(QNum, qobject_from_jsonf("%d", value));
g_assert(qnum_get_try_int(qnum, &val));
g_assert_cmpint(val, ==, value);
- QDECREF(qnum);
+ qobject_unref(qnum);
qnum = qobject_to(QNum, qobject_from_jsonf("%lld", value_ll));
g_assert(qnum_get_try_int(qnum, &val));
g_assert_cmpint(val, ==, value_ll);
- QDECREF(qnum);
+ qobject_unref(qnum);
qnum = qobject_to(QNum, qobject_from_jsonf("%f", valuef));
g_assert(qnum_get_double(qnum) == valuef);
- QDECREF(qnum);
+ qobject_unref(qnum);
}
static void keyword_literal(void)
str = qobject_to_json(obj);
g_assert(strcmp(qstring_get_str(str), "true") == 0);
- QDECREF(str);
+ qobject_unref(str);
- QDECREF(qbool);
+ qobject_unref(qbool);
obj = qobject_from_json("false", &error_abort);
qbool = qobject_to(QBool, obj);
str = qobject_to_json(obj);
g_assert(strcmp(qstring_get_str(str), "false") == 0);
- QDECREF(str);
+ qobject_unref(str);
- QDECREF(qbool);
+ qobject_unref(qbool);
qbool = qobject_to(QBool, qobject_from_jsonf("%i", false));
g_assert(qbool);
g_assert(qbool_get_bool(qbool) == false);
- QDECREF(qbool);
+ qobject_unref(qbool);
/* Test that non-zero values other than 1 get collapsed to true */
qbool = qobject_to(QBool, qobject_from_jsonf("%i", 2));
g_assert(qbool);
g_assert(qbool_get_bool(qbool) == true);
- QDECREF(qbool);
+ qobject_unref(qbool);
obj = qobject_from_json("null", &error_abort);
g_assert(obj != NULL);
null = qnull();
g_assert(QOBJECT(null) == obj);
- qobject_decref(obj);
- QDECREF(null);
+ qobject_unref(obj);
+ qobject_unref(null);
}
static void simple_dict(void)
g_assert(qlit_equal_qobject(&test_cases[i].decoded, obj));
str = qobject_to_json(obj);
- qobject_decref(obj);
+ qobject_unref(obj);
obj = qobject_from_json(qstring_get_str(str), &error_abort);
g_assert(qlit_equal_qobject(&test_cases[i].decoded, obj));
- qobject_decref(obj);
- QDECREF(str);
+ qobject_unref(obj);
+ qobject_unref(str);
}
}
obj = qobject_from_json(gstr->str, &error_abort);
g_assert(obj != NULL);
- qobject_decref(obj);
+ qobject_unref(obj);
g_string_free(gstr, true);
}
g_assert(qlit_equal_qobject(&test_cases[i].decoded, obj));
str = qobject_to_json(obj);
- qobject_decref(obj);
+ qobject_unref(obj);
obj = qobject_from_json(qstring_get_str(str), &error_abort);
g_assert(qlit_equal_qobject(&test_cases[i].decoded, obj));
- qobject_decref(obj);
- QDECREF(str);
+ qobject_unref(obj);
+ qobject_unref(str);
}
}
g_assert(qlit_equal_qobject(&test_cases[i].decoded, obj));
str = qobject_to_json(obj);
- qobject_decref(obj);
+ qobject_unref(obj);
obj = qobject_from_json(qstring_get_str(str), &error_abort);
g_assert(qlit_equal_qobject(&test_cases[i].decoded, obj));
- qobject_decref(obj);
- QDECREF(str);
+ qobject_unref(obj);
+ qobject_unref(str);
}
}
obj = qobject_from_jsonf("[%d, 2, %p]", 1, embedded_obj);
g_assert(qlit_equal_qobject(&decoded, obj));
- qobject_decref(obj);
+ qobject_unref(obj);
}
static void empty_input(void)
obj = qobject_from_json(make_nest(buf, max_nesting), &error_abort);
g_assert(obj != NULL);
- qobject_decref(obj);
+ qobject_unref(obj);
obj = qobject_from_json(make_nest(buf, max_nesting + 1), &err);
error_free_or_abort(&err);
g_assert(qlist->base.refcnt == 1);
g_assert(qobject_type(QOBJECT(qlist)) == QTYPE_QLIST);
- QDECREF(qlist);
+ qobject_unref(qlist);
}
static void qlist_append_test(void)
g_assert(entry != NULL);
g_assert(entry->value == QOBJECT(qi));
- QDECREF(qlist);
+ qobject_unref(qlist);
}
static void qobject_to_qlist_test(void)
g_assert(qobject_to(QList, QOBJECT(qlist)) == qlist);
- QDECREF(qlist);
+ qobject_unref(qlist);
}
static int iter_called;
g_assert(iter_called == iter_max);
- QDECREF(qlist);
+ qobject_unref(qlist);
}
int main(int argc, char **argv)
qdict_put(qobject_to(QDict, qobj), "bee", qlist_new());
g_assert(!qlit_equal_qobject(&qlit, qobj));
- qobject_decref(qobj);
+ qobject_unref(qobj);
}
static void qobject_from_qlit_test(void)
bee = qdict_get_qlist(qdict, "bee");
obj = qlist_pop(bee);
g_assert_cmpint(qnum_get_int(qobject_to(QNum, obj)), ==, 43);
- qobject_decref(obj);
+ qobject_unref(obj);
obj = qlist_pop(bee);
g_assert_cmpint(qnum_get_int(qobject_to(QNum, obj)), ==, 44);
- qobject_decref(obj);
+ qobject_unref(obj);
obj = qlist_pop(bee);
g_assert(qbool_get_bool(qobject_to(QBool, obj)));
- qobject_decref(obj);
+ qobject_unref(obj);
- qobject_decref(qobj);
+ qobject_unref(qobj);
}
int main(int argc, char **argv)
g_assert(obj == QOBJECT(&qnull_));
g_assert(qnull_.base.refcnt == 2);
g_assert(qobject_type(obj) == QTYPE_QNULL);
- qobject_decref(obj);
+ qobject_unref(obj);
g_assert(qnull_.base.refcnt == 1);
}
g_assert(qnull_.base.refcnt == 1);
obj = QOBJECT(qnull());
v = qobject_input_visitor_new(obj);
- qobject_decref(obj);
+ qobject_unref(obj);
visit_type_null(v, NULL, &null, &error_abort);
g_assert(obj == QOBJECT(&qnull_));
- QDECREF(null);
+ qobject_unref(null);
visit_free(v);
null = NULL;
visit_type_null(v, NULL, &null, &error_abort);
visit_complete(v, &obj);
g_assert(obj == QOBJECT(&qnull_));
- QDECREF(null);
- qobject_decref(obj);
+ qobject_unref(null);
+ qobject_unref(obj);
visit_free(v);
g_assert(qnull_.base.refcnt == 1);
g_assert_cmpint(qn->base.refcnt, ==, 1);
g_assert_cmpint(qobject_type(QOBJECT(qn)), ==, QTYPE_QNUM);
- QDECREF(qn);
+ qobject_unref(qn);
}
static void qnum_from_uint_test(void)
g_assert(qn->base.refcnt == 1);
g_assert(qobject_type(QOBJECT(qn)) == QTYPE_QNUM);
- QDECREF(qn);
+ qobject_unref(qn);
}
static void qnum_from_double_test(void)
g_assert_cmpint(qn->base.refcnt, ==, 1);
g_assert_cmpint(qobject_type(QOBJECT(qn)), ==, QTYPE_QNUM);
- QDECREF(qn);
+ qobject_unref(qn);
}
static void qnum_from_int64_test(void)
qn = qnum_from_int(value);
g_assert_cmpint((int64_t) qn->u.i64, ==, value);
- QDECREF(qn);
+ qobject_unref(qn);
}
static void qnum_get_int_test(void)
qn = qnum_from_int(value);
g_assert_cmpint(qnum_get_int(qn), ==, value);
- QDECREF(qn);
+ qobject_unref(qn);
}
static void qnum_get_uint_test(void)
qn = qnum_from_uint(value);
g_assert(qnum_get_try_uint(qn, &val));
g_assert_cmpuint(val, ==, value);
- QDECREF(qn);
+ qobject_unref(qn);
qn = qnum_from_int(value);
g_assert(qnum_get_try_uint(qn, &val));
g_assert_cmpuint(val, ==, value);
- QDECREF(qn);
+ qobject_unref(qn);
/* invalid cases */
qn = qnum_from_int(-1);
g_assert(!qnum_get_try_uint(qn, &val));
- QDECREF(qn);
+ qobject_unref(qn);
qn = qnum_from_uint(-1ULL);
g_assert(!qnum_get_try_int(qn, &ival));
- QDECREF(qn);
+ qobject_unref(qn);
qn = qnum_from_double(0.42);
g_assert(!qnum_get_try_uint(qn, &val));
- QDECREF(qn);
+ qobject_unref(qn);
}
static void qobject_to_qnum_test(void)
qn = qnum_from_int(0);
g_assert(qobject_to(QNum, QOBJECT(qn)) == qn);
- QDECREF(qn);
+ qobject_unref(qn);
qn = qnum_from_double(0);
g_assert(qobject_to(QNum, QOBJECT(qn)) == qn);
- QDECREF(qn);
+ qobject_unref(qn);
}
static void qnum_to_string_test(void)
tmp = qnum_to_string(qn);
g_assert_cmpstr(tmp, ==, "123456");
g_free(tmp);
- QDECREF(qn);
+ qobject_unref(qn);
qn = qnum_from_double(0.42);
tmp = qnum_to_string(qn);
g_assert_cmpstr(tmp, ==, "0.42");
g_free(tmp);
- QDECREF(qn);
+ qobject_unref(qn);
}
int main(int argc, char **argv)
va_start(ap, _);
while ((obj = va_arg(ap, QObject *)) != NULL) {
- qobject_decref(obj);
+ qobject_unref(obj);
}
va_end(ap);
}
g_assert(strcmp(str, qstring->string) == 0);
g_assert(qobject_type(QOBJECT(qstring)) == QTYPE_QSTRING);
- QDECREF(qstring);
+ qobject_unref(qstring);
}
static void qstring_get_str_test(void)
ret_str = qstring_get_str(qstring);
g_assert(strcmp(ret_str, str) == 0);
- QDECREF(qstring);
+ qobject_unref(qstring);
}
static void qstring_append_chr_test(void)
qstring_append_chr(qstring, str[i]);
g_assert(strcmp(str, qstring_get_str(qstring)) == 0);
- QDECREF(qstring);
+ qobject_unref(qstring);
}
static void qstring_from_substr_test(void)
g_assert(qs != NULL);
g_assert(strcmp(qstring_get_str(qs), "tualiza") == 0);
- QDECREF(qs);
+ qobject_unref(qs);
}
qstring = qstring_from_str("foo");
g_assert(qobject_to(QString, QOBJECT(qstring)) == qstring);
- QDECREF(qstring);
+ qobject_unref(qstring);
}
int main(int argc, char **argv)
" 'arguments': { 'id': %d } }", i);
g_assert(response);
g_assert(!qdict_haskey(response, "error"));
- QDECREF(response);
+ qobject_unref(response);
}
qtest_end();
s->sockets * s->cores * s->threads);
g_assert(response);
g_assert(qdict_haskey(response, "error"));
- QDECREF(response);
+ qobject_unref(response);
qtest_end();
g_free(args);
" 'arguments': %p }", args);
g_assert(qdict_haskey(resp, "return"));
ret = qdict_get_qlist(resp, "return");
- QINCREF(ret);
- QDECREF(resp);
+ qobject_ref(ret);
+ qobject_unref(resp);
return ret;
}
QLIST_FOREACH_ENTRY(types, e) {
QDict *d = qobject_to(QDict, qlist_entry_obj(e));
const char *name = qdict_get_str(d, "name");
- QINCREF(d);
+ qobject_ref(d);
qdict_put(index, name, d);
}
return index;
resp = qmp("{'execute': 'device-list-properties',"
" 'arguments': {'typename': %s}}",
type);
- QDECREF(resp);
+ qobject_unref(resp);
help = hmp("device_add \"%s,help\"", type);
g_free(help);
qtest_start(common_args);
types = device_type_list(true);
- QDECREF(types);
+ qobject_unref(types);
help = hmp("device_add help");
g_free(help);
g_assert(qom_has_parent(index, name, parent));
}
- QDECREF(types);
- QDECREF(index);
+ qobject_unref(types);
+ qobject_unref(index);
}
static void test_qom_list_fields(void)
test_qom_list_parents("device");
test_qom_list_parents("sys-bus-device");
- QDECREF(all_types);
- QDECREF(non_abstract);
+ qobject_unref(all_types);
+ qobject_unref(non_abstract);
qtest_end();
}
test_one_device(type);
}
- QDECREF(types);
+ qobject_unref(types);
qtest_end();
}
g_assert(qdict_haskey(d, "abstract") && qdict_get_bool(d, "abstract"));
}
- QDECREF(all_types);
- QDECREF(index);
+ qobject_unref(all_types);
+ qobject_unref(index);
qtest_end();
}
response = qmp_receive();
g_assert(response);
g_assert(qdict_haskey(response, "return"));
- QDECREF(response);
+ qobject_unref(response);
}
static void test_drive_without_dev(void)
g_assert(response);
error = qdict_get_qdict(response, "error");
g_assert_cmpstr(qdict_get_try_str(error, "class"), ==, "GenericError");
- QDECREF(response);
+ qobject_unref(response);
/* Delete the drive */
drive_del();
sub = qdict_get_qdict(rsp, "return");
g_assert(qdict_haskey(sub, "running"));
running = qdict_get_bool(sub, "running");
- QDECREF(rsp);
+ qobject_unref(rsp);
/* Issue the migrate command. */
rsp = qtest_qmp(from->qts,
"{ 'execute': 'migrate', 'arguments': { 'uri': %s }}",
uri);
g_assert(qdict_haskey(rsp, "return"));
- QDECREF(rsp);
+ qobject_unref(rsp);
/* Wait for STOP event, but only if we were running: */
if (running) {
/* "setup", "active", "completed", "failed", "cancelled" */
if (strcmp(st, "completed") == 0) {
- QDECREF(rsp);
+ qobject_unref(rsp);
break;
}
if ((strcmp(st, "setup") == 0) || (strcmp(st, "active") == 0)) {
- QDECREF(rsp);
+ qobject_unref(rsp);
g_usleep(5000);
continue;
}
g_free(cmd);
g_assert(response);
g_assert(!qdict_haskey(response, "error"));
- QDECREF(response);
+ qobject_unref(response);
outb(ACPI_PCIHP_ADDR + PCI_EJ_BASE, 1 << slot);
/* Send QMP request */
socket_send(fd, str, qstring_get_length(qstr));
- QDECREF(qstr);
- qobject_decref(qobj);
+ qobject_unref(qstr);
+ qobject_unref(qobj);
}
}
void qtest_qmpv_discard_response(QTestState *s, const char *fmt, va_list ap)
{
QDict *response = qtest_qmpv(s, fmt, ap);
- QDECREF(response);
+ qobject_unref(response);
}
void qtest_qmp_discard_response(QTestState *s, const char *fmt, ...)
va_start(ap, fmt);
response = qtest_qmpv(s, fmt, ap);
va_end(ap);
- QDECREF(response);
+ qobject_unref(response);
}
QDict *qtest_qmp_eventwait_ref(QTestState *s, const char *event)
(strcmp(qdict_get_str(response, "event"), event) == 0)) {
return response;
}
- QDECREF(response);
+ qobject_unref(response);
}
}
QDict *response;
response = qtest_qmp_eventwait_ref(s, event);
- QDECREF(response);
+ qobject_unref(response);
}
char *qtest_hmpv(QTestState *s, const char *fmt, va_list ap)
ret = g_strdup(qdict_get_try_str(resp, "return"));
while (ret == NULL && qdict_get_try_str(resp, "event")) {
/* Ignore asynchronous QMP events */
- QDECREF(resp);
+ qobject_unref(resp);
resp = qtest_qmp_receive(s);
ret = g_strdup(qdict_get_try_str(resp, "return"));
}
g_assert(ret);
- QDECREF(resp);
+ qobject_unref(resp);
g_free(cmd);
return ret;
}
}
qtest_end();
- QDECREF(response);
+ qobject_unref(response);
}
/*
g_assert(response);
g_assert(!qdict_haskey(response, "event")); /* We don't expect any events */
g_assert(!qdict_haskey(response, "error"));
- QDECREF(response);
+ qobject_unref(response);
}
/*
g_assert(event);
g_assert_cmpstr(qdict_get_str(event, "event"), ==, "DEVICE_DELETED");
- QDECREF(response1);
- QDECREF(response2);
+ qobject_unref(response1);
+ qobject_unref(response2);
}
response = qmp("{ 'execute': 'quit' }");
g_assert(qdict_haskey(response, "return"));
- QDECREF(response);
+ qobject_unref(response);
qtest_quit(global_qtest);
}
if (!strcmp(event_string, "STOP")) {
got_stop = true;
}
- QDECREF(response);
+ qobject_unref(response);
response = qtest_qmp_receive(who);
}
return response;
rsp_ram = qdict_get_qdict(rsp_return, "ram");
result = qdict_get_try_int(rsp_ram, "dirty-sync-count", 0);
}
- QDECREF(rsp);
+ qobject_unref(rsp);
return result;
}
rsp = wait_command(who, "{ 'execute': 'query-migrate' }");
rsp_return = qdict_get_qdict(rsp, "return");
g_assert(qdict_haskey(rsp_return, "postcopy-blocktime"));
- QDECREF(rsp);
+ qobject_unref(rsp);
}
static void wait_for_migration_complete(QTestState *who)
status = qdict_get_str(rsp_return, "status");
completed = strcmp(status, "completed") == 0;
g_assert_cmpstr(status, !=, "failed");
- QDECREF(rsp);
+ qobject_unref(rsp);
if (completed) {
return;
}
qdict_get_try_int(rsp_return, parameter, -1));
g_assert_cmpstr(result, ==, value);
g_free(result);
- QDECREF(rsp);
+ qobject_unref(rsp);
}
static void migrate_set_parameter(QTestState *who, const char *parameter,
rsp = qtest_qmp(who, cmd);
g_free(cmd);
g_assert(qdict_haskey(rsp, "return"));
- QDECREF(rsp);
+ qobject_unref(rsp);
migrate_check_parameter(who, parameter, value);
}
rsp = qtest_qmp(who, cmd);
g_free(cmd);
g_assert(qdict_haskey(rsp, "return"));
- QDECREF(rsp);
+ qobject_unref(rsp);
}
static void migrate(QTestState *who, const char *uri)
rsp = qtest_qmp(who, cmd);
g_free(cmd);
g_assert(qdict_haskey(rsp, "return"));
- QDECREF(rsp);
+ qobject_unref(rsp);
}
static void migrate_start_postcopy(QTestState *who)
rsp = wait_command(who, "{ 'execute': 'migrate-start-postcopy' }");
g_assert(qdict_haskey(rsp, "return"));
- QDECREF(rsp);
+ qobject_unref(rsp);
}
static void test_migrate_start(QTestState **from, QTestState **to,
rsp = qtest_qmp(who, cmd);
g_free(cmd);
g_assert(qdict_haskey(rsp, "return"));
- QDECREF(rsp);
+ qobject_unref(rsp);
result_int = value * 1000L;
expected = g_strdup_printf("%" PRId64, result_int);
migrate_check_parameter(who, "downtime-limit", expected);
rsp = qtest_qmp(who, cmd);
g_free(cmd);
g_assert(qdict_haskey(rsp, "return"));
- QDECREF(rsp);
+ qobject_unref(rsp);
migrate_check_parameter(who, "max-bandwidth", value);
}
g_assert(!strcmp(status, "setup") || !(strcmp(status, "failed")));
failed = !strcmp(status, "failed");
- QDECREF(rsp);
+ qobject_unref(rsp);
} while (!failed);
/* Is the machine currently running? */
rsp_return = qdict_get_qdict(rsp, "return");
g_assert(qdict_haskey(rsp_return, "running"));
g_assert(qdict_get_bool(rsp_return, "running"));
- QDECREF(rsp);
+ qobject_unref(rsp);
test_migrate_end(from, to, false);
}
} else {
g_assert_cmpint(node, ==, 1);
}
- qobject_decref(e);
+ qobject_unref(e);
}
- QDECREF(resp);
+ qobject_unref(resp);
qtest_end();
g_free(cli);
}
} else {
g_assert(false);
}
- qobject_decref(e);
+ qobject_unref(e);
}
- QDECREF(resp);
+ qobject_unref(resp);
qtest_end();
g_free(cli);
}
} else {
g_assert(false);
}
- qobject_decref(e);
+ qobject_unref(e);
}
- QDECREF(resp);
+ qobject_unref(resp);
qtest_end();
g_free(cli);
}
} else {
g_assert(false);
}
- qobject_decref(e);
+ qobject_unref(e);
}
- QDECREF(resp);
+ qobject_unref(resp);
qtest_end();
g_free(cli);
}
data = qdict_get_qdict(response, "data");
g_assert(qdict_haskey(data, "action"));
g_assert_cmpstr(qdict_get_str(data, "action"), ==, "pause");
- QDECREF(response);
+ qobject_unref(response);
}
int main(int argc, char **argv)
response = qmp("{'execute': 'system_reset', 'arguments': {} }");
g_assert(response);
g_assert(!qdict_haskey(response, "error"));
- QDECREF(response);
+ qobject_unref(response);
/* check open is settable again */
smram_set_bit(pcidev, MCH_HOST_BRIDGE_SMRAM_D_OPEN, false);
/* Not even a dictionary */
resp = qtest_qmp(qts, "null");
g_assert_cmpstr(get_error_class(resp), ==, "GenericError");
- QDECREF(resp);
+ qobject_unref(resp);
/* No "execute" key */
resp = qtest_qmp(qts, "{}");
g_assert_cmpstr(get_error_class(resp), ==, "GenericError");
- QDECREF(resp);
+ qobject_unref(resp);
/* "execute" isn't a string */
resp = qtest_qmp(qts, "{ 'execute': true }");
g_assert_cmpstr(get_error_class(resp), ==, "GenericError");
- QDECREF(resp);
+ qobject_unref(resp);
/* "arguments" isn't a dictionary */
resp = qtest_qmp(qts, "{ 'execute': 'no-such-cmd', 'arguments': [] }");
g_assert_cmpstr(get_error_class(resp), ==, "GenericError");
- QDECREF(resp);
+ qobject_unref(resp);
/* extra key */
resp = qtest_qmp(qts, "{ 'execute': 'no-such-cmd', 'extra': true }");
g_assert_cmpstr(get_error_class(resp), ==, "GenericError");
- QDECREF(resp);
+ qobject_unref(resp);
}
static void test_qmp_protocol(void)
test_version(qdict_get(q, "version"));
capabilities = qdict_get_qlist(q, "capabilities");
g_assert(capabilities && qlist_empty(capabilities));
- QDECREF(resp);
+ qobject_unref(resp);
/* Test valid command before handshake */
resp = qtest_qmp(qts, "{ 'execute': 'query-version' }");
g_assert_cmpstr(get_error_class(resp), ==, "CommandNotFound");
- QDECREF(resp);
+ qobject_unref(resp);
/* Test malformed commands before handshake */
test_malformed(qts);
resp = qtest_qmp(qts, "{ 'execute': 'qmp_capabilities' }");
ret = qdict_get_qdict(resp, "return");
g_assert(ret && !qdict_size(ret));
- QDECREF(resp);
+ qobject_unref(resp);
/* Test repeated handshake */
resp = qtest_qmp(qts, "{ 'execute': 'qmp_capabilities' }");
g_assert_cmpstr(get_error_class(resp), ==, "CommandNotFound");
- QDECREF(resp);
+ qobject_unref(resp);
/* Test valid command */
resp = qtest_qmp(qts, "{ 'execute': 'query-version' }");
test_version(qdict_get(resp, "return"));
- QDECREF(resp);
+ qobject_unref(resp);
/* Test malformed commands */
test_malformed(qts);
ret = qdict_get_qdict(resp, "return");
g_assert(ret);
g_assert_cmpstr(qdict_get_try_str(resp, "id"), ==, "cookie#1");
- QDECREF(resp);
+ qobject_unref(resp);
/* Test command failure with 'id' */
resp = qtest_qmp(qts, "{ 'execute': 'human-monitor-command', 'id': 2 }");
g_assert_cmpstr(get_error_class(resp), ==, "GenericError");
g_assert_cmpint(qdict_get_int(resp, "id"), ==, 2);
- QDECREF(resp);
+ qobject_unref(resp);
qtest_quit(qts);
}
qstr = qobject_to(QString, entry->value);
g_assert(qstr);
g_assert_cmpstr(qstring_get_str(qstr), ==, "oob");
- QDECREF(resp);
+ qobject_unref(resp);
/* Try a fake capability, it should fail. */
resp = qtest_qmp(qts,
"{ 'execute': 'qmp_capabilities', "
" 'arguments': { 'enable': [ 'cap-does-not-exist' ] } }");
g_assert(qdict_haskey(resp, "error"));
- QDECREF(resp);
+ qobject_unref(resp);
/* Now, enable OOB in current QMP session, it should succeed. */
resp = qtest_qmp(qts,
"{ 'execute': 'qmp_capabilities', "
" 'arguments': { 'enable': [ 'oob' ] } }");
g_assert(qdict_haskey(resp, "return"));
- QDECREF(resp);
+ qobject_unref(resp);
/*
* Try any command that does not support OOB but with OOB flag. We
"{ 'execute': 'query-cpus',"
" 'control': { 'run-oob': true } }");
g_assert(qdict_haskey(resp, "error"));
- QDECREF(resp);
+ qobject_unref(resp);
/*
* First send the "x-oob-test" command with lock=true and
!g_strcmp0(cmd_id, "unlock-cmd")) {
acks++;
}
- QDECREF(resp);
+ qobject_unref(resp);
}
qtest_quit(qts);
-1, &error_abort),
==, expected_error_class);
}
- QDECREF(resp);
+ qobject_unref(resp);
qtest_end();
}
visit_type_SchemaInfoList(qiv, NULL, &schema->list, &error_abort);
visit_free(qiv);
- QDECREF(resp);
+ qobject_unref(resp);
qtest_end();
schema->hash = g_hash_table_new(g_str_hash, g_str_equal);
g_assert(response);
if (!recurse) {
- QDECREF(response);
+ qobject_unref(response);
return;
}
path, prop);
/* qom-get may fail but should not, e.g., segfault. */
g_assert(tmp);
- QDECREF(tmp);
+ qobject_unref(tmp);
}
}
- QDECREF(response);
+ qobject_unref(response);
}
static void test_machine(gconstpointer data)
response = qmp("{ 'execute': 'quit' }");
g_assert(qdict_haskey(response, "return"));
- QDECREF(response);
+ qobject_unref(response);
qtest_end();
g_free(args);
QDict *data;
data = qdict_get_qdict(ev, "data");
- QINCREF(data);
- QDECREF(ev);
+ qobject_ref(data);
+ qobject_unref(ev);
return data;
}
clock_step(ticks * TCO_TICK_NSEC * 2);
ad = get_watchdog_action();
g_assert(!strcmp(qdict_get_str(ad, "action"), "pause"));
- QDECREF(ad);
+ qobject_unref(ad);
stop_tco(&td);
test_end(&td);
clock_step(ticks * TCO_TICK_NSEC * 2);
ad = get_watchdog_action();
g_assert(!strcmp(qdict_get_str(ad, "action"), "reset"));
- QDECREF(ad);
+ qobject_unref(ad);
stop_tco(&td);
test_end(&td);
clock_step(ticks * TCO_TICK_NSEC * 2);
ad = get_watchdog_action();
g_assert(!strcmp(qdict_get_str(ad, "action"), "shutdown"));
- QDECREF(ad);
+ qobject_unref(ad);
stop_tco(&td);
test_end(&td);
clock_step(ticks * TCO_TICK_NSEC * 2);
ad = get_watchdog_action();
g_assert(!strcmp(qdict_get_str(ad, "action"), "none"));
- QDECREF(ad);
+ qobject_unref(ad);
stop_tco(&td);
test_end(&td);
qdict = qobject_to(QDict, addr);
port = qdict_get_str(qdict, "port");
tmp = g_strdup_printf("tcp:127.0.0.1:%s", port);
- QDECREF(qdict);
+ qobject_unref(qdict);
qemu_chr_fe_init(&be, chr, &error_abort);
qemu_chr_fe_set_handlers(&be, socket_can_read, socket_read,
/* Nothing */
qdict = keyval_parse("", NULL, &error_abort);
g_assert_cmpuint(qdict_size(qdict), ==, 0);
- QDECREF(qdict);
+ qobject_unref(qdict);
/* Empty key (qemu_opts_parse() accepts this) */
qdict = keyval_parse("=val", NULL, &err);
qdict = keyval_parse(params + 2, NULL, &error_abort);
g_assert_cmpuint(qdict_size(qdict), ==, 1);
g_assert_cmpstr(qdict_get_try_str(qdict, long_key + 1), ==, "v");
- QDECREF(qdict);
+ qobject_unref(qdict);
/* Long key fragment */
qdict = keyval_parse(params, NULL, &error_abort);
g_assert(sub_qdict);
g_assert_cmpuint(qdict_size(sub_qdict), ==, 1);
g_assert_cmpstr(qdict_get_try_str(sub_qdict, long_key + 1), ==, "v");
- QDECREF(qdict);
+ qobject_unref(qdict);
g_free(params);
/* Crap after valid key */
g_assert_cmpuint(qdict_size(qdict), ==, 2);
g_assert_cmpstr(qdict_get_try_str(qdict, "a"), ==, "3");
g_assert_cmpstr(qdict_get_try_str(qdict, "b"), ==, "2,x");
- QDECREF(qdict);
+ qobject_unref(qdict);
/* Even when it doesn't in qemu_opts_parse() */
qdict = keyval_parse("id=foo,id=bar", NULL, &error_abort);
g_assert_cmpuint(qdict_size(qdict), ==, 1);
g_assert_cmpstr(qdict_get_try_str(qdict, "id"), ==, "bar");
- QDECREF(qdict);
+ qobject_unref(qdict);
/* Dotted keys */
qdict = keyval_parse("a.b.c=1,a.b.c=2,d=3", NULL, &error_abort);
g_assert_cmpuint(qdict_size(sub_qdict), ==, 1);
g_assert_cmpstr(qdict_get_try_str(sub_qdict, "c"), ==, "2");
g_assert_cmpstr(qdict_get_try_str(qdict, "d"), ==, "3");
- QDECREF(qdict);
+ qobject_unref(qdict);
/* Inconsistent dotted keys */
qdict = keyval_parse("a.b=1,a=2", NULL, &err);
qdict = keyval_parse("x=y,", NULL, &error_abort);
g_assert_cmpuint(qdict_size(qdict), ==, 1);
g_assert_cmpstr(qdict_get_try_str(qdict, "x"), ==, "y");
- QDECREF(qdict);
+ qobject_unref(qdict);
/* Except when it isn't */
qdict = keyval_parse(",", NULL, &err);
qdict = keyval_parse("x=,,id=bar", NULL, &error_abort);
g_assert_cmpuint(qdict_size(qdict), ==, 1);
g_assert_cmpstr(qdict_get_try_str(qdict, "x"), ==, ",id=bar");
- QDECREF(qdict);
+ qobject_unref(qdict);
/* Anti-social ID is left to caller (qemu_opts_parse() rejects it) */
qdict = keyval_parse("id=666", NULL, &error_abort);
g_assert_cmpuint(qdict_size(qdict), ==, 1);
g_assert_cmpstr(qdict_get_try_str(qdict, "id"), ==, "666");
- QDECREF(qdict);
+ qobject_unref(qdict);
/* Implied value not supported (unlike qemu_opts_parse()) */
qdict = keyval_parse("an,noaus,noaus=", NULL, &err);
g_assert_cmpstr(qdict_get_try_str(qdict, "implied"), ==, "an");
g_assert_cmpstr(qdict_get_try_str(qdict, "aus"), ==, "off");
g_assert_cmpstr(qdict_get_try_str(qdict, "noaus"), ==, "");
- QDECREF(qdict);
+ qobject_unref(qdict);
/* Implied dotted key */
qdict = keyval_parse("val", "eins.zwei", &error_abort);
g_assert(sub_qdict);
g_assert_cmpuint(qdict_size(sub_qdict), ==, 1);
g_assert_cmpstr(qdict_get_try_str(sub_qdict, "zwei"), ==, "val");
- QDECREF(qdict);
+ qobject_unref(qdict);
/* Implied key with empty value (qemu_opts_parse() accepts this) */
qdict = keyval_parse(",", "implied", &err);
qstr = qobject_to(QString, qlist_pop(qlist));
g_assert(qstr);
g_assert_cmpstr(qstring_get_str(qstr), ==, expected[i]);
- QDECREF(qstr);
+ qobject_unref(qstr);
}
g_assert(qlist_empty(qlist));
}
NULL, &error_abort);
g_assert_cmpint(qdict_size(qdict), ==, 1);
check_list012(qdict_get_qlist(qdict, "list"));
- QDECREF(qdict);
+ qobject_unref(qdict);
/* Multiple indexes, last one wins */
qdict = keyval_parse("list.1=goner,list.0=null,list.01=eins,list.2=zwei",
NULL, &error_abort);
g_assert_cmpint(qdict_size(qdict), ==, 1);
check_list012(qdict_get_qlist(qdict, "list"));
- QDECREF(qdict);
+ qobject_unref(qdict);
/* List at deeper nesting */
qdict = keyval_parse("a.list.1=eins,a.list.00=null,a.list.2=zwei",
sub_qdict = qdict_get_qdict(qdict, "a");
g_assert_cmpint(qdict_size(sub_qdict), ==, 1);
check_list012(qdict_get_qlist(sub_qdict, "list"));
- QDECREF(qdict);
+ qobject_unref(qdict);
/* Inconsistent dotted keys: both list and dictionary */
qdict = keyval_parse("a.b.c=1,a.b.0=2", NULL, &err);
qdict = keyval_parse("bool1=on,bool2=off", NULL, &error_abort);
v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
- QDECREF(qdict);
+ qobject_unref(qdict);
visit_start_struct(v, NULL, NULL, 0, &error_abort);
visit_type_bool(v, "bool1", &b, &error_abort);
g_assert(b);
qdict = keyval_parse("bool1=offer", NULL, &error_abort);
v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
- QDECREF(qdict);
+ qobject_unref(qdict);
visit_start_struct(v, NULL, NULL, 0, &error_abort);
visit_type_bool(v, "bool1", &b, &err);
error_free_or_abort(&err);
/* Lower limit zero */
qdict = keyval_parse("number1=0", NULL, &error_abort);
v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
- QDECREF(qdict);
+ qobject_unref(qdict);
visit_start_struct(v, NULL, NULL, 0, &error_abort);
visit_type_uint64(v, "number1", &u, &error_abort);
g_assert_cmpuint(u, ==, 0);
qdict = keyval_parse("number1=18446744073709551615,number2=-1",
NULL, &error_abort);
v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
- QDECREF(qdict);
+ qobject_unref(qdict);
visit_start_struct(v, NULL, NULL, 0, &error_abort);
visit_type_uint64(v, "number1", &u, &error_abort);
g_assert_cmphex(u, ==, UINT64_MAX);
qdict = keyval_parse("number1=18446744073709551616",
NULL, &error_abort);
v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
- QDECREF(qdict);
+ qobject_unref(qdict);
visit_start_struct(v, NULL, NULL, 0, &error_abort);
visit_type_uint64(v, "number1", &u, &err);
error_free_or_abort(&err);
qdict = keyval_parse("number1=-18446744073709551616",
NULL, &error_abort);
v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
- QDECREF(qdict);
+ qobject_unref(qdict);
visit_start_struct(v, NULL, NULL, 0, &error_abort);
visit_type_uint64(v, "number1", &u, &err);
error_free_or_abort(&err);
qdict = keyval_parse("number1=0x2a,number2=052",
NULL, &error_abort);
v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
- QDECREF(qdict);
+ qobject_unref(qdict);
visit_start_struct(v, NULL, NULL, 0, &error_abort);
visit_type_uint64(v, "number1", &u, &error_abort);
g_assert_cmpuint(u, ==, 42);
qdict = keyval_parse("number1=3.14,number2=08",
NULL, &error_abort);
v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
- QDECREF(qdict);
+ qobject_unref(qdict);
visit_start_struct(v, NULL, NULL, 0, &error_abort);
visit_type_uint64(v, "number1", &u, &err);
error_free_or_abort(&err);
/* Lower limit zero */
qdict = keyval_parse("sz1=0", NULL, &error_abort);
v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
- QDECREF(qdict);
+ qobject_unref(qdict);
visit_start_struct(v, NULL, NULL, 0, &error_abort);
visit_type_size(v, "sz1", &sz, &error_abort);
g_assert_cmpuint(sz, ==, 0);
"sz3=9007199254740993",
NULL, &error_abort);
v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
- QDECREF(qdict);
+ qobject_unref(qdict);
visit_start_struct(v, NULL, NULL, 0, &error_abort);
visit_type_size(v, "sz1", &sz, &error_abort);
g_assert_cmphex(sz, ==, 0x1fffffffffffff);
"sz2=9223372036854775295", /* 7ffffffffffffdff */
NULL, &error_abort);
v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
- QDECREF(qdict);
+ qobject_unref(qdict);
visit_start_struct(v, NULL, NULL, 0, &error_abort);
visit_type_size(v, "sz1", &sz, &error_abort);
g_assert_cmphex(sz, ==, 0x7ffffffffffffc00);
"sz2=18446744073709550591", /* fffffffffffffbff */
NULL, &error_abort);
v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
- QDECREF(qdict);
+ qobject_unref(qdict);
visit_start_struct(v, NULL, NULL, 0, &error_abort);
visit_type_size(v, "sz1", &sz, &error_abort);
g_assert_cmphex(sz, ==, 0xfffffffffffff800);
"sz2=18446744073709550592", /* fffffffffffffc00 */
NULL, &error_abort);
v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
- QDECREF(qdict);
+ qobject_unref(qdict);
visit_start_struct(v, NULL, NULL, 0, &error_abort);
visit_type_size(v, "sz1", &sz, &err);
error_free_or_abort(&err);
qdict = keyval_parse("sz1=8b,sz2=1.5k,sz3=2M,sz4=0.1G,sz5=16777215T",
NULL, &error_abort);
v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
- QDECREF(qdict);
+ qobject_unref(qdict);
visit_start_struct(v, NULL, NULL, 0, &error_abort);
visit_type_size(v, "sz1", &sz, &error_abort);
g_assert_cmpuint(sz, ==, 8);
/* Beyond limit with suffix */
qdict = keyval_parse("sz1=16777216T", NULL, &error_abort);
v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
- QDECREF(qdict);
+ qobject_unref(qdict);
visit_start_struct(v, NULL, NULL, 0, &error_abort);
visit_type_size(v, "sz1", &sz, &err);
error_free_or_abort(&err);
/* Trailing crap */
qdict = keyval_parse("sz1=16E,sz2=16Gi", NULL, &error_abort);
v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
- QDECREF(qdict);
+ qobject_unref(qdict);
visit_start_struct(v, NULL, NULL, 0, &error_abort);
visit_type_size(v, "sz1", &sz, &err);
error_free_or_abort(&err);
qdict = keyval_parse("a.b.c=1,a.b.c=2,d=3", NULL, &error_abort);
v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
- QDECREF(qdict);
+ qobject_unref(qdict);
visit_start_struct(v, NULL, NULL, 0, &error_abort);
visit_start_struct(v, "a", NULL, 0, &error_abort);
visit_start_struct(v, "b", NULL, 0, &error_abort);
qdict = keyval_parse("a.b=", NULL, &error_abort);
v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
- QDECREF(qdict);
+ qobject_unref(qdict);
visit_start_struct(v, NULL, NULL, 0, &error_abort);
visit_start_struct(v, "a", NULL, 0, &error_abort);
visit_type_int(v, "c", &i, &err); /* a.c missing */
qdict = keyval_parse("a.0=,a.1=I,a.2.0=II", NULL, &error_abort);
/* TODO empty list */
v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
- QDECREF(qdict);
+ qobject_unref(qdict);
visit_start_struct(v, NULL, NULL, 0, &error_abort);
visit_start_list(v, "a", NULL, 0, &error_abort);
visit_type_str(v, NULL, &s, &error_abort);
qdict = keyval_parse("a.0=,b.0.0=head", NULL, &error_abort);
v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
- QDECREF(qdict);
+ qobject_unref(qdict);
visit_start_struct(v, NULL, NULL, 0, &error_abort);
visit_start_list(v, "a", NULL, 0, &error_abort);
visit_check_list(v, &err); /* a[0] unexpected */
qdict = keyval_parse("a.b=1", NULL, &error_abort);
v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
- QDECREF(qdict);
+ qobject_unref(qdict);
visit_start_struct(v, NULL, NULL, 0, &error_abort);
visit_optional(v, "b", &present);
g_assert(!present); /* b missing */
*/
qdict = keyval_parse("a=1,b=2,c=on", NULL, &error_abort);
v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
- QDECREF(qdict);
+ qobject_unref(qdict);
visit_start_struct(v, NULL, NULL, 0, &error_abort);
visit_type_AltStrObj(v, "a", &aso, &error_abort);
g_assert_cmpint(aso->type, ==, QTYPE_QSTRING);
qdict = keyval_parse("a.0=null,a.1=1", NULL, &error_abort);
v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
- QDECREF(qdict);
+ qobject_unref(qdict);
visit_start_struct(v, NULL, NULL, 0, &error_abort);
visit_type_any(v, "a", &any, &error_abort);
qlist = qobject_to(QList, any);
g_assert(qlist);
qstr = qobject_to(QString, qlist_pop(qlist));
g_assert_cmpstr(qstring_get_str(qstr), ==, "null");
- QDECREF(qstr);
+ qobject_unref(qstr);
qstr = qobject_to(QString, qlist_pop(qlist));
g_assert_cmpstr(qstring_get_str(qstr), ==, "1");
g_assert(qlist_empty(qlist));
- QDECREF(qstr);
- qobject_decref(any);
+ qobject_unref(qstr);
+ qobject_unref(any);
visit_check_struct(v, &error_abort);
visit_end_struct(v, NULL);
visit_free(v);
g_assert(response);
g_assert(!qdict_haskey(response, "error"));
- QDECREF(response);
+ qobject_unref(response);
response = qmp("{'execute': 'object-del',"
" 'arguments': {"
"}}");
g_assert(response);
g_assert(!qdict_haskey(response, "error"));
- QDECREF(response);
+ qobject_unref(response);
}
/* add a netfilter to a netdev and then remove the netdev */
g_assert(response);
g_assert(!qdict_haskey(response, "error"));
- QDECREF(response);
+ qobject_unref(response);
response = qmp("{'execute': 'netdev_del',"
" 'arguments': {"
"}}");
g_assert(response);
g_assert(!qdict_haskey(response, "error"));
- QDECREF(response);
+ qobject_unref(response);
/* add back the netdev */
response = qmp("{'execute': 'netdev_add',"
"}}");
g_assert(response);
g_assert(!qdict_haskey(response, "error"));
- QDECREF(response);
+ qobject_unref(response);
}
/* add multi(2) netfilters to a netdev and then remove them */
g_assert(response);
g_assert(!qdict_haskey(response, "error"));
- QDECREF(response);
+ qobject_unref(response);
response = qmp("{'execute': 'object-add',"
" 'arguments': {"
g_assert(response);
g_assert(!qdict_haskey(response, "error"));
- QDECREF(response);
+ qobject_unref(response);
response = qmp("{'execute': 'object-del',"
" 'arguments': {"
"}}");
g_assert(response);
g_assert(!qdict_haskey(response, "error"));
- QDECREF(response);
+ qobject_unref(response);
response = qmp("{'execute': 'object-del',"
" 'arguments': {"
"}}");
g_assert(response);
g_assert(!qdict_haskey(response, "error"));
- QDECREF(response);
+ qobject_unref(response);
}
/* add multi(2) netfilters to a netdev and then remove the netdev */
g_assert(response);
g_assert(!qdict_haskey(response, "error"));
- QDECREF(response);
+ qobject_unref(response);
response = qmp("{'execute': 'object-add',"
" 'arguments': {"
g_assert(response);
g_assert(!qdict_haskey(response, "error"));
- QDECREF(response);
+ qobject_unref(response);
response = qmp("{'execute': 'netdev_del',"
" 'arguments': {"
"}}");
g_assert(response);
g_assert(!qdict_haskey(response, "error"));
- QDECREF(response);
+ qobject_unref(response);
/* add back the netdev */
response = qmp("{'execute': 'netdev_add',"
"}}");
g_assert(response);
g_assert(!qdict_haskey(response, "error"));
- QDECREF(response);
+ qobject_unref(response);
}
int main(int argc, char **argv)
g_assert_cmpstr(qdict_get_str(dict, "number1"), ==, "42");
g_assert_false(qdict_haskey(dict, "number2"));
- QDECREF(dict);
+ qobject_unref(dict);
qemu_opts_del(opts);
}
g_assert_cmpstr(qdict_get_str(dict, "number1"), ==, "42");
g_assert_false(qdict_haskey(dict, "number2"));
g_assert_false(qdict_haskey(dict, "bool1"));
- QDECREF(dict);
+ qobject_unref(dict);
dict = qemu_opts_to_qdict_filtered(opts, NULL, &opts_list_02, false);
g_assert(dict != NULL);
g_assert_false(qdict_haskey(dict, "str3"));
g_assert_false(qdict_haskey(dict, "number1"));
g_assert_false(qdict_haskey(dict, "number2"));
- QDECREF(dict);
+ qobject_unref(dict);
/* Now delete converted options from opts */
dict = qemu_opts_to_qdict_filtered(opts, NULL, &opts_list_01, true);
g_assert_cmpstr(qdict_get_str(dict, "number1"), ==, "42");
g_assert_false(qdict_haskey(dict, "number2"));
g_assert_false(qdict_haskey(dict, "bool1"));
- QDECREF(dict);
+ qobject_unref(dict);
dict = qemu_opts_to_qdict_filtered(opts, NULL, &opts_list_02, true);
g_assert(dict != NULL);
g_assert_false(qdict_haskey(dict, "str3"));
g_assert_false(qdict_haskey(dict, "number1"));
g_assert_false(qdict_haskey(dict, "number2"));
- QDECREF(dict);
+ qobject_unref(dict);
g_assert_true(QTAILQ_EMPTY(&opts->head));
dict = qemu_opts_to_qdict(opts, NULL);
g_assert(dict != NULL);
g_assert_cmpstr(qdict_get_str(dict, "foo"), ==, "b");
- QDECREF(dict);
+ qobject_unref(dict);
/* The last one still wins if entries are deleted, and both are deleted */
dict = qemu_opts_to_qdict_filtered(opts, NULL, NULL, true);
g_assert(dict != NULL);
g_assert_cmpstr(qdict_get_str(dict, "foo"), ==, "b");
- QDECREF(dict);
+ qobject_unref(dict);
g_assert_true(QTAILQ_EMPTY(&opts->head));
v = qdict_get_int(ret, "return");
g_assert_cmpint(r, ==, v);
- QDECREF(ret);
+ qobject_unref(ret);
}
static void test_qga_sync(gconstpointer fix)
v = qdict_get_int(ret, "return");
g_assert_cmpint(r, ==, v);
- QDECREF(ret);
+ qobject_unref(ret);
}
static void test_qga_ping(gconstpointer fix)
g_assert_nonnull(ret);
qmp_assert_no_error(ret);
- QDECREF(ret);
+ qobject_unref(ret);
}
static void test_qga_invalid_args(gconstpointer fix)
g_assert_cmpstr(class, ==, "GenericError");
g_assert_cmpstr(desc, ==, "Parameter 'foo' is unexpected");
- QDECREF(ret);
+ qobject_unref(ret);
}
static void test_qga_invalid_cmd(gconstpointer fix)
g_assert_cmpstr(class, ==, "CommandNotFound");
g_assert_cmpint(strlen(desc), >, 0);
- QDECREF(ret);
+ qobject_unref(ret);
}
static void test_qga_info(gconstpointer fix)
version = qdict_get_try_str(val, "version");
g_assert_cmpstr(version, ==, QEMU_VERSION);
- QDECREF(ret);
+ qobject_unref(ret);
}
static void test_qga_get_vcpus(gconstpointer fix)
g_assert(qdict_haskey(qobject_to(QDict, entry->value), "online"));
g_assert(qdict_haskey(qobject_to(QDict, entry->value), "logical-id"));
- QDECREF(ret);
+ qobject_unref(ret);
}
static void test_qga_get_fsinfo(gconstpointer fix)
g_assert(qdict_haskey(qobject_to(QDict, entry->value), "disk"));
}
- QDECREF(ret);
+ qobject_unref(ret);
}
static void test_qga_get_memory_block_info(gconstpointer fix)
g_assert_cmpint(size, >, 0);
}
- QDECREF(ret);
+ qobject_unref(ret);
}
static void test_qga_get_memory_blocks(gconstpointer fix)
}
}
- QDECREF(ret);
+ qobject_unref(ret);
}
static void test_qga_network_get_interfaces(gconstpointer fix)
entry = qlist_first(list);
g_assert(qdict_haskey(qobject_to(QDict, entry->value), "name"));
- QDECREF(ret);
+ qobject_unref(ret);
}
static void test_qga_file_ops(gconstpointer fix)
g_assert_nonnull(ret);
qmp_assert_no_error(ret);
id = qdict_get_int(ret, "return");
- QDECREF(ret);
+ qobject_unref(ret);
enc = g_base64_encode(helloworld, sizeof(helloworld));
/* write */
eof = qdict_get_bool(val, "eof");
g_assert_cmpint(count, ==, sizeof(helloworld));
g_assert_cmpint(eof, ==, 0);
- QDECREF(ret);
+ qobject_unref(ret);
g_free(cmd);
/* flush */
" 'arguments': {'handle': %" PRId64 "} }",
id);
ret = qmp_fd(fixture->fd, cmd);
- QDECREF(ret);
+ qobject_unref(ret);
g_free(cmd);
/* close */
" 'arguments': {'handle': %" PRId64 "} }",
id);
ret = qmp_fd(fixture->fd, cmd);
- QDECREF(ret);
+ qobject_unref(ret);
g_free(cmd);
/* check content */
g_assert_nonnull(ret);
qmp_assert_no_error(ret);
id = qdict_get_int(ret, "return");
- QDECREF(ret);
+ qobject_unref(ret);
/* read */
cmd = g_strdup_printf("{'execute': 'guest-file-read',"
g_assert(eof);
g_assert_cmpstr(b64, ==, enc);
- QDECREF(ret);
+ qobject_unref(ret);
g_free(cmd);
g_free(enc);
g_assert_cmpint(count, ==, 0);
g_assert(eof);
g_assert_cmpstr(b64, ==, "");
- QDECREF(ret);
+ qobject_unref(ret);
g_free(cmd);
/* seek */
eof = qdict_get_bool(val, "eof");
g_assert_cmpint(count, ==, 6);
g_assert(!eof);
- QDECREF(ret);
+ qobject_unref(ret);
g_free(cmd);
/* partial read */
g_assert_cmpmem(dec, count, helloworld + 6, sizeof(helloworld) - 6);
g_free(dec);
- QDECREF(ret);
+ qobject_unref(ret);
g_free(cmd);
/* close */
" 'arguments': {'handle': %" PRId64 "} }",
id);
ret = qmp_fd(fixture->fd, cmd);
- QDECREF(ret);
+ qobject_unref(ret);
g_free(cmd);
}
g_assert_nonnull(ret);
qmp_assert_no_error(ret);
id = qdict_get_int(ret, "return");
- QDECREF(ret);
+ qobject_unref(ret);
enc = g_base64_encode(helloworld, sizeof(helloworld));
/* write */
eof = qdict_get_bool(val, "eof");
g_assert_cmpint(count, ==, sizeof(helloworld));
g_assert_cmpint(eof, ==, 0);
- QDECREF(ret);
+ qobject_unref(ret);
g_free(cmd);
/* read (check implicit flush) */
g_assert_cmpint(count, ==, 0);
g_assert(eof);
g_assert_cmpstr(b64, ==, "");
- QDECREF(ret);
+ qobject_unref(ret);
g_free(cmd);
/* seek to 0 */
eof = qdict_get_bool(val, "eof");
g_assert_cmpint(count, ==, 0);
g_assert(!eof);
- QDECREF(ret);
+ qobject_unref(ret);
g_free(cmd);
/* read */
g_assert_cmpint(count, ==, sizeof(helloworld));
g_assert(eof);
g_assert_cmpstr(b64, ==, enc);
- QDECREF(ret);
+ qobject_unref(ret);
g_free(cmd);
g_free(enc);
" 'arguments': {'handle': %" PRId64 "} }",
id);
ret = qmp_fd(fixture->fd, cmd);
- QDECREF(ret);
+ qobject_unref(ret);
g_free(cmd);
}
time = qdict_get_int(ret, "return");
g_assert_cmpint(time, >, 0);
- QDECREF(ret);
+ qobject_unref(ret);
}
static void test_qga_blacklist(gconstpointer data)
desc = qdict_get_try_str(error, "desc");
g_assert_cmpstr(class, ==, "GenericError");
g_assert_nonnull(g_strstr_len(desc, -1, "has been disabled"));
- QDECREF(ret);
+ qobject_unref(ret);
ret = qmp_fd(fix.fd, "{'execute': 'guest-get-time'}");
g_assert_nonnull(ret);
desc = qdict_get_try_str(error, "desc");
g_assert_cmpstr(class, ==, "GenericError");
g_assert_nonnull(g_strstr_len(desc, -1, "has been disabled"));
- QDECREF(ret);
+ qobject_unref(ret);
/* check something work */
ret = qmp_fd(fix.fd, "{'execute': 'guest-get-fsinfo'}");
qmp_assert_no_error(ret);
- QDECREF(ret);
+ qobject_unref(ret);
fixture_tear_down(&fix, NULL);
}
status = qdict_get_try_str(ret, "return");
g_assert_cmpstr(status, ==, "thawed");
- QDECREF(ret);
+ qobject_unref(ret);
}
static void test_qga_guest_exec(gconstpointer fix)
val = qdict_get_qdict(ret, "return");
pid = qdict_get_int(val, "pid");
g_assert_cmpint(pid, >, 0);
- QDECREF(ret);
+ qobject_unref(ret);
/* wait for completion */
now = g_get_monotonic_time();
val = qdict_get_qdict(ret, "return");
exited = qdict_get_bool(val, "exited");
if (!exited) {
- QDECREF(ret);
+ qobject_unref(ret);
}
} while (!exited &&
g_get_monotonic_time() < now + 5 * G_TIME_SPAN_SECOND);
g_assert_cmpint(len, ==, 12);
g_assert_cmpstr((char *)decoded, ==, "\" test_str \"");
g_free(decoded);
- QDECREF(ret);
+ qobject_unref(ret);
}
static void test_qga_guest_exec_invalid(gconstpointer fix)
desc = qdict_get_str(error, "desc");
g_assert_cmpstr(class, ==, "GenericError");
g_assert_cmpint(strlen(desc), >, 0);
- QDECREF(ret);
+ qobject_unref(ret);
/* invalid pid */
ret = qmp_fd(fixture->fd, "{'execute': 'guest-exec-status',"
desc = qdict_get_str(error, "desc");
g_assert_cmpstr(class, ==, "GenericError");
g_assert_cmpint(strlen(desc), >, 0);
- QDECREF(ret);
+ qobject_unref(ret);
}
static void test_qga_guest_get_osinfo(gconstpointer data)
g_assert_nonnull(str);
g_assert_cmpstr(str, ==, "unit-test");
- QDECREF(ret);
+ qobject_unref(ret);
g_free(env[0]);
fixture_tear_down(&fixture, NULL);
}
assert(resp != NULL);
assert(!qdict_haskey(qobject_to(QDict, resp), "error"));
- qobject_decref(resp);
- QDECREF(req);
+ qobject_unref(resp);
+ qobject_unref(req);
}
/* test commands that return an error due to invalid parameters */
assert(resp != NULL);
assert(qdict_haskey(qobject_to(QDict, resp), "error"));
- qobject_decref(resp);
- QDECREF(req);
+ qobject_unref(resp);
+ qobject_unref(req);
/* check that with extra arguments it throws an error */
req = qdict_new();
assert(resp != NULL);
assert(qdict_haskey(qobject_to(QDict, resp), "error"));
- qobject_decref(resp);
- QDECREF(req);
+ qobject_unref(resp);
+ qobject_unref(req);
}
static QObject *test_qmp_dispatch(QDict *req)
assert(resp && !qdict_haskey(resp, "error"));
ret = qdict_get(resp, "return");
assert(ret);
- qobject_incref(ret);
- qobject_decref(resp_obj);
+ qobject_ref(ret);
+ qobject_unref(resp_obj);
return ret;
}
assert(qdict_get_int(ret_dict_dict2_userdef, "integer") == 422);
assert(!strcmp(qdict_get_str(ret_dict_dict2_userdef, "string"), "hello2"));
assert(!strcmp(qdict_get_str(ret_dict_dict2, "string"), "blah4"));
- QDECREF(ret);
+ qobject_unref(ret);
qdict_put_int(args3, "a", 66);
qdict_put(req, "arguments", args3);
ret3 = qobject_to(QNum, test_qmp_dispatch(req));
g_assert(qnum_get_try_int(ret3, &val));
g_assert_cmpint(val, ==, 66);
- QDECREF(ret3);
+ qobject_unref(ret3);
- QDECREF(req);
+ qobject_unref(req);
}
/* test generated dealloc functions for generated types */
v = qobject_input_visitor_new(QOBJECT(ud2_dict));
visit_type_UserDefTwo(v, NULL, &ud2, &err);
visit_free(v);
- QDECREF(ud2_dict);
+ qobject_unref(ud2_dict);
}
/* verify that visit_type_XXX() cleans up properly on error */
static void event_teardown(TestEventData *data,
const void *unused)
{
- QDECREF(data->expect);
+ qobject_unref(data->expect);
test_event_data = NULL;
g_mutex_unlock(&test_event_lock);
static void visitor_input_teardown(TestInputVisitorData *data,
const void *unused)
{
- qobject_decref(data->obj);
+ qobject_unref(data->obj);
data->obj = NULL;
if (data->qiv) {
g_assert(qnum);
g_assert(qnum_get_try_int(qnum, &val));
g_assert_cmpint(val, ==, -42);
- qobject_decref(res);
+ qobject_unref(res);
v = visitor_input_test_init(data, "{ 'integer': -42, 'boolean': true, 'string': 'foo' }");
visit_type_any(v, NULL, &res, &error_abort);
qstring = qobject_to(QString, qobj);
g_assert(qstring);
g_assert_cmpstr(qstring_get_str(qstring), ==, "foo");
- qobject_decref(res);
+ qobject_unref(res);
}
static void test_visitor_in_null(TestInputVisitorData *data,
visit_start_struct(v, NULL, NULL, 0, &error_abort);
visit_type_null(v, "a", &null, &error_abort);
g_assert(qobject_type(QOBJECT(null)) == QTYPE_QNULL);
- QDECREF(null);
+ qobject_unref(null);
visit_type_null(v, "b", &null, &err);
error_free_or_abort(&err);
g_assert(!null);
g_assert(schema);
qapi_free_SchemaInfoList(schema);
- qobject_decref(obj);
+ qobject_unref(obj);
visit_free(v);
}
{
visit_free(data->ov);
data->ov = NULL;
- qobject_decref(data->obj);
+ qobject_unref(data->obj);
data->obj = NULL;
}
g_assert(qnum);
g_assert(qnum_get_try_int(qnum, &val));
g_assert_cmpint(val, ==, -42);
- qobject_decref(qobj);
+ qobject_unref(qobj);
visitor_reset(data);
qdict = qdict_new();
qdict_put_str(qdict, "string", "foo");
qobj = QOBJECT(qdict);
visit_type_any(data->ov, NULL, &qobj, &error_abort);
- qobject_decref(qobj);
+ qobject_unref(qobj);
qdict = qobject_to(QDict, visitor_get(data));
g_assert(qdict);
qnum = qobject_to(QNum, qdict_get(qdict, "integer"));
qvalue = qobject_to(QNum, tmp);
g_assert(qnum_get_try_uint(qvalue, &val));
g_assert_cmpint(val, ==, i);
- qobject_decref(qlist_pop(qlist));
+ qobject_unref(qlist_pop(qlist));
}
break;
qvalue = qobject_to(QNum, tmp);
g_assert(qnum_get_try_int(qvalue, &val));
g_assert_cmpint(val, ==, i);
- qobject_decref(qlist_pop(qlist));
+ qobject_unref(qlist_pop(qlist));
}
break;
case USER_DEF_NATIVE_LIST_UNION_KIND_BOOLEAN:
g_assert(tmp);
qvalue = qobject_to(QBool, tmp);
g_assert_cmpint(qbool_get_bool(qvalue), ==, i % 3 == 0);
- qobject_decref(qlist_pop(qlist));
+ qobject_unref(qlist_pop(qlist));
}
break;
case USER_DEF_NATIVE_LIST_UNION_KIND_STRING:
qvalue = qobject_to(QString, tmp);
sprintf(str, "%d", i);
g_assert_cmpstr(qstring_get_str(qvalue), ==, str);
- qobject_decref(qlist_pop(qlist));
+ qobject_unref(qlist_pop(qlist));
}
break;
case USER_DEF_NATIVE_LIST_UNION_KIND_NUMBER:
g_string_printf(double_actual, "%.6f", qnum_get_double(qvalue));
g_assert_cmpstr(double_actual->str, ==, double_expected->str);
- qobject_decref(qlist_pop(qlist));
+ qobject_unref(qlist_pop(qlist));
g_string_free(double_expected, true);
g_string_free(double_actual, true);
}
default:
g_assert_not_reached();
}
- QDECREF(qlist);
+ qobject_unref(qlist);
}
static void test_native_list(TestOutputVisitorData *data,
output_json = qobject_to_json(obj_orig);
obj = qobject_from_json(qstring_get_str(output_json), &error_abort);
- QDECREF(output_json);
+ qobject_unref(output_json);
d->qiv = qobject_input_visitor_new(obj);
- qobject_decref(obj_orig);
- qobject_decref(obj);
+ qobject_unref(obj_orig);
+ qobject_unref(obj);
visit(d->qiv, native_out, errp);
}
cpu0 = qobject_to(QDict, qlist_peek(ret));
path = g_strdup(qdict_get_str(cpu0, "qom_path"));
- QDECREF(resp);
+ qobject_unref(resp);
return path;
}
" 'property': %s } }",
path, prop);
QObject *ret = qdict_get(resp, "return");
- qobject_incref(ret);
- QDECREF(resp);
+ qobject_ref(ret);
+ qobject_unref(resp);
return ret;
}
QBool *value = qobject_to(QBool, qom_get(path, prop));
bool b = qbool_get_bool(value);
- QDECREF(value);
+ qobject_unref(value);
return b;
}
#endif
g_assert_cmpint(val, ==, args->expected_value);
qtest_end();
- QDECREF(value);
+ qobject_unref(value);
g_free(path);
}
g_assert(!!(value & (1U << args->bitnr)) == args->expected_value);
- QDECREF(present);
- QDECREF(filtered);
+ qobject_unref(present);
+ qobject_unref(filtered);
g_free(path);
}
"'property': 'temperature' } }", id);
g_assert(qdict_haskey(response, "return"));
ret = qdict_get_int(response, "return");
- QDECREF(response);
+ qobject_unref(response);
return ret;
}
response = qmp("{ 'execute': 'qom-set', 'arguments': { 'path': %s, "
"'property': 'temperature', 'value': %d } }", id, value);
g_assert(qdict_haskey(response, "return"));
- QDECREF(response);
+ qobject_unref(response);
}
#define TMP105_PRECISION (1000/16)
rsp = qmp("{ 'execute': 'migrate_set_speed',"
"'arguments': { 'value': 10 } }");
g_assert(qdict_haskey(rsp, "return"));
- QDECREF(rsp);
+ qobject_unref(rsp);
cmd = g_strdup_printf("{ 'execute': 'migrate',"
"'arguments': { 'uri': '%s' } }",
rsp = qmp(cmd);
g_free(cmd);
g_assert(qdict_haskey(rsp, "return"));
- QDECREF(rsp);
+ qobject_unref(rsp);
wait_for_log_fd(s);
rsp = qmp("{ 'execute': 'migrate_set_speed',"
"'arguments': { 'value': 0 } }");
g_assert(qdict_haskey(rsp, "return"));
- QDECREF(rsp);
+ qobject_unref(rsp);
qmp_eventwait("STOP");
qvirtqueue_kick(dev, vq, free_head);
rsp = qmp("{ 'execute' : 'stop'}");
- QDECREF(rsp);
+ qobject_unref(rsp);
ret = iov_send(socket, iov, 2, 0, sizeof(len) + sizeof(test));
g_assert_cmpint(ret, ==, sizeof(test) + sizeof(len));
* ensure the packet data gets queued in QEMU, before we do 'cont'.
*/
rsp = qmp("{ 'execute' : 'query-status'}");
- QDECREF(rsp);
+ qobject_unref(rsp);
rsp = qmp("{ 'execute' : 'cont'}");
- QDECREF(rsp);
+ qobject_unref(rsp);
qvirtio_wait_used_elem(dev, vq, free_head, NULL, QVIRTIO_NET_TIMEOUT_US);
memread(req_addr + VNET_HDR_SIZE, buffer, sizeof(test));
guid_str = qdict_get_str(rsp_ret, "guid");
g_assert(qemu_uuid_parse(guid_str, guid) == 0);
}
- QDECREF(rsp);
+ qobject_unref(rsp);
}
static char disk[] = "tests/vmgenid-test-disk-XXXXXX";
{
QDict *resp = qtest_qmp(s, "{'execute':'query-status'}");
g_assert(qdict_haskey(resp, "return"));
- QDECREF(resp);
+ qobject_unref(resp);
}
static QDict *ib700_program_and_wait(QTestState *s)
qtest_clock_step(s, 2 * NANOSECONDS_PER_SECOND);
event = qtest_qmp_eventwait_ref(s, "WATCHDOG");
data = qdict_get_qdict(event, "data");
- QINCREF(data);
- QDECREF(event);
+ qobject_ref(data);
+ qobject_unref(event);
return data;
}
qtest_irq_intercept_in(s, "ioapic");
d = ib700_program_and_wait(s);
g_assert(!strcmp(qdict_get_str(d, "action"), "pause"));
- QDECREF(d);
+ qobject_unref(d);
qtest_qmp_eventwait(s, "STOP");
qtest_quit(s);
}
qtest_irq_intercept_in(s, "ioapic");
d = ib700_program_and_wait(s);
g_assert(!strcmp(qdict_get_str(d, "action"), "reset"));
- QDECREF(d);
+ qobject_unref(d);
qtest_qmp_eventwait(s, "RESET");
qtest_quit(s);
}
qtest_irq_intercept_in(s, "ioapic");
d = ib700_program_and_wait(s);
g_assert(!strcmp(qdict_get_str(d, "action"), "reset"));
- QDECREF(d);
+ qobject_unref(d);
qtest_qmp_eventwait(s, "SHUTDOWN");
qtest_quit(s);
}
qtest_irq_intercept_in(s, "ioapic");
d = ib700_program_and_wait(s);
g_assert(!strcmp(qdict_get_str(d, "action"), "none"));
- QDECREF(d);
+ qobject_unref(d);
qtest_quit(s);
}
* Else, fail because we have conflicting needs on how to map
* @key_in_cur.
* In any case, take over the reference to @value, i.e. if the caller
- * wants to hold on to a reference, it needs to QINCREF().
+ * wants to hold on to a reference, it needs to qobject_ref().
* Use @key up to @key_cursor to identify the key in error messages.
* On success, return the mapped value.
* On failure, store an error through @errp and return NULL.
if (qobject_type(old) != (value ? QTYPE_QSTRING : QTYPE_QDICT)) {
error_setg(errp, "Parameters '%.*s.*' used inconsistently",
(int)(key_cursor - key), key);
- QDECREF(value);
+ qobject_unref(value);
return NULL;
}
if (!value) {
error_setg(errp, "Parameter '%s%d' missing", key, i);
g_free(key);
g_free(elt);
- QDECREF(list);
+ qobject_unref(list);
return NULL;
}
- qobject_incref(elt[i]);
+ qobject_ref(elt[i]);
qlist_append_obj(list, elt[i]);
}
while (*s) {
s = keyval_parse_one(qdict, s, implied_key, errp);
if (!s) {
- QDECREF(qdict);
+ qobject_unref(qdict);
return NULL;
}
implied_key = NULL;
listified = keyval_listify(qdict, NULL, errp);
if (!listified) {
- QDECREF(qdict);
+ qobject_unref(qdict);
return NULL;
}
assert(listified == QOBJECT(qdict));
}
out:
- QDECREF(subqdict);
- QDECREF(list);
+ qobject_unref(subqdict);
+ qobject_unref(list);
}
void qemu_config_parse_qdict(QDict *options, QemuOptsList **lists,
projects / qemu.git / commitdiff