Compare commits
87 Commits
queue/ui-p
...
queue/ui+i
Author | SHA1 | Date | |
---|---|---|---|
|
6e24ee0c1e | ||
|
954ee55bd5 | ||
|
8498bb8d2e | ||
|
85970a627f | ||
|
51dbea77a2 | ||
|
77b0359bf4 | ||
|
d3b787fa7d | ||
|
e18a639164 | ||
|
469819a3e8 | ||
|
22a9e1fd63 | ||
|
84e3d0725b | ||
|
db7a99cdc1 | ||
|
32b9ca9868 | ||
|
2a747008cb | ||
|
92bd1e465b | ||
|
492734b5da | ||
|
d2a44865e8 | ||
|
a825ca0613 | ||
|
a08fc2f8cc | ||
|
c34647c18a | ||
|
2e1d6bdcce | ||
|
c9c06eb832 | ||
|
905bf0ee8a | ||
|
32809e7f7b | ||
|
8a98bfc6e3 | ||
|
8a48be0e87 | ||
|
96e659d006 | ||
|
cf80eb8d09 | ||
|
2c1c31ed55 | ||
|
438d116872 | ||
|
4c84f662c2 | ||
|
2499ee9fad | ||
|
7af25f9f6a | ||
|
896b6757f9 | ||
|
269c20b2bb | ||
|
ad664c1d4c | ||
|
709fa704f6 | ||
|
61d7c14437 | ||
|
9848619a3b | ||
|
07fe095452 | ||
|
1eb4243434 | ||
|
77a7a36760 | ||
|
4ccd89d294 | ||
|
5d7fb0f254 | ||
|
c7b4efb4a0 | ||
|
1ea1572adf | ||
|
605553654f | ||
|
b81bdbf3c7 | ||
|
35f91e5069 | ||
|
6d13643a3a | ||
|
c5c6c47ce3 | ||
|
19e9cdf040 | ||
|
c03d83d55a | ||
|
b053ef6106 | ||
|
9ed442b8ae | ||
|
822335eb51 | ||
|
446de8b68a | ||
|
d528227d4c | ||
|
3fb2111fc9 | ||
|
76318657a8 | ||
|
85bbd1e7a4 | ||
|
1e507bb0fd | ||
|
d015c4ea6f | ||
|
3152779cd6 | ||
|
5923f85fb8 | ||
|
2bc7cfea09 | ||
|
61a8f418b2 | ||
|
36aeb6094f | ||
|
60390d2dc8 | ||
|
01b2ffcedd | ||
|
8da54b2507 | ||
|
542f70c22e | ||
|
54e1d4ed1d | ||
|
b97a879de9 | ||
|
308714e6bc | ||
|
9c39b94f14 | ||
|
acb0b292b6 | ||
|
3fb53fb4d1 | ||
|
cc74d332ff | ||
|
2b48e10f88 | ||
|
6e3b2bfd6a | ||
|
b255b2c8a5 | ||
|
58634047b7 | ||
|
c1214ad3dc | ||
|
7c877c8030 | ||
|
560f19f162 | ||
|
a2740ad584 |
@@ -1,15 +1,22 @@
|
||||
language: c
|
||||
git:
|
||||
submodules: false
|
||||
env:
|
||||
global:
|
||||
- LC_ALL=C
|
||||
matrix:
|
||||
- IMAGE=debian-armhf-cross
|
||||
TARGET_LIST=arm-softmmu,arm-linux-user
|
||||
TARGET_LIST=arm-softmmu,arm-linux-user,armeb-linux-user
|
||||
- IMAGE=debian-arm64-cross
|
||||
TARGET_LIST=aarch64-softmmu,aarch64-linux-user
|
||||
- IMAGE=debian-s390x-cross
|
||||
TARGET_LIST=s390x-softmmu,s390x-linux-user
|
||||
# mips64el-softmmu disabled due to libfdt problem
|
||||
- IMAGE=debian-mipsel-cross
|
||||
TARGET_LIST=mipsel-softmmu,mipsel-linux-user,mips64el-linux-user
|
||||
build:
|
||||
pre_ci:
|
||||
- make docker-image-${IMAGE}
|
||||
- make docker-image-${IMAGE} V=1
|
||||
pre_ci_boot:
|
||||
image_name: qemu
|
||||
image_tag: ${IMAGE}
|
||||
@@ -17,5 +24,13 @@ build:
|
||||
options: "-e HOME=/root"
|
||||
ci:
|
||||
- unset CC
|
||||
# some targets require newer up to date packages, for example TARGET_LIST matching
|
||||
# aarch64*-softmmu|arm*-softmmu|ppc*-softmmu|microblaze*-softmmu|mips64el-softmmu)
|
||||
# see the configure script:
|
||||
# error_exit "DTC (libfdt) version >= 1.4.2 not present. Your options:"
|
||||
# " (1) Preferred: Install the DTC (libfdt) devel package"
|
||||
# " (2) Fetch the DTC submodule, using:"
|
||||
# " git submodule update --init dtc"
|
||||
- dpkg --compare-versions `dpkg-query --showformat='${Version}' --show libfdt-dev` ge 1.4.2 || git submodule update --init dtc
|
||||
- ./configure ${QEMU_CONFIGURE_OPTS} --target-list=${TARGET_LIST}
|
||||
- make -j2
|
||||
- make -j$(($(getconf _NPROCESSORS_ONLN) + 1))
|
||||
|
@@ -1411,8 +1411,7 @@ F: include/qapi/qmp/
|
||||
X: include/qapi/qmp/dispatch.h
|
||||
F: scripts/coccinelle/qobject.cocci
|
||||
F: tests/check-qdict.c
|
||||
F: tests/check-qfloat.c
|
||||
F: tests/check-qint.c
|
||||
F: tests/check-qnum.c
|
||||
F: tests/check-qjson.c
|
||||
F: tests/check-qlist.c
|
||||
F: tests/check-qstring.c
|
||||
@@ -1858,12 +1857,14 @@ Build and test automation
|
||||
-------------------------
|
||||
M: Alex Bennée <alex.bennee@linaro.org>
|
||||
M: Fam Zheng <famz@redhat.com>
|
||||
R: Philippe Mathieu-Daudé <f4bug@amsat.org>
|
||||
L: qemu-devel@nongnu.org
|
||||
S: Maintained
|
||||
F: .travis.yml
|
||||
F: .shippable.yml
|
||||
F: tests/docker/
|
||||
W: https://travis-ci.org/qemu/qemu
|
||||
W: https://app.shippable.com/github/qemu/qemu
|
||||
W: http://patchew.org/QEMU/
|
||||
|
||||
Documentation
|
||||
|
@@ -523,8 +523,6 @@ static inline PageDesc *page_find(tb_page_addr_t index)
|
||||
# define MAX_CODE_GEN_BUFFER_SIZE (32u * 1024 * 1024)
|
||||
#elif defined(__aarch64__)
|
||||
# define MAX_CODE_GEN_BUFFER_SIZE (128ul * 1024 * 1024)
|
||||
#elif defined(__arm__)
|
||||
# define MAX_CODE_GEN_BUFFER_SIZE (16u * 1024 * 1024)
|
||||
#elif defined(__s390x__)
|
||||
/* We have a +- 4GB range on the branches; leave some slop. */
|
||||
# define MAX_CODE_GEN_BUFFER_SIZE (3ul * 1024 * 1024 * 1024)
|
||||
@@ -781,12 +779,13 @@ static inline void code_gen_alloc(size_t tb_size)
|
||||
exit(1);
|
||||
}
|
||||
|
||||
/* Estimate a good size for the number of TBs we can support. We
|
||||
still haven't deducted the prologue from the buffer size here,
|
||||
but that's minimal and won't affect the estimate much. */
|
||||
tcg_ctx.code_gen_max_blocks
|
||||
= tcg_ctx.code_gen_buffer_size / CODE_GEN_AVG_BLOCK_SIZE;
|
||||
tcg_ctx.tb_ctx.tbs = g_new(TranslationBlock, tcg_ctx.code_gen_max_blocks);
|
||||
/* size this conservatively -- realloc later if needed */
|
||||
tcg_ctx.tb_ctx.tbs_size =
|
||||
tcg_ctx.code_gen_buffer_size / CODE_GEN_AVG_BLOCK_SIZE / 8;
|
||||
if (unlikely(!tcg_ctx.tb_ctx.tbs_size)) {
|
||||
tcg_ctx.tb_ctx.tbs_size = 64 * 1024;
|
||||
}
|
||||
tcg_ctx.tb_ctx.tbs = g_new(TranslationBlock *, tcg_ctx.tb_ctx.tbs_size);
|
||||
|
||||
qemu_mutex_init(&tcg_ctx.tb_ctx.tb_lock);
|
||||
}
|
||||
@@ -828,16 +827,20 @@ bool tcg_enabled(void)
|
||||
static TranslationBlock *tb_alloc(target_ulong pc)
|
||||
{
|
||||
TranslationBlock *tb;
|
||||
TBContext *ctx;
|
||||
|
||||
assert_tb_locked();
|
||||
|
||||
if (tcg_ctx.tb_ctx.nb_tbs >= tcg_ctx.code_gen_max_blocks) {
|
||||
tb = tcg_tb_alloc(&tcg_ctx);
|
||||
if (unlikely(tb == NULL)) {
|
||||
return NULL;
|
||||
}
|
||||
tb = &tcg_ctx.tb_ctx.tbs[tcg_ctx.tb_ctx.nb_tbs++];
|
||||
tb->pc = pc;
|
||||
tb->cflags = 0;
|
||||
tb->invalid = false;
|
||||
ctx = &tcg_ctx.tb_ctx;
|
||||
if (unlikely(ctx->nb_tbs == ctx->tbs_size)) {
|
||||
ctx->tbs_size *= 2;
|
||||
ctx->tbs = g_renew(TranslationBlock *, ctx->tbs, ctx->tbs_size);
|
||||
}
|
||||
ctx->tbs[ctx->nb_tbs++] = tb;
|
||||
return tb;
|
||||
}
|
||||
|
||||
@@ -850,8 +853,10 @@ void tb_free(TranslationBlock *tb)
|
||||
Ignore the hard cases and just back up if this TB happens to
|
||||
be the last one generated. */
|
||||
if (tcg_ctx.tb_ctx.nb_tbs > 0 &&
|
||||
tb == &tcg_ctx.tb_ctx.tbs[tcg_ctx.tb_ctx.nb_tbs - 1]) {
|
||||
tcg_ctx.code_gen_ptr = tb->tc_ptr;
|
||||
tb == tcg_ctx.tb_ctx.tbs[tcg_ctx.tb_ctx.nb_tbs - 1]) {
|
||||
size_t struct_size = ROUND_UP(sizeof(*tb), qemu_icache_linesize);
|
||||
|
||||
tcg_ctx.code_gen_ptr = tb->tc_ptr - struct_size;
|
||||
tcg_ctx.tb_ctx.nb_tbs--;
|
||||
}
|
||||
}
|
||||
@@ -1279,9 +1284,11 @@ TranslationBlock *tb_gen_code(CPUState *cpu,
|
||||
|
||||
gen_code_buf = tcg_ctx.code_gen_ptr;
|
||||
tb->tc_ptr = gen_code_buf;
|
||||
tb->pc = pc;
|
||||
tb->cs_base = cs_base;
|
||||
tb->flags = flags;
|
||||
tb->cflags = cflags;
|
||||
tb->invalid = false;
|
||||
|
||||
#ifdef CONFIG_PROFILER
|
||||
tcg_ctx.tb_count1++; /* includes aborted translations because of
|
||||
@@ -1666,7 +1673,7 @@ static TranslationBlock *tb_find_pc(uintptr_t tc_ptr)
|
||||
m_max = tcg_ctx.tb_ctx.nb_tbs - 1;
|
||||
while (m_min <= m_max) {
|
||||
m = (m_min + m_max) >> 1;
|
||||
tb = &tcg_ctx.tb_ctx.tbs[m];
|
||||
tb = tcg_ctx.tb_ctx.tbs[m];
|
||||
v = (uintptr_t)tb->tc_ptr;
|
||||
if (v == tc_ptr) {
|
||||
return tb;
|
||||
@@ -1676,7 +1683,7 @@ static TranslationBlock *tb_find_pc(uintptr_t tc_ptr)
|
||||
m_min = m + 1;
|
||||
}
|
||||
}
|
||||
return &tcg_ctx.tb_ctx.tbs[m_max];
|
||||
return tcg_ctx.tb_ctx.tbs[m_max];
|
||||
}
|
||||
|
||||
#if !defined(CONFIG_USER_ONLY)
|
||||
@@ -1874,7 +1881,7 @@ void dump_exec_info(FILE *f, fprintf_function cpu_fprintf)
|
||||
direct_jmp_count = 0;
|
||||
direct_jmp2_count = 0;
|
||||
for (i = 0; i < tcg_ctx.tb_ctx.nb_tbs; i++) {
|
||||
tb = &tcg_ctx.tb_ctx.tbs[i];
|
||||
tb = tcg_ctx.tb_ctx.tbs[i];
|
||||
target_code_size += tb->size;
|
||||
if (tb->size > max_target_code_size) {
|
||||
max_target_code_size = tb->size;
|
||||
@@ -1894,8 +1901,7 @@ void dump_exec_info(FILE *f, fprintf_function cpu_fprintf)
|
||||
cpu_fprintf(f, "gen code size %td/%zd\n",
|
||||
tcg_ctx.code_gen_ptr - tcg_ctx.code_gen_buffer,
|
||||
tcg_ctx.code_gen_highwater - tcg_ctx.code_gen_buffer);
|
||||
cpu_fprintf(f, "TB count %d/%d\n",
|
||||
tcg_ctx.tb_ctx.nb_tbs, tcg_ctx.code_gen_max_blocks);
|
||||
cpu_fprintf(f, "TB count %d\n", tcg_ctx.tb_ctx.nb_tbs);
|
||||
cpu_fprintf(f, "TB avg target size %d max=%d bytes\n",
|
||||
tcg_ctx.tb_ctx.nb_tbs ? target_code_size /
|
||||
tcg_ctx.tb_ctx.nb_tbs : 0,
|
||||
|
@@ -222,7 +222,7 @@ cryptodev_backend_can_be_deleted(UserCreatable *uc, Error **errp)
|
||||
|
||||
static void cryptodev_backend_instance_init(Object *obj)
|
||||
{
|
||||
object_property_add(obj, "queues", "int",
|
||||
object_property_add(obj, "queues", "uint32",
|
||||
cryptodev_backend_get_queues,
|
||||
cryptodev_backend_set_queues,
|
||||
NULL, NULL, NULL);
|
||||
|
@@ -31,7 +31,6 @@
|
||||
#include "qemu/module.h"
|
||||
#include "qapi/qmp/qbool.h"
|
||||
#include "qapi/qmp/qdict.h"
|
||||
#include "qapi/qmp/qint.h"
|
||||
#include "qapi/qmp/qstring.h"
|
||||
#include "sysemu/qtest.h"
|
||||
|
||||
|
@@ -37,7 +37,6 @@
|
||||
#include "qapi/qobject-output-visitor.h"
|
||||
#include "qapi/qmp/qdict.h"
|
||||
#include "qapi/qmp/qjson.h"
|
||||
#include "qapi/qmp/qint.h"
|
||||
#include "qapi/qmp/qstring.h"
|
||||
#include "qemu/cutils.h"
|
||||
|
||||
|
@@ -36,7 +36,6 @@
|
||||
#include "qemu/cutils.h"
|
||||
#include "sysemu/sysemu.h"
|
||||
#include "qapi/qmp/qdict.h"
|
||||
#include "qapi/qmp/qint.h"
|
||||
#include "qapi/qmp/qstring.h"
|
||||
#include "qapi-visit.h"
|
||||
#include "qapi/qobject-input-visitor.h"
|
||||
|
13
block/qapi.c
13
block/qapi.c
@@ -595,9 +595,11 @@ static void dump_qobject(fprintf_function func_fprintf, void *f,
|
||||
int comp_indent, QObject *obj)
|
||||
{
|
||||
switch (qobject_type(obj)) {
|
||||
case QTYPE_QINT: {
|
||||
QInt *value = qobject_to_qint(obj);
|
||||
func_fprintf(f, "%" PRId64, qint_get_int(value));
|
||||
case QTYPE_QNUM: {
|
||||
QNum *value = qobject_to_qnum(obj);
|
||||
char *tmp = qnum_to_string(value);
|
||||
func_fprintf(f, "%s", tmp);
|
||||
g_free(tmp);
|
||||
break;
|
||||
}
|
||||
case QTYPE_QSTRING: {
|
||||
@@ -615,11 +617,6 @@ static void dump_qobject(fprintf_function func_fprintf, void *f,
|
||||
dump_qlist(func_fprintf, f, comp_indent, value);
|
||||
break;
|
||||
}
|
||||
case QTYPE_QFLOAT: {
|
||||
QFloat *value = qobject_to_qfloat(obj);
|
||||
func_fprintf(f, "%g", qfloat_get_double(value));
|
||||
break;
|
||||
}
|
||||
case QTYPE_QBOOL: {
|
||||
QBool *value = qobject_to_qbool(obj);
|
||||
func_fprintf(f, "%s", qbool_get_bool(value) ? "true" : "false");
|
||||
|
@@ -19,7 +19,6 @@
|
||||
#include "qapi/qmp/qbool.h"
|
||||
#include "qapi/qmp/qdict.h"
|
||||
#include "qapi/qmp/qerror.h"
|
||||
#include "qapi/qmp/qint.h"
|
||||
#include "qapi/qmp/qjson.h"
|
||||
#include "qapi/qmp/qlist.h"
|
||||
#include "qapi/qmp/qstring.h"
|
||||
|
@@ -16,7 +16,6 @@
|
||||
#include "qapi-visit.h"
|
||||
#include "qapi/error.h"
|
||||
#include "qapi/qmp/qdict.h"
|
||||
#include "qapi/qmp/qint.h"
|
||||
#include "qapi/qobject-input-visitor.h"
|
||||
#include "qemu/uri.h"
|
||||
#include "qemu/error-report.h"
|
||||
|
@@ -34,7 +34,6 @@
|
||||
#include "qemu/sockets.h"
|
||||
#include "qemu/uri.h"
|
||||
#include "qapi-visit.h"
|
||||
#include "qapi/qmp/qint.h"
|
||||
#include "qapi/qmp/qstring.h"
|
||||
#include "qapi/qobject-input-visitor.h"
|
||||
#include "qapi/qobject-output-visitor.h"
|
||||
|
@@ -29,7 +29,6 @@
|
||||
#include "qemu/module.h"
|
||||
#include "qemu/bswap.h"
|
||||
#include "migration/blocker.h"
|
||||
#include "qapi/qmp/qint.h"
|
||||
#include "qapi/qmp/qbool.h"
|
||||
#include "qapi/qmp/qstring.h"
|
||||
#include "qemu/cutils.h"
|
||||
|
@@ -334,8 +334,9 @@ static bool parse_stats_intervals(BlockAcctStats *stats, QList *intervals,
|
||||
break;
|
||||
}
|
||||
|
||||
case QTYPE_QINT: {
|
||||
int64_t length = qint_get_int(qobject_to_qint(entry->value));
|
||||
case QTYPE_QNUM: {
|
||||
int64_t length = qnum_get_int(qobject_to_qnum(entry->value));
|
||||
|
||||
if (length > 0 && length <= UINT_MAX) {
|
||||
block_acct_add_interval(stats, (unsigned) length);
|
||||
} else {
|
||||
|
@@ -83,23 +83,25 @@ static uint64_t acpi_memory_hotplug_read(void *opaque, hwaddr addr,
|
||||
o = OBJECT(mdev->dimm);
|
||||
switch (addr) {
|
||||
case 0x0: /* Lo part of phys address where DIMM is mapped */
|
||||
val = o ? object_property_get_int(o, PC_DIMM_ADDR_PROP, NULL) : 0;
|
||||
val = o ? object_property_get_uint(o, PC_DIMM_ADDR_PROP, NULL) : 0;
|
||||
trace_mhp_acpi_read_addr_lo(mem_st->selector, val);
|
||||
break;
|
||||
case 0x4: /* Hi part of phys address where DIMM is mapped */
|
||||
val = o ? object_property_get_int(o, PC_DIMM_ADDR_PROP, NULL) >> 32 : 0;
|
||||
val =
|
||||
o ? object_property_get_uint(o, PC_DIMM_ADDR_PROP, NULL) >> 32 : 0;
|
||||
trace_mhp_acpi_read_addr_hi(mem_st->selector, val);
|
||||
break;
|
||||
case 0x8: /* Lo part of DIMM size */
|
||||
val = o ? object_property_get_int(o, PC_DIMM_SIZE_PROP, NULL) : 0;
|
||||
val = o ? object_property_get_uint(o, PC_DIMM_SIZE_PROP, NULL) : 0;
|
||||
trace_mhp_acpi_read_size_lo(mem_st->selector, val);
|
||||
break;
|
||||
case 0xc: /* Hi part of DIMM size */
|
||||
val = o ? object_property_get_int(o, PC_DIMM_SIZE_PROP, NULL) >> 32 : 0;
|
||||
val =
|
||||
o ? object_property_get_uint(o, PC_DIMM_SIZE_PROP, NULL) >> 32 : 0;
|
||||
trace_mhp_acpi_read_size_hi(mem_st->selector, val);
|
||||
break;
|
||||
case 0x10: /* node proximity for _PXM method */
|
||||
val = o ? object_property_get_int(o, PC_DIMM_NODE_PROP, NULL) : 0;
|
||||
val = o ? object_property_get_uint(o, PC_DIMM_NODE_PROP, NULL) : 0;
|
||||
trace_mhp_acpi_read_pxm(mem_st->selector, val);
|
||||
break;
|
||||
case 0x14: /* pack and return is_* fields */
|
||||
|
@@ -236,14 +236,14 @@ static void
|
||||
nvdimm_build_structure_spa(GArray *structures, DeviceState *dev)
|
||||
{
|
||||
NvdimmNfitSpa *nfit_spa;
|
||||
uint64_t addr = object_property_get_int(OBJECT(dev), PC_DIMM_ADDR_PROP,
|
||||
NULL);
|
||||
uint64_t size = object_property_get_int(OBJECT(dev), PC_DIMM_SIZE_PROP,
|
||||
NULL);
|
||||
uint32_t node = object_property_get_int(OBJECT(dev), PC_DIMM_NODE_PROP,
|
||||
NULL);
|
||||
uint64_t addr = object_property_get_uint(OBJECT(dev), PC_DIMM_ADDR_PROP,
|
||||
NULL);
|
||||
uint64_t size = object_property_get_uint(OBJECT(dev), PC_DIMM_SIZE_PROP,
|
||||
NULL);
|
||||
uint32_t node = object_property_get_uint(OBJECT(dev), PC_DIMM_NODE_PROP,
|
||||
NULL);
|
||||
int slot = object_property_get_int(OBJECT(dev), PC_DIMM_SLOT_PROP,
|
||||
NULL);
|
||||
NULL);
|
||||
|
||||
nfit_spa = acpi_data_push(structures, sizeof(*nfit_spa));
|
||||
|
||||
@@ -284,8 +284,8 @@ static void
|
||||
nvdimm_build_structure_memdev(GArray *structures, DeviceState *dev)
|
||||
{
|
||||
NvdimmNfitMemDev *nfit_memdev;
|
||||
uint64_t size = object_property_get_int(OBJECT(dev), PC_DIMM_SIZE_PROP,
|
||||
NULL);
|
||||
uint64_t size = object_property_get_uint(OBJECT(dev), PC_DIMM_SIZE_PROP,
|
||||
NULL);
|
||||
int slot = object_property_get_int(OBJECT(dev), PC_DIMM_SLOT_PROP,
|
||||
NULL);
|
||||
uint32_t handle = nvdimm_slot_to_handle(slot);
|
||||
|
@@ -37,7 +37,6 @@
|
||||
#include "hw/pci/pci_bus.h"
|
||||
#include "qapi/error.h"
|
||||
#include "qom/qom-qobject.h"
|
||||
#include "qapi/qmp/qint.h"
|
||||
|
||||
//#define DEBUG
|
||||
|
||||
@@ -63,10 +62,10 @@ typedef struct AcpiPciHpFind {
|
||||
static int acpi_pcihp_get_bsel(PCIBus *bus)
|
||||
{
|
||||
Error *local_err = NULL;
|
||||
int64_t bsel = object_property_get_int(OBJECT(bus), ACPI_PCIHP_PROP_BSEL,
|
||||
&local_err);
|
||||
uint64_t bsel = object_property_get_uint(OBJECT(bus), ACPI_PCIHP_PROP_BSEL,
|
||||
&local_err);
|
||||
|
||||
if (local_err || bsel < 0 || bsel >= ACPI_PCIHP_MAX_HOTPLUG_BUS) {
|
||||
if (local_err || bsel >= ACPI_PCIHP_MAX_HOTPLUG_BUS) {
|
||||
if (local_err) {
|
||||
error_free(local_err);
|
||||
}
|
||||
|
@@ -180,8 +180,8 @@ static void aspeed_board_init(MachineState *machine,
|
||||
|
||||
sc = ASPEED_SOC_GET_CLASS(&bmc->soc);
|
||||
|
||||
object_property_set_int(OBJECT(&bmc->soc), ram_size, "ram-size",
|
||||
&error_abort);
|
||||
object_property_set_uint(OBJECT(&bmc->soc), ram_size, "ram-size",
|
||||
&error_abort);
|
||||
object_property_set_int(OBJECT(&bmc->soc), cfg->hw_strap1, "hw-strap1",
|
||||
&error_abort);
|
||||
object_property_set_int(OBJECT(&bmc->soc), cfg->num_cs, "num-cs",
|
||||
@@ -193,8 +193,8 @@ static void aspeed_board_init(MachineState *machine,
|
||||
* Allocate RAM after the memory controller has checked the size
|
||||
* was valid. If not, a default value is used.
|
||||
*/
|
||||
ram_size = object_property_get_int(OBJECT(&bmc->soc), "ram-size",
|
||||
&error_abort);
|
||||
ram_size = object_property_get_uint(OBJECT(&bmc->soc), "ram-size",
|
||||
&error_abort);
|
||||
|
||||
memory_region_allocate_system_memory(&bmc->ram, NULL, "ram", ram_size);
|
||||
memory_region_add_subregion(get_system_memory(), sc->info->sdram_base,
|
||||
|
@@ -125,7 +125,7 @@ static void bcm2835_peripherals_realize(DeviceState *dev, Error **errp)
|
||||
Object *obj;
|
||||
MemoryRegion *ram;
|
||||
Error *err = NULL;
|
||||
uint32_t ram_size, vcram_size;
|
||||
uint64_t ram_size, vcram_size;
|
||||
int n;
|
||||
|
||||
obj = object_property_get_link(OBJECT(dev), "ram", &err);
|
||||
@@ -207,15 +207,14 @@ static void bcm2835_peripherals_realize(DeviceState *dev, Error **errp)
|
||||
INTERRUPT_ARM_MAILBOX));
|
||||
|
||||
/* Framebuffer */
|
||||
vcram_size = (uint32_t)object_property_get_int(OBJECT(s), "vcram-size",
|
||||
&err);
|
||||
vcram_size = object_property_get_uint(OBJECT(s), "vcram-size", &err);
|
||||
if (err) {
|
||||
error_propagate(errp, err);
|
||||
return;
|
||||
}
|
||||
|
||||
object_property_set_int(OBJECT(&s->fb), ram_size - vcram_size,
|
||||
"vcram-base", &err);
|
||||
object_property_set_uint(OBJECT(&s->fb), ram_size - vcram_size,
|
||||
"vcram-base", &err);
|
||||
if (err) {
|
||||
error_propagate(errp, err);
|
||||
return;
|
||||
|
@@ -153,8 +153,8 @@ static void raspi2_init(MachineState *machine)
|
||||
qdev_prop_set_drive(carddev, "drive", blk, &error_fatal);
|
||||
object_property_set_bool(OBJECT(carddev), true, "realized", &error_fatal);
|
||||
|
||||
vcram_size = object_property_get_int(OBJECT(&s->soc), "vcram-size",
|
||||
&error_abort);
|
||||
vcram_size = object_property_get_uint(OBJECT(&s->soc), "vcram-size",
|
||||
&error_abort);
|
||||
setup_boot(machine, 2, machine->ram_size - vcram_size);
|
||||
}
|
||||
|
||||
|
@@ -511,7 +511,7 @@ typedef struct FloppyDrive {
|
||||
static Property floppy_drive_properties[] = {
|
||||
DEFINE_PROP_UINT32("unit", FloppyDrive, unit, -1),
|
||||
DEFINE_BLOCK_PROPERTIES(FloppyDrive, conf),
|
||||
DEFINE_PROP_DEFAULT("drive-type", FloppyDrive, type,
|
||||
DEFINE_PROP_SIGNED("drive-type", FloppyDrive, type,
|
||||
FLOPPY_DRIVE_TYPE_AUTO, qdev_prop_fdc_drive_type,
|
||||
FloppyDriveType),
|
||||
DEFINE_PROP_END_OF_LIST(),
|
||||
@@ -2805,13 +2805,13 @@ static Property isa_fdc_properties[] = {
|
||||
DEFINE_PROP_DRIVE("driveB", FDCtrlISABus, state.qdev_for_drives[1].blk),
|
||||
DEFINE_PROP_BIT("check_media_rate", FDCtrlISABus, state.check_media_rate,
|
||||
0, true),
|
||||
DEFINE_PROP_DEFAULT("fdtypeA", FDCtrlISABus, state.qdev_for_drives[0].type,
|
||||
DEFINE_PROP_SIGNED("fdtypeA", FDCtrlISABus, state.qdev_for_drives[0].type,
|
||||
FLOPPY_DRIVE_TYPE_AUTO, qdev_prop_fdc_drive_type,
|
||||
FloppyDriveType),
|
||||
DEFINE_PROP_DEFAULT("fdtypeB", FDCtrlISABus, state.qdev_for_drives[1].type,
|
||||
DEFINE_PROP_SIGNED("fdtypeB", FDCtrlISABus, state.qdev_for_drives[1].type,
|
||||
FLOPPY_DRIVE_TYPE_AUTO, qdev_prop_fdc_drive_type,
|
||||
FloppyDriveType),
|
||||
DEFINE_PROP_DEFAULT("fallback", FDCtrlISABus, state.fallback,
|
||||
DEFINE_PROP_SIGNED("fallback", FDCtrlISABus, state.fallback,
|
||||
FLOPPY_DRIVE_TYPE_288, qdev_prop_fdc_drive_type,
|
||||
FloppyDriveType),
|
||||
DEFINE_PROP_END_OF_LIST(),
|
||||
@@ -2862,13 +2862,13 @@ static const VMStateDescription vmstate_sysbus_fdc ={
|
||||
static Property sysbus_fdc_properties[] = {
|
||||
DEFINE_PROP_DRIVE("driveA", FDCtrlSysBus, state.qdev_for_drives[0].blk),
|
||||
DEFINE_PROP_DRIVE("driveB", FDCtrlSysBus, state.qdev_for_drives[1].blk),
|
||||
DEFINE_PROP_DEFAULT("fdtypeA", FDCtrlSysBus, state.qdev_for_drives[0].type,
|
||||
DEFINE_PROP_SIGNED("fdtypeA", FDCtrlSysBus, state.qdev_for_drives[0].type,
|
||||
FLOPPY_DRIVE_TYPE_AUTO, qdev_prop_fdc_drive_type,
|
||||
FloppyDriveType),
|
||||
DEFINE_PROP_DEFAULT("fdtypeB", FDCtrlSysBus, state.qdev_for_drives[1].type,
|
||||
DEFINE_PROP_SIGNED("fdtypeB", FDCtrlSysBus, state.qdev_for_drives[1].type,
|
||||
FLOPPY_DRIVE_TYPE_AUTO, qdev_prop_fdc_drive_type,
|
||||
FloppyDriveType),
|
||||
DEFINE_PROP_DEFAULT("fallback", FDCtrlISABus, state.fallback,
|
||||
DEFINE_PROP_SIGNED("fallback", FDCtrlISABus, state.fallback,
|
||||
FLOPPY_DRIVE_TYPE_144, qdev_prop_fdc_drive_type,
|
||||
FloppyDriveType),
|
||||
DEFINE_PROP_END_OF_LIST(),
|
||||
@@ -2891,10 +2891,10 @@ static const TypeInfo sysbus_fdc_info = {
|
||||
|
||||
static Property sun4m_fdc_properties[] = {
|
||||
DEFINE_PROP_DRIVE("drive", FDCtrlSysBus, state.qdev_for_drives[0].blk),
|
||||
DEFINE_PROP_DEFAULT("fdtype", FDCtrlSysBus, state.qdev_for_drives[0].type,
|
||||
DEFINE_PROP_SIGNED("fdtype", FDCtrlSysBus, state.qdev_for_drives[0].type,
|
||||
FLOPPY_DRIVE_TYPE_AUTO, qdev_prop_fdc_drive_type,
|
||||
FloppyDriveType),
|
||||
DEFINE_PROP_DEFAULT("fallback", FDCtrlISABus, state.fallback,
|
||||
DEFINE_PROP_SIGNED("fallback", FDCtrlISABus, state.fallback,
|
||||
FLOPPY_DRIVE_TYPE_144, qdev_prop_fdc_drive_type,
|
||||
FloppyDriveType),
|
||||
DEFINE_PROP_END_OF_LIST(),
|
||||
|
@@ -71,7 +71,7 @@ hwaddr platform_bus_get_mmio_addr(PlatformBusDevice *pbus, SysBusDevice *sbdev,
|
||||
return -1;
|
||||
}
|
||||
|
||||
return object_property_get_int(OBJECT(sbdev_mr), "addr", NULL);
|
||||
return object_property_get_uint(OBJECT(sbdev_mr), "addr", NULL);
|
||||
}
|
||||
|
||||
static void platform_bus_count_irqs(SysBusDevice *sbdev, void *opaque)
|
||||
|
@@ -69,6 +69,12 @@ static void set_enum(Object *obj, Visitor *v, const char *name, void *opaque,
|
||||
visit_type_enum(v, prop->name, ptr, prop->info->enum_table, errp);
|
||||
}
|
||||
|
||||
static void set_default_value_enum(Object *obj, const Property *prop)
|
||||
{
|
||||
object_property_set_str(obj, prop->info->enum_table[prop->defval.i],
|
||||
prop->name, &error_abort);
|
||||
}
|
||||
|
||||
/* Bit */
|
||||
|
||||
static uint32_t qdev_get_prop_mask(Property *prop)
|
||||
@@ -120,11 +126,17 @@ static void prop_set_bit(Object *obj, Visitor *v, const char *name,
|
||||
bit_prop_set(dev, prop, value);
|
||||
}
|
||||
|
||||
static void set_default_value_bool(Object *obj, const Property *prop)
|
||||
{
|
||||
object_property_set_bool(obj, prop->defval.u, prop->name, &error_abort);
|
||||
}
|
||||
|
||||
PropertyInfo qdev_prop_bit = {
|
||||
.name = "bool",
|
||||
.description = "on/off",
|
||||
.get = prop_get_bit,
|
||||
.set = prop_set_bit,
|
||||
.set_default_value = set_default_value_bool,
|
||||
};
|
||||
|
||||
/* Bit64 */
|
||||
@@ -183,6 +195,7 @@ PropertyInfo qdev_prop_bit64 = {
|
||||
.description = "on/off",
|
||||
.get = prop_get_bit64,
|
||||
.set = prop_set_bit64,
|
||||
.set_default_value = set_default_value_bool,
|
||||
};
|
||||
|
||||
/* --- bool --- */
|
||||
@@ -216,6 +229,7 @@ PropertyInfo qdev_prop_bool = {
|
||||
.name = "bool",
|
||||
.get = get_bool,
|
||||
.set = set_bool,
|
||||
.set_default_value = set_default_value_bool,
|
||||
};
|
||||
|
||||
/* --- 8bit integer --- */
|
||||
@@ -245,10 +259,21 @@ static void set_uint8(Object *obj, Visitor *v, const char *name, void *opaque,
|
||||
visit_type_uint8(v, name, ptr, errp);
|
||||
}
|
||||
|
||||
static void set_default_value_int(Object *obj, const Property *prop)
|
||||
{
|
||||
object_property_set_int(obj, prop->defval.i, prop->name, &error_abort);
|
||||
}
|
||||
|
||||
static void set_default_value_uint(Object *obj, const Property *prop)
|
||||
{
|
||||
object_property_set_uint(obj, prop->defval.u, prop->name, &error_abort);
|
||||
}
|
||||
|
||||
PropertyInfo qdev_prop_uint8 = {
|
||||
.name = "uint8",
|
||||
.get = get_uint8,
|
||||
.set = set_uint8,
|
||||
.set_default_value = set_default_value_uint,
|
||||
};
|
||||
|
||||
/* --- 16bit integer --- */
|
||||
@@ -282,6 +307,7 @@ PropertyInfo qdev_prop_uint16 = {
|
||||
.name = "uint16",
|
||||
.get = get_uint16,
|
||||
.set = set_uint16,
|
||||
.set_default_value = set_default_value_uint,
|
||||
};
|
||||
|
||||
/* --- 32bit integer --- */
|
||||
@@ -340,12 +366,14 @@ PropertyInfo qdev_prop_uint32 = {
|
||||
.name = "uint32",
|
||||
.get = get_uint32,
|
||||
.set = set_uint32,
|
||||
.set_default_value = set_default_value_uint,
|
||||
};
|
||||
|
||||
PropertyInfo qdev_prop_int32 = {
|
||||
.name = "int32",
|
||||
.get = get_int32,
|
||||
.set = set_int32,
|
||||
.set_default_value = set_default_value_int,
|
||||
};
|
||||
|
||||
/* --- 64bit integer --- */
|
||||
@@ -379,6 +407,7 @@ PropertyInfo qdev_prop_uint64 = {
|
||||
.name = "uint64",
|
||||
.get = get_uint64,
|
||||
.set = set_uint64,
|
||||
.set_default_value = set_default_value_uint,
|
||||
};
|
||||
|
||||
/* --- string --- */
|
||||
@@ -526,6 +555,7 @@ PropertyInfo qdev_prop_on_off_auto = {
|
||||
.enum_table = OnOffAuto_lookup,
|
||||
.get = get_enum,
|
||||
.set = set_enum,
|
||||
.set_default_value = set_default_value_enum,
|
||||
};
|
||||
|
||||
/* --- lost tick policy --- */
|
||||
@@ -537,6 +567,7 @@ PropertyInfo qdev_prop_losttickpolicy = {
|
||||
.enum_table = LostTickPolicy_lookup,
|
||||
.get = get_enum,
|
||||
.set = set_enum,
|
||||
.set_default_value = set_default_value_enum,
|
||||
};
|
||||
|
||||
/* --- Block device error handling policy --- */
|
||||
@@ -550,6 +581,7 @@ PropertyInfo qdev_prop_blockdev_on_error = {
|
||||
.enum_table = BlockdevOnError_lookup,
|
||||
.get = get_enum,
|
||||
.set = set_enum,
|
||||
.set_default_value = set_default_value_enum,
|
||||
};
|
||||
|
||||
/* --- BIOS CHS translation */
|
||||
@@ -563,6 +595,7 @@ PropertyInfo qdev_prop_bios_chs_trans = {
|
||||
.enum_table = BiosAtaTranslation_lookup,
|
||||
.get = get_enum,
|
||||
.set = set_enum,
|
||||
.set_default_value = set_default_value_enum,
|
||||
};
|
||||
|
||||
/* --- FDC default drive types */
|
||||
@@ -573,7 +606,8 @@ PropertyInfo qdev_prop_fdc_drive_type = {
|
||||
"144/288/120/none/auto",
|
||||
.enum_table = FloppyDriveType_lookup,
|
||||
.get = get_enum,
|
||||
.set = set_enum
|
||||
.set = set_enum,
|
||||
.set_default_value = set_default_value_enum,
|
||||
};
|
||||
|
||||
/* --- pci address --- */
|
||||
@@ -648,6 +682,7 @@ PropertyInfo qdev_prop_pci_devfn = {
|
||||
.print = print_pci_devfn,
|
||||
.get = get_int32,
|
||||
.set = set_pci_devfn,
|
||||
.set_default_value = set_default_value_int,
|
||||
};
|
||||
|
||||
/* --- blocksize --- */
|
||||
@@ -695,6 +730,7 @@ PropertyInfo qdev_prop_blocksize = {
|
||||
.description = "A power of two between 512 and 32768",
|
||||
.get = get_uint16,
|
||||
.set = set_blocksize,
|
||||
.set_default_value = set_default_value_uint,
|
||||
};
|
||||
|
||||
/* --- pci host address --- */
|
||||
@@ -917,6 +953,7 @@ PropertyInfo qdev_prop_arraylen = {
|
||||
.name = "uint32",
|
||||
.get = get_uint32,
|
||||
.set = set_prop_arraylen,
|
||||
.set_default_value = set_default_value_uint,
|
||||
};
|
||||
|
||||
/* --- public helpers --- */
|
||||
@@ -1153,4 +1190,5 @@ PropertyInfo qdev_prop_size = {
|
||||
.name = "size",
|
||||
.get = get_size,
|
||||
.set = set_size,
|
||||
.set_default_value = set_default_value_uint,
|
||||
};
|
||||
|
@@ -793,17 +793,8 @@ void qdev_property_add_static(DeviceState *dev, Property *prop,
|
||||
prop->info->description,
|
||||
&error_abort);
|
||||
|
||||
if (prop->qtype == QTYPE_NONE) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (prop->qtype == QTYPE_QBOOL) {
|
||||
object_property_set_bool(obj, prop->defval, prop->name, &error_abort);
|
||||
} else if (prop->info->enum_table) {
|
||||
object_property_set_str(obj, prop->info->enum_table[prop->defval],
|
||||
prop->name, &error_abort);
|
||||
} else if (prop->qtype == QTYPE_QINT) {
|
||||
object_property_set_int(obj, prop->defval, prop->name, &error_abort);
|
||||
if (prop->info->set_default_value) {
|
||||
prop->info->set_default_value(obj, prop);
|
||||
}
|
||||
}
|
||||
|
||||
|
@@ -57,7 +57,6 @@
|
||||
|
||||
#include "hw/acpi/aml-build.h"
|
||||
|
||||
#include "qapi/qmp/qint.h"
|
||||
#include "qom/qom-qobject.h"
|
||||
#include "hw/i386/amd_iommu.h"
|
||||
#include "hw/i386/intel_iommu.h"
|
||||
@@ -137,9 +136,9 @@ static void acpi_get_pm_info(AcpiPmInfo *pm)
|
||||
obj = piix;
|
||||
pm->cpu_hp_io_base = PIIX4_CPU_HOTPLUG_IO_BASE;
|
||||
pm->pcihp_io_base =
|
||||
object_property_get_int(obj, ACPI_PCIHP_IO_BASE_PROP, NULL);
|
||||
object_property_get_uint(obj, ACPI_PCIHP_IO_BASE_PROP, NULL);
|
||||
pm->pcihp_io_len =
|
||||
object_property_get_int(obj, ACPI_PCIHP_IO_LEN_PROP, NULL);
|
||||
object_property_get_uint(obj, ACPI_PCIHP_IO_LEN_PROP, NULL);
|
||||
}
|
||||
if (lpc) {
|
||||
obj = lpc;
|
||||
@@ -150,41 +149,42 @@ static void acpi_get_pm_info(AcpiPmInfo *pm)
|
||||
/* Fill in optional s3/s4 related properties */
|
||||
o = object_property_get_qobject(obj, ACPI_PM_PROP_S3_DISABLED, NULL);
|
||||
if (o) {
|
||||
pm->s3_disabled = qint_get_int(qobject_to_qint(o));
|
||||
pm->s3_disabled = qnum_get_uint(qobject_to_qnum(o));
|
||||
} else {
|
||||
pm->s3_disabled = false;
|
||||
}
|
||||
qobject_decref(o);
|
||||
o = object_property_get_qobject(obj, ACPI_PM_PROP_S4_DISABLED, NULL);
|
||||
if (o) {
|
||||
pm->s4_disabled = qint_get_int(qobject_to_qint(o));
|
||||
pm->s4_disabled = qnum_get_uint(qobject_to_qnum(o));
|
||||
} else {
|
||||
pm->s4_disabled = false;
|
||||
}
|
||||
qobject_decref(o);
|
||||
o = object_property_get_qobject(obj, ACPI_PM_PROP_S4_VAL, NULL);
|
||||
if (o) {
|
||||
pm->s4_val = qint_get_int(qobject_to_qint(o));
|
||||
pm->s4_val = qnum_get_uint(qobject_to_qnum(o));
|
||||
} else {
|
||||
pm->s4_val = false;
|
||||
}
|
||||
qobject_decref(o);
|
||||
|
||||
/* Fill in mandatory properties */
|
||||
pm->sci_int = object_property_get_int(obj, ACPI_PM_PROP_SCI_INT, NULL);
|
||||
pm->sci_int = object_property_get_uint(obj, ACPI_PM_PROP_SCI_INT, NULL);
|
||||
|
||||
pm->acpi_enable_cmd = object_property_get_int(obj,
|
||||
ACPI_PM_PROP_ACPI_ENABLE_CMD,
|
||||
NULL);
|
||||
pm->acpi_disable_cmd = object_property_get_int(obj,
|
||||
ACPI_PM_PROP_ACPI_DISABLE_CMD,
|
||||
NULL);
|
||||
pm->io_base = object_property_get_int(obj, ACPI_PM_PROP_PM_IO_BASE,
|
||||
NULL);
|
||||
pm->gpe0_blk = object_property_get_int(obj, ACPI_PM_PROP_GPE0_BLK,
|
||||
pm->acpi_enable_cmd = object_property_get_uint(obj,
|
||||
ACPI_PM_PROP_ACPI_ENABLE_CMD,
|
||||
NULL);
|
||||
pm->acpi_disable_cmd =
|
||||
object_property_get_uint(obj,
|
||||
ACPI_PM_PROP_ACPI_DISABLE_CMD,
|
||||
NULL);
|
||||
pm->io_base = object_property_get_uint(obj, ACPI_PM_PROP_PM_IO_BASE,
|
||||
NULL);
|
||||
pm->gpe0_blk_len = object_property_get_int(obj, ACPI_PM_PROP_GPE0_BLK_LEN,
|
||||
NULL);
|
||||
pm->gpe0_blk = object_property_get_uint(obj, ACPI_PM_PROP_GPE0_BLK,
|
||||
NULL);
|
||||
pm->gpe0_blk_len = object_property_get_uint(obj, ACPI_PM_PROP_GPE0_BLK_LEN,
|
||||
NULL);
|
||||
pm->pcihp_bridge_en =
|
||||
object_property_get_bool(obj, "acpi-pci-hotplug-with-bridge-support",
|
||||
NULL);
|
||||
@@ -237,19 +237,19 @@ static void acpi_get_pci_holes(Range *hole, Range *hole64)
|
||||
g_assert(pci_host);
|
||||
|
||||
range_set_bounds1(hole,
|
||||
object_property_get_int(pci_host,
|
||||
PCI_HOST_PROP_PCI_HOLE_START,
|
||||
NULL),
|
||||
object_property_get_int(pci_host,
|
||||
PCI_HOST_PROP_PCI_HOLE_END,
|
||||
NULL));
|
||||
object_property_get_uint(pci_host,
|
||||
PCI_HOST_PROP_PCI_HOLE_START,
|
||||
NULL),
|
||||
object_property_get_uint(pci_host,
|
||||
PCI_HOST_PROP_PCI_HOLE_END,
|
||||
NULL));
|
||||
range_set_bounds1(hole64,
|
||||
object_property_get_int(pci_host,
|
||||
PCI_HOST_PROP_PCI_HOLE64_START,
|
||||
NULL),
|
||||
object_property_get_int(pci_host,
|
||||
PCI_HOST_PROP_PCI_HOLE64_END,
|
||||
NULL));
|
||||
object_property_get_uint(pci_host,
|
||||
PCI_HOST_PROP_PCI_HOLE64_START,
|
||||
NULL),
|
||||
object_property_get_uint(pci_host,
|
||||
PCI_HOST_PROP_PCI_HOLE64_END,
|
||||
NULL));
|
||||
}
|
||||
|
||||
#define ACPI_PORT_SMI_CMD 0x00b2 /* TODO: this is APM_CNT_IOPORT */
|
||||
@@ -529,7 +529,7 @@ static void build_append_pci_bus_devices(Aml *parent_scope, PCIBus *bus,
|
||||
|
||||
bsel = object_property_get_qobject(OBJECT(bus), ACPI_PCIHP_PROP_BSEL, NULL);
|
||||
if (bsel) {
|
||||
int64_t bsel_val = qint_get_int(qobject_to_qint(bsel));
|
||||
uint64_t bsel_val = qnum_get_uint(qobject_to_qnum(bsel));
|
||||
|
||||
aml_append(parent_scope, aml_name_decl("BSEL", aml_int(bsel_val)));
|
||||
notify_method = aml_method("DVNT", 2, AML_NOTSERIALIZED);
|
||||
@@ -639,7 +639,8 @@ static void build_append_pci_bus_devices(Aml *parent_scope, PCIBus *bus,
|
||||
|
||||
/* If bus supports hotplug select it and notify about local events */
|
||||
if (bsel) {
|
||||
int64_t bsel_val = qint_get_int(qobject_to_qint(bsel));
|
||||
uint64_t bsel_val = qnum_get_uint(qobject_to_qnum(bsel));
|
||||
|
||||
aml_append(method, aml_store(aml_int(bsel_val), aml_name("BNUM")));
|
||||
aml_append(method,
|
||||
aml_call2("DVNT", aml_name("PCIU"), aml_int(1) /* Device Check */)
|
||||
@@ -2614,12 +2615,12 @@ static bool acpi_get_mcfg(AcpiMcfgInfo *mcfg)
|
||||
if (!o) {
|
||||
return false;
|
||||
}
|
||||
mcfg->mcfg_base = qint_get_int(qobject_to_qint(o));
|
||||
mcfg->mcfg_base = qnum_get_uint(qobject_to_qnum(o));
|
||||
qobject_decref(o);
|
||||
|
||||
o = object_property_get_qobject(pci_host, PCIE_HOST_MCFG_SIZE, NULL);
|
||||
assert(o);
|
||||
mcfg->mcfg_size = qint_get_int(qobject_to_qint(o));
|
||||
mcfg->mcfg_size = qnum_get_uint(qobject_to_qnum(o));
|
||||
qobject_decref(o);
|
||||
return true;
|
||||
}
|
||||
|
@@ -347,7 +347,7 @@ static int check_fdc(Object *obj, void *opaque)
|
||||
return 0;
|
||||
}
|
||||
|
||||
iobase = object_property_get_int(obj, "iobase", &local_err);
|
||||
iobase = object_property_get_uint(obj, "iobase", &local_err);
|
||||
if (local_err || iobase != 0x3f0) {
|
||||
error_free(local_err);
|
||||
return 0;
|
||||
@@ -1098,7 +1098,7 @@ static void pc_new_cpu(const char *typename, int64_t apic_id, Error **errp)
|
||||
|
||||
cpu = object_new(typename);
|
||||
|
||||
object_property_set_int(cpu, apic_id, "apic-id", &local_err);
|
||||
object_property_set_uint(cpu, apic_id, "apic-id", &local_err);
|
||||
object_property_set_bool(cpu, true, "realized", &local_err);
|
||||
|
||||
object_unref(cpu);
|
||||
@@ -1558,7 +1558,7 @@ void pc_basic_device_init(ISABus *isa_bus, qemu_irq *gsi,
|
||||
* and earlier, use IRQ2 for compat. Otherwise, use IRQ16~23,
|
||||
* IRQ8 and IRQ2.
|
||||
*/
|
||||
uint8_t compat = object_property_get_int(OBJECT(hpet),
|
||||
uint8_t compat = object_property_get_uint(OBJECT(hpet),
|
||||
HPET_INTCAP, NULL);
|
||||
if (!compat) {
|
||||
qdev_prop_set_uint32(hpet, HPET_INTCAP, hpet_irqs);
|
||||
|
@@ -182,9 +182,9 @@ static void xen_ram_init(PCMachineState *pcms,
|
||||
{
|
||||
MemoryRegion *sysmem = get_system_memory();
|
||||
ram_addr_t block_len;
|
||||
uint64_t user_lowmem = object_property_get_int(qdev_get_machine(),
|
||||
PC_MACHINE_MAX_RAM_BELOW_4G,
|
||||
&error_abort);
|
||||
uint64_t user_lowmem = object_property_get_uint(qdev_get_machine(),
|
||||
PC_MACHINE_MAX_RAM_BELOW_4G,
|
||||
&error_abort);
|
||||
|
||||
/* Handle the machine opt max-ram-below-4g. It is basically doing
|
||||
* min(xen limit, user limit).
|
||||
|
@@ -487,6 +487,7 @@ void hid_reset(HIDState *hs)
|
||||
memset(hs->kbd.keycodes, 0, sizeof(hs->kbd.keycodes));
|
||||
memset(hs->kbd.key, 0, sizeof(hs->kbd.key));
|
||||
hs->kbd.keys = 0;
|
||||
hs->kbd.modifiers = 0;
|
||||
break;
|
||||
case HID_MOUSE:
|
||||
case HID_TABLET:
|
||||
|
@@ -85,12 +85,12 @@ typedef struct {
|
||||
int rptr, wptr, count;
|
||||
} PS2Queue;
|
||||
|
||||
typedef struct {
|
||||
struct PS2State {
|
||||
PS2Queue queue;
|
||||
int32_t write_cmd;
|
||||
void (*update_irq)(void *, int);
|
||||
void *update_arg;
|
||||
} PS2State;
|
||||
};
|
||||
|
||||
typedef struct {
|
||||
PS2State common;
|
||||
@@ -551,9 +551,17 @@ static uint8_t translate_table[256] = {
|
||||
0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
|
||||
};
|
||||
|
||||
void ps2_queue(void *opaque, int b)
|
||||
static void ps2_reset_queue(PS2State *s)
|
||||
{
|
||||
PS2Queue *q = &s->queue;
|
||||
|
||||
q->rptr = 0;
|
||||
q->wptr = 0;
|
||||
q->count = 0;
|
||||
}
|
||||
|
||||
void ps2_queue(PS2State *s, int b)
|
||||
{
|
||||
PS2State *s = (PS2State *)opaque;
|
||||
PS2Queue *q = &s->queue;
|
||||
|
||||
if (q->count >= PS2_QUEUE_SIZE - 1)
|
||||
@@ -692,13 +700,12 @@ static void ps2_keyboard_event(DeviceState *dev, QemuConsole *src,
|
||||
}
|
||||
}
|
||||
|
||||
uint32_t ps2_read_data(void *opaque)
|
||||
uint32_t ps2_read_data(PS2State *s)
|
||||
{
|
||||
PS2State *s = (PS2State *)opaque;
|
||||
PS2Queue *q;
|
||||
int val, index;
|
||||
|
||||
trace_ps2_read_data(opaque);
|
||||
trace_ps2_read_data(s);
|
||||
q = &s->queue;
|
||||
if (q->count == 0) {
|
||||
/* NOTE: if no data left, we return the last keyboard one
|
||||
@@ -733,6 +740,7 @@ static void ps2_reset_keyboard(PS2KbdState *s)
|
||||
trace_ps2_reset_keyboard(s);
|
||||
s->scan_enabled = 1;
|
||||
s->scancode_set = 2;
|
||||
ps2_reset_queue(&s->common);
|
||||
ps2_set_ledstate(s, 0);
|
||||
}
|
||||
|
||||
@@ -1081,12 +1089,8 @@ void ps2_write_mouse(void *opaque, int val)
|
||||
|
||||
static void ps2_common_reset(PS2State *s)
|
||||
{
|
||||
PS2Queue *q;
|
||||
s->write_cmd = -1;
|
||||
q = &s->queue;
|
||||
q->rptr = 0;
|
||||
q->wptr = 0;
|
||||
q->count = 0;
|
||||
ps2_reset_queue(s);
|
||||
s->update_irq(s->update_arg, 0);
|
||||
}
|
||||
|
||||
|
@@ -450,10 +450,10 @@ static void apic_common_get_id(Object *obj, Visitor *v, const char *name,
|
||||
void *opaque, Error **errp)
|
||||
{
|
||||
APICCommonState *s = APIC_COMMON(obj);
|
||||
int64_t value;
|
||||
uint32_t value;
|
||||
|
||||
value = s->apicbase & MSR_IA32_APICBASE_EXTD ? s->initial_apic_id : s->id;
|
||||
visit_type_int(v, name, &value, errp);
|
||||
visit_type_uint32(v, name, &value, errp);
|
||||
}
|
||||
|
||||
static void apic_common_set_id(Object *obj, Visitor *v, const char *name,
|
||||
@@ -462,14 +462,14 @@ static void apic_common_set_id(Object *obj, Visitor *v, const char *name,
|
||||
APICCommonState *s = APIC_COMMON(obj);
|
||||
DeviceState *dev = DEVICE(obj);
|
||||
Error *local_err = NULL;
|
||||
int64_t value;
|
||||
uint32_t value;
|
||||
|
||||
if (dev->realized) {
|
||||
qdev_prop_set_after_realize(dev, name, errp);
|
||||
return;
|
||||
}
|
||||
|
||||
visit_type_int(v, name, &value, &local_err);
|
||||
visit_type_uint32(v, name, &value, &local_err);
|
||||
if (local_err) {
|
||||
error_propagate(errp, local_err);
|
||||
return;
|
||||
@@ -484,7 +484,7 @@ static void apic_common_initfn(Object *obj)
|
||||
APICCommonState *s = APIC_COMMON(obj);
|
||||
|
||||
s->id = s->initial_apic_id = -1;
|
||||
object_property_add(obj, "id", "int",
|
||||
object_property_add(obj, "id", "uint32",
|
||||
apic_common_get_id,
|
||||
apic_common_set_id, NULL, NULL, NULL);
|
||||
}
|
||||
|
@@ -268,7 +268,7 @@ static void arm_gicv3_common_realize(DeviceState *dev, Error **errp)
|
||||
* VLPIS == 0 (virtual LPIs not supported)
|
||||
* PLPIS == 0 (physical LPIs not supported)
|
||||
*/
|
||||
cpu_affid = object_property_get_int(OBJECT(cpu), "mp-affinity", NULL);
|
||||
cpu_affid = object_property_get_uint(OBJECT(cpu), "mp-affinity", NULL);
|
||||
last = (i == s->num_cpu - 1);
|
||||
|
||||
/* The CPU mp-affinity property is in MPIDR register format; squash
|
||||
|
@@ -46,7 +46,8 @@ void pc_dimm_memory_plug(DeviceState *dev, MemoryHotplugState *hpms,
|
||||
uint64_t existing_dimms_capacity = 0;
|
||||
uint64_t addr;
|
||||
|
||||
addr = object_property_get_int(OBJECT(dimm), PC_DIMM_ADDR_PROP, &local_err);
|
||||
addr = object_property_get_uint(OBJECT(dimm),
|
||||
PC_DIMM_ADDR_PROP, &local_err);
|
||||
if (local_err) {
|
||||
goto out;
|
||||
}
|
||||
@@ -73,7 +74,7 @@ void pc_dimm_memory_plug(DeviceState *dev, MemoryHotplugState *hpms,
|
||||
goto out;
|
||||
}
|
||||
|
||||
object_property_set_int(OBJECT(dev), addr, PC_DIMM_ADDR_PROP, &local_err);
|
||||
object_property_set_uint(OBJECT(dev), addr, PC_DIMM_ADDR_PROP, &local_err);
|
||||
if (local_err) {
|
||||
goto out;
|
||||
}
|
||||
@@ -135,7 +136,7 @@ static int pc_existing_dimms_capacity_internal(Object *obj, void *opaque)
|
||||
DeviceState *dev = DEVICE(obj);
|
||||
|
||||
if (dev->realized) {
|
||||
(*size) += object_property_get_int(obj, PC_DIMM_SIZE_PROP,
|
||||
(*size) += object_property_get_uint(obj, PC_DIMM_SIZE_PROP,
|
||||
cap->errp);
|
||||
}
|
||||
|
||||
@@ -181,8 +182,8 @@ int qmp_pc_dimm_device_list(Object *obj, void *opaque)
|
||||
di->addr = dimm->addr;
|
||||
di->slot = dimm->slot;
|
||||
di->node = dimm->node;
|
||||
di->size = object_property_get_int(OBJECT(dimm), PC_DIMM_SIZE_PROP,
|
||||
NULL);
|
||||
di->size = object_property_get_uint(OBJECT(dimm), PC_DIMM_SIZE_PROP,
|
||||
NULL);
|
||||
di->memdev = object_get_canonical_path(OBJECT(dimm->hostmem));
|
||||
|
||||
info->u.dimm.data = di;
|
||||
@@ -313,9 +314,9 @@ uint64_t pc_dimm_get_free_addr(uint64_t address_space_start,
|
||||
/* find address range that will fit new DIMM */
|
||||
for (item = list; item; item = g_slist_next(item)) {
|
||||
PCDIMMDevice *dimm = item->data;
|
||||
uint64_t dimm_size = object_property_get_int(OBJECT(dimm),
|
||||
PC_DIMM_SIZE_PROP,
|
||||
errp);
|
||||
uint64_t dimm_size = object_property_get_uint(OBJECT(dimm),
|
||||
PC_DIMM_SIZE_PROP,
|
||||
errp);
|
||||
if (errp && *errp) {
|
||||
goto out;
|
||||
}
|
||||
@@ -355,7 +356,7 @@ static Property pc_dimm_properties[] = {
|
||||
static void pc_dimm_get_size(Object *obj, Visitor *v, const char *name,
|
||||
void *opaque, Error **errp)
|
||||
{
|
||||
int64_t value;
|
||||
uint64_t value;
|
||||
MemoryRegion *mr;
|
||||
PCDIMMDevice *dimm = PC_DIMM(obj);
|
||||
PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(obj);
|
||||
@@ -363,7 +364,7 @@ static void pc_dimm_get_size(Object *obj, Visitor *v, const char *name,
|
||||
mr = ddc->get_memory_region(dimm);
|
||||
value = memory_region_size(mr);
|
||||
|
||||
visit_type_int(v, name, &value, errp);
|
||||
visit_type_uint64(v, name, &value, errp);
|
||||
}
|
||||
|
||||
static void pc_dimm_check_memdev_is_busy(Object *obj, const char *name,
|
||||
@@ -386,7 +387,7 @@ static void pc_dimm_init(Object *obj)
|
||||
{
|
||||
PCDIMMDevice *dimm = PC_DIMM(obj);
|
||||
|
||||
object_property_add(obj, PC_DIMM_SIZE_PROP, "int", pc_dimm_get_size,
|
||||
object_property_add(obj, PC_DIMM_SIZE_PROP, "uint64", pc_dimm_get_size,
|
||||
NULL, NULL, NULL, &error_abort);
|
||||
object_property_add_link(obj, PC_DIMM_MEMDEV_PROP, TYPE_MEMORY_BACKEND,
|
||||
(Object **)&dimm->hostmem,
|
||||
|
@@ -244,7 +244,7 @@ static void aux_slave_dev_print(Monitor *mon, DeviceState *dev, int indent)
|
||||
|
||||
monitor_printf(mon, "%*smemory " TARGET_FMT_plx "/" TARGET_FMT_plx "\n",
|
||||
indent, "",
|
||||
object_property_get_int(OBJECT(s->mmio), "addr", NULL),
|
||||
object_property_get_uint(OBJECT(s->mmio), "addr", NULL),
|
||||
memory_region_size(s->mmio));
|
||||
}
|
||||
|
||||
|
@@ -111,7 +111,7 @@ uint16_t pvpanic_port(void)
|
||||
if (!o) {
|
||||
return 0;
|
||||
}
|
||||
return object_property_get_int(o, PVPANIC_IOPORT_PROP, NULL);
|
||||
return object_property_get_uint(o, PVPANIC_IOPORT_PROP, NULL);
|
||||
}
|
||||
|
||||
static Property pvpanic_isa_properties[] = {
|
||||
|
@@ -645,12 +645,12 @@ static PropertyInfo e1000e_prop_disable_vnet,
|
||||
|
||||
static Property e1000e_properties[] = {
|
||||
DEFINE_NIC_PROPERTIES(E1000EState, conf),
|
||||
DEFINE_PROP_DEFAULT("disable_vnet_hdr", E1000EState, disable_vnet, false,
|
||||
DEFINE_PROP_SIGNED("disable_vnet_hdr", E1000EState, disable_vnet, false,
|
||||
e1000e_prop_disable_vnet, bool),
|
||||
DEFINE_PROP_DEFAULT("subsys_ven", E1000EState, subsys_ven,
|
||||
DEFINE_PROP_SIGNED("subsys_ven", E1000EState, subsys_ven,
|
||||
PCI_VENDOR_ID_INTEL,
|
||||
e1000e_prop_subsys_ven, uint16_t),
|
||||
DEFINE_PROP_DEFAULT("subsys", E1000EState, subsys, 0,
|
||||
DEFINE_PROP_SIGNED("subsys", E1000EState, subsys, 0,
|
||||
e1000e_prop_subsys, uint16_t),
|
||||
DEFINE_PROP_END_OF_LIST(),
|
||||
};
|
||||
|
@@ -94,7 +94,7 @@ static void gpex_host_initfn(Object *obj)
|
||||
|
||||
object_initialize(root, sizeof(*root), TYPE_GPEX_ROOT_DEVICE);
|
||||
object_property_add_child(obj, "gpex_root", OBJECT(root), NULL);
|
||||
qdev_prop_set_uint32(DEVICE(root), "addr", PCI_DEVFN(0, 0));
|
||||
qdev_prop_set_int32(DEVICE(root), "addr", PCI_DEVFN(0, 0));
|
||||
qdev_prop_set_bit(DEVICE(root), "multifunction", false);
|
||||
}
|
||||
|
||||
|
@@ -273,19 +273,19 @@ static void i440fx_pcihost_initfn(Object *obj)
|
||||
memory_region_init_io(&s->data_mem, obj, &pci_host_data_le_ops, s,
|
||||
"pci-conf-data", 4);
|
||||
|
||||
object_property_add(obj, PCI_HOST_PROP_PCI_HOLE_START, "int",
|
||||
object_property_add(obj, PCI_HOST_PROP_PCI_HOLE_START, "uint32",
|
||||
i440fx_pcihost_get_pci_hole_start,
|
||||
NULL, NULL, NULL, NULL);
|
||||
|
||||
object_property_add(obj, PCI_HOST_PROP_PCI_HOLE_END, "int",
|
||||
object_property_add(obj, PCI_HOST_PROP_PCI_HOLE_END, "uint32",
|
||||
i440fx_pcihost_get_pci_hole_end,
|
||||
NULL, NULL, NULL, NULL);
|
||||
|
||||
object_property_add(obj, PCI_HOST_PROP_PCI_HOLE64_START, "int",
|
||||
object_property_add(obj, PCI_HOST_PROP_PCI_HOLE64_START, "uint64",
|
||||
i440fx_pcihost_get_pci_hole64_start,
|
||||
NULL, NULL, NULL, NULL);
|
||||
|
||||
object_property_add(obj, PCI_HOST_PROP_PCI_HOLE64_END, "int",
|
||||
object_property_add(obj, PCI_HOST_PROP_PCI_HOLE64_END, "uint64",
|
||||
i440fx_pcihost_get_pci_hole64_end,
|
||||
NULL, NULL, NULL, NULL);
|
||||
}
|
||||
|
@@ -129,9 +129,8 @@ static void q35_host_get_mmcfg_size(Object *obj, Visitor *v, const char *name,
|
||||
void *opaque, Error **errp)
|
||||
{
|
||||
PCIExpressHost *e = PCIE_HOST_BRIDGE(obj);
|
||||
uint32_t value = e->size;
|
||||
|
||||
visit_type_uint32(v, name, &value, errp);
|
||||
visit_type_uint64(v, name, &e->size, errp);
|
||||
}
|
||||
|
||||
static Property q35_host_props[] = {
|
||||
@@ -173,26 +172,26 @@ static void q35_host_initfn(Object *obj)
|
||||
|
||||
object_initialize(&s->mch, sizeof(s->mch), TYPE_MCH_PCI_DEVICE);
|
||||
object_property_add_child(OBJECT(s), "mch", OBJECT(&s->mch), NULL);
|
||||
qdev_prop_set_uint32(DEVICE(&s->mch), "addr", PCI_DEVFN(0, 0));
|
||||
qdev_prop_set_int32(DEVICE(&s->mch), "addr", PCI_DEVFN(0, 0));
|
||||
qdev_prop_set_bit(DEVICE(&s->mch), "multifunction", false);
|
||||
|
||||
object_property_add(obj, PCI_HOST_PROP_PCI_HOLE_START, "int",
|
||||
object_property_add(obj, PCI_HOST_PROP_PCI_HOLE_START, "uint32",
|
||||
q35_host_get_pci_hole_start,
|
||||
NULL, NULL, NULL, NULL);
|
||||
|
||||
object_property_add(obj, PCI_HOST_PROP_PCI_HOLE_END, "int",
|
||||
object_property_add(obj, PCI_HOST_PROP_PCI_HOLE_END, "uint32",
|
||||
q35_host_get_pci_hole_end,
|
||||
NULL, NULL, NULL, NULL);
|
||||
|
||||
object_property_add(obj, PCI_HOST_PROP_PCI_HOLE64_START, "int",
|
||||
object_property_add(obj, PCI_HOST_PROP_PCI_HOLE64_START, "uint64",
|
||||
q35_host_get_pci_hole64_start,
|
||||
NULL, NULL, NULL, NULL);
|
||||
|
||||
object_property_add(obj, PCI_HOST_PROP_PCI_HOLE64_END, "int",
|
||||
object_property_add(obj, PCI_HOST_PROP_PCI_HOLE64_END, "uint64",
|
||||
q35_host_get_pci_hole64_end,
|
||||
NULL, NULL, NULL, NULL);
|
||||
|
||||
object_property_add(obj, PCIE_HOST_MCFG_SIZE, "int",
|
||||
object_property_add(obj, PCIE_HOST_MCFG_SIZE, "uint64",
|
||||
q35_host_get_mmcfg_size,
|
||||
NULL, NULL, NULL, NULL);
|
||||
|
||||
|
@@ -150,7 +150,7 @@ static void xilinx_pcie_host_init(Object *obj)
|
||||
|
||||
object_initialize(root, sizeof(*root), TYPE_XILINX_PCIE_ROOT);
|
||||
object_property_add_child(obj, "root", OBJECT(root), NULL);
|
||||
qdev_prop_set_uint32(DEVICE(root), "addr", PCI_DEVFN(0, 0));
|
||||
qdev_prop_set_int32(DEVICE(root), "addr", PCI_DEVFN(0, 0));
|
||||
qdev_prop_set_bit(DEVICE(root), "multifunction", false);
|
||||
}
|
||||
|
||||
|
@@ -1111,7 +1111,7 @@ static void powernv_machine_initfn(Object *obj)
|
||||
|
||||
static void powernv_machine_class_props_init(ObjectClass *oc)
|
||||
{
|
||||
object_class_property_add(oc, "num-chips", "uint32_t",
|
||||
object_class_property_add(oc, "num-chips", "uint32",
|
||||
pnv_get_num_chips, pnv_set_num_chips,
|
||||
NULL, NULL, NULL);
|
||||
object_class_property_set_description(oc, "num-chips",
|
||||
|
@@ -51,7 +51,7 @@ static void powernv_cpu_init(PowerPCCPU *cpu, Error **errp)
|
||||
int thread_index = 0; /* TODO: TCG supports only one thread */
|
||||
ppc_spr_t *pir = &env->spr_cb[SPR_PIR];
|
||||
|
||||
core_pir = object_property_get_int(OBJECT(cpu), "core-pir", &error_abort);
|
||||
core_pir = object_property_get_uint(OBJECT(cpu), "core-pir", &error_abort);
|
||||
|
||||
/*
|
||||
* The PIR of a thread is the core PIR + the thread index. We will
|
||||
|
@@ -2589,7 +2589,8 @@ static void spapr_memory_plug(HotplugHandler *hotplug_dev, DeviceState *dev,
|
||||
goto out;
|
||||
}
|
||||
|
||||
addr = object_property_get_int(OBJECT(dimm), PC_DIMM_ADDR_PROP, &local_err);
|
||||
addr = object_property_get_uint(OBJECT(dimm),
|
||||
PC_DIMM_ADDR_PROP, &local_err);
|
||||
if (local_err) {
|
||||
pc_dimm_memory_unplug(dev, &ms->hotplug_memory, mr);
|
||||
goto out;
|
||||
@@ -2751,7 +2752,7 @@ static void spapr_memory_unplug_request(HotplugHandler *hotplug_dev,
|
||||
sPAPRDRConnector *drc;
|
||||
sPAPRDIMMState *ds;
|
||||
|
||||
addr_start = object_property_get_int(OBJECT(dimm), PC_DIMM_ADDR_PROP,
|
||||
addr_start = object_property_get_uint(OBJECT(dimm), PC_DIMM_ADDR_PROP,
|
||||
&local_err);
|
||||
if (local_err) {
|
||||
goto out;
|
||||
@@ -2986,7 +2987,7 @@ static void spapr_machine_device_plug(HotplugHandler *hotplug_dev,
|
||||
error_setg(errp, "Memory hotplug not supported for this machine");
|
||||
return;
|
||||
}
|
||||
node = object_property_get_int(OBJECT(dev), PC_DIMM_NODE_PROP, errp);
|
||||
node = object_property_get_uint(OBJECT(dev), PC_DIMM_NODE_PROP, errp);
|
||||
if (*errp) {
|
||||
return;
|
||||
}
|
||||
|
@@ -1107,7 +1107,7 @@ static void usb_host_detach_kernel(USBHostDevice *s)
|
||||
if (rc != 0) {
|
||||
return;
|
||||
}
|
||||
for (i = 0; i < conf->bNumInterfaces; i++) {
|
||||
for (i = 0; i < USB_MAX_INTERFACES; i++) {
|
||||
rc = libusb_kernel_driver_active(s->dh, i);
|
||||
usb_host_libusb_error("libusb_kernel_driver_active", rc);
|
||||
if (rc != 1) {
|
||||
@@ -1130,7 +1130,7 @@ static void usb_host_attach_kernel(USBHostDevice *s)
|
||||
if (rc != 0) {
|
||||
return;
|
||||
}
|
||||
for (i = 0; i < conf->bNumInterfaces; i++) {
|
||||
for (i = 0; i < USB_MAX_INTERFACES; i++) {
|
||||
if (!s->ifs[i].detached) {
|
||||
continue;
|
||||
}
|
||||
@@ -1145,7 +1145,7 @@ static int usb_host_claim_interfaces(USBHostDevice *s, int configuration)
|
||||
{
|
||||
USBDevice *udev = USB_DEVICE(s);
|
||||
struct libusb_config_descriptor *conf;
|
||||
int rc, i;
|
||||
int rc, i, claimed;
|
||||
|
||||
for (i = 0; i < USB_MAX_INTERFACES; i++) {
|
||||
udev->altsetting[i] = 0;
|
||||
@@ -1164,14 +1164,19 @@ static int usb_host_claim_interfaces(USBHostDevice *s, int configuration)
|
||||
return USB_RET_STALL;
|
||||
}
|
||||
|
||||
for (i = 0; i < conf->bNumInterfaces; i++) {
|
||||
claimed = 0;
|
||||
for (i = 0; i < USB_MAX_INTERFACES; i++) {
|
||||
trace_usb_host_claim_interface(s->bus_num, s->addr, configuration, i);
|
||||
rc = libusb_claim_interface(s->dh, i);
|
||||
usb_host_libusb_error("libusb_claim_interface", rc);
|
||||
if (rc != 0) {
|
||||
return USB_RET_STALL;
|
||||
if (rc == 0) {
|
||||
s->ifs[i].claimed = true;
|
||||
if (++claimed == conf->bNumInterfaces) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
s->ifs[i].claimed = true;
|
||||
}
|
||||
if (claimed != conf->bNumInterfaces) {
|
||||
return USB_RET_STALL;
|
||||
}
|
||||
|
||||
udev->ninterfaces = conf->bNumInterfaces;
|
||||
@@ -1183,10 +1188,9 @@ static int usb_host_claim_interfaces(USBHostDevice *s, int configuration)
|
||||
|
||||
static void usb_host_release_interfaces(USBHostDevice *s)
|
||||
{
|
||||
USBDevice *udev = USB_DEVICE(s);
|
||||
int i, rc;
|
||||
|
||||
for (i = 0; i < udev->ninterfaces; i++) {
|
||||
for (i = 0; i < USB_MAX_INTERFACES; i++) {
|
||||
if (!s->ifs[i].claimed) {
|
||||
continue;
|
||||
}
|
||||
|
@@ -30,7 +30,6 @@
|
||||
#include "hw/xen/xen_backend.h"
|
||||
#include "monitor/qdev.h"
|
||||
#include "qapi/qmp/qbool.h"
|
||||
#include "qapi/qmp/qint.h"
|
||||
#include "qapi/qmp/qstring.h"
|
||||
|
||||
#include "hw/xen/io/ring.h"
|
||||
|
@@ -301,7 +301,7 @@ static inline void tlb_flush_by_mmuidx_all_cpus_synced(CPUState *cpu,
|
||||
#define CODE_GEN_AVG_BLOCK_SIZE 150
|
||||
#endif
|
||||
|
||||
#if defined(__arm__) || defined(_ARCH_PPC) \
|
||||
#if defined(_ARCH_PPC) \
|
||||
|| defined(__x86_64__) || defined(__i386__) \
|
||||
|| defined(__sparc__) || defined(__aarch64__) \
|
||||
|| defined(__s390x__) || defined(__mips__) \
|
||||
@@ -401,9 +401,6 @@ static inline void tb_set_jmp_target1(uintptr_t jmp_addr, uintptr_t addr)
|
||||
#elif defined(__aarch64__)
|
||||
void aarch64_tb_set_jmp_target(uintptr_t jmp_addr, uintptr_t addr);
|
||||
#define tb_set_jmp_target1 aarch64_tb_set_jmp_target
|
||||
#elif defined(__arm__)
|
||||
void arm_tb_set_jmp_target(uintptr_t jmp_addr, uintptr_t addr);
|
||||
#define tb_set_jmp_target1 arm_tb_set_jmp_target
|
||||
#elif defined(__sparc__) || defined(__mips__)
|
||||
void tb_set_jmp_target1(uintptr_t jmp_addr, uintptr_t addr);
|
||||
#else
|
||||
|
@@ -31,8 +31,9 @@ typedef struct TBContext TBContext;
|
||||
|
||||
struct TBContext {
|
||||
|
||||
TranslationBlock *tbs;
|
||||
TranslationBlock **tbs;
|
||||
struct qht htable;
|
||||
size_t tbs_size;
|
||||
int nb_tbs;
|
||||
/* any access to the tbs or the page table must use this lock */
|
||||
QemuMutex tb_lock;
|
||||
|
@@ -36,8 +36,8 @@ void *ps2_kbd_init(void (*update_irq)(void *, int), void *update_arg);
|
||||
void *ps2_mouse_init(void (*update_irq)(void *, int), void *update_arg);
|
||||
void ps2_write_mouse(void *, int val);
|
||||
void ps2_write_keyboard(void *, int val);
|
||||
uint32_t ps2_read_data(void *);
|
||||
void ps2_queue(void *, int b);
|
||||
uint32_t ps2_read_data(PS2State *s);
|
||||
void ps2_queue(PS2State *s, int b);
|
||||
void ps2_keyboard_set_translation(void *opaque, int mode);
|
||||
void ps2_mouse_fake_event(void *opaque);
|
||||
|
||||
|
@@ -29,7 +29,7 @@ static inline uint16_t applesmc_port(void)
|
||||
Object *obj = object_resolve_path_type("", TYPE_APPLE_SMC, NULL);
|
||||
|
||||
if (obj) {
|
||||
return object_property_get_int(obj, APPLESMC_PROP_IO_BASE, NULL);
|
||||
return object_property_get_uint(obj, APPLESMC_PROP_IO_BASE, NULL);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
@@ -226,8 +226,10 @@ struct Property {
|
||||
PropertyInfo *info;
|
||||
ptrdiff_t offset;
|
||||
uint8_t bitnr;
|
||||
QType qtype;
|
||||
int64_t defval;
|
||||
union {
|
||||
int64_t i;
|
||||
uint64_t u;
|
||||
} defval;
|
||||
int arrayoffset;
|
||||
PropertyInfo *arrayinfo;
|
||||
int arrayfieldsize;
|
||||
@@ -238,6 +240,7 @@ struct PropertyInfo {
|
||||
const char *description;
|
||||
const char * const *enum_table;
|
||||
int (*print)(DeviceState *dev, Property *prop, char *dest, size_t len);
|
||||
void (*set_default_value)(Object *obj, const Property *prop);
|
||||
ObjectPropertyAccessor *get;
|
||||
ObjectPropertyAccessor *set;
|
||||
ObjectPropertyRelease *release;
|
||||
|
@@ -37,31 +37,39 @@ extern PropertyInfo qdev_prop_arraylen;
|
||||
.offset = offsetof(_state, _field) \
|
||||
+ type_check(_type, typeof_field(_state, _field)), \
|
||||
}
|
||||
#define DEFINE_PROP_DEFAULT(_name, _state, _field, _defval, _prop, _type) { \
|
||||
|
||||
#define DEFINE_PROP_SIGNED(_name, _state, _field, _defval, _prop, _type) { \
|
||||
.name = (_name), \
|
||||
.info = &(_prop), \
|
||||
.offset = offsetof(_state, _field) \
|
||||
+ type_check(_type,typeof_field(_state, _field)), \
|
||||
.qtype = QTYPE_QINT, \
|
||||
.defval = (_type)_defval, \
|
||||
.defval.i = (_type)_defval, \
|
||||
}
|
||||
|
||||
#define DEFINE_PROP_BIT(_name, _state, _field, _bit, _defval) { \
|
||||
.name = (_name), \
|
||||
.info = &(qdev_prop_bit), \
|
||||
.bitnr = (_bit), \
|
||||
.offset = offsetof(_state, _field) \
|
||||
+ type_check(uint32_t,typeof_field(_state, _field)), \
|
||||
.qtype = QTYPE_QBOOL, \
|
||||
.defval = (bool)_defval, \
|
||||
.defval.u = (bool)_defval, \
|
||||
}
|
||||
|
||||
#define DEFINE_PROP_UNSIGNED(_name, _state, _field, _defval, _prop, _type) { \
|
||||
.name = (_name), \
|
||||
.info = &(_prop), \
|
||||
.offset = offsetof(_state, _field) \
|
||||
+ type_check(_type, typeof_field(_state, _field)), \
|
||||
.defval.u = (_type)_defval, \
|
||||
}
|
||||
|
||||
#define DEFINE_PROP_BIT64(_name, _state, _field, _bit, _defval) { \
|
||||
.name = (_name), \
|
||||
.info = &(qdev_prop_bit64), \
|
||||
.bitnr = (_bit), \
|
||||
.offset = offsetof(_state, _field) \
|
||||
+ type_check(uint64_t, typeof_field(_state, _field)), \
|
||||
.qtype = QTYPE_QBOOL, \
|
||||
.defval = (bool)_defval, \
|
||||
.defval.u = (bool)_defval, \
|
||||
}
|
||||
|
||||
#define DEFINE_PROP_BOOL(_name, _state, _field, _defval) { \
|
||||
@@ -69,8 +77,7 @@ extern PropertyInfo qdev_prop_arraylen;
|
||||
.info = &(qdev_prop_bool), \
|
||||
.offset = offsetof(_state, _field) \
|
||||
+ type_check(bool, typeof_field(_state, _field)), \
|
||||
.qtype = QTYPE_QBOOL, \
|
||||
.defval = (bool)_defval, \
|
||||
.defval.u = (bool)_defval, \
|
||||
}
|
||||
|
||||
#define PROP_ARRAY_LEN_PREFIX "len-"
|
||||
@@ -105,26 +112,25 @@ extern PropertyInfo qdev_prop_arraylen;
|
||||
.info = &(qdev_prop_arraylen), \
|
||||
.offset = offsetof(_state, _field) \
|
||||
+ type_check(uint32_t, typeof_field(_state, _field)), \
|
||||
.qtype = QTYPE_QINT, \
|
||||
.arrayinfo = &(_arrayprop), \
|
||||
.arrayfieldsize = sizeof(_arraytype), \
|
||||
.arrayoffset = offsetof(_state, _arrayfield), \
|
||||
}
|
||||
|
||||
#define DEFINE_PROP_UINT8(_n, _s, _f, _d) \
|
||||
DEFINE_PROP_DEFAULT(_n, _s, _f, _d, qdev_prop_uint8, uint8_t)
|
||||
DEFINE_PROP_UNSIGNED(_n, _s, _f, _d, qdev_prop_uint8, uint8_t)
|
||||
#define DEFINE_PROP_UINT16(_n, _s, _f, _d) \
|
||||
DEFINE_PROP_DEFAULT(_n, _s, _f, _d, qdev_prop_uint16, uint16_t)
|
||||
DEFINE_PROP_UNSIGNED(_n, _s, _f, _d, qdev_prop_uint16, uint16_t)
|
||||
#define DEFINE_PROP_UINT32(_n, _s, _f, _d) \
|
||||
DEFINE_PROP_DEFAULT(_n, _s, _f, _d, qdev_prop_uint32, uint32_t)
|
||||
DEFINE_PROP_UNSIGNED(_n, _s, _f, _d, qdev_prop_uint32, uint32_t)
|
||||
#define DEFINE_PROP_INT32(_n, _s, _f, _d) \
|
||||
DEFINE_PROP_DEFAULT(_n, _s, _f, _d, qdev_prop_int32, int32_t)
|
||||
DEFINE_PROP_SIGNED(_n, _s, _f, _d, qdev_prop_int32, int32_t)
|
||||
#define DEFINE_PROP_UINT64(_n, _s, _f, _d) \
|
||||
DEFINE_PROP_DEFAULT(_n, _s, _f, _d, qdev_prop_uint64, uint64_t)
|
||||
DEFINE_PROP_UNSIGNED(_n, _s, _f, _d, qdev_prop_uint64, uint64_t)
|
||||
#define DEFINE_PROP_SIZE(_n, _s, _f, _d) \
|
||||
DEFINE_PROP_DEFAULT(_n, _s, _f, _d, qdev_prop_size, uint64_t)
|
||||
DEFINE_PROP_UNSIGNED(_n, _s, _f, _d, qdev_prop_size, uint64_t)
|
||||
#define DEFINE_PROP_PCI_DEVFN(_n, _s, _f, _d) \
|
||||
DEFINE_PROP_DEFAULT(_n, _s, _f, _d, qdev_prop_pci_devfn, int32_t)
|
||||
DEFINE_PROP_SIGNED(_n, _s, _f, _d, qdev_prop_pci_devfn, int32_t)
|
||||
|
||||
/*
|
||||
* Please avoid pointer properties. If you must use them, you must
|
||||
@@ -158,17 +164,17 @@ extern PropertyInfo qdev_prop_arraylen;
|
||||
#define DEFINE_PROP_MACADDR(_n, _s, _f) \
|
||||
DEFINE_PROP(_n, _s, _f, qdev_prop_macaddr, MACAddr)
|
||||
#define DEFINE_PROP_ON_OFF_AUTO(_n, _s, _f, _d) \
|
||||
DEFINE_PROP_DEFAULT(_n, _s, _f, _d, qdev_prop_on_off_auto, OnOffAuto)
|
||||
DEFINE_PROP_SIGNED(_n, _s, _f, _d, qdev_prop_on_off_auto, OnOffAuto)
|
||||
#define DEFINE_PROP_LOSTTICKPOLICY(_n, _s, _f, _d) \
|
||||
DEFINE_PROP_DEFAULT(_n, _s, _f, _d, qdev_prop_losttickpolicy, \
|
||||
DEFINE_PROP_SIGNED(_n, _s, _f, _d, qdev_prop_losttickpolicy, \
|
||||
LostTickPolicy)
|
||||
#define DEFINE_PROP_BLOCKDEV_ON_ERROR(_n, _s, _f, _d) \
|
||||
DEFINE_PROP_DEFAULT(_n, _s, _f, _d, qdev_prop_blockdev_on_error, \
|
||||
DEFINE_PROP_SIGNED(_n, _s, _f, _d, qdev_prop_blockdev_on_error, \
|
||||
BlockdevOnError)
|
||||
#define DEFINE_PROP_BIOS_CHS_TRANS(_n, _s, _f, _d) \
|
||||
DEFINE_PROP_DEFAULT(_n, _s, _f, _d, qdev_prop_bios_chs_trans, int)
|
||||
DEFINE_PROP_SIGNED(_n, _s, _f, _d, qdev_prop_bios_chs_trans, int)
|
||||
#define DEFINE_PROP_BLOCKSIZE(_n, _s, _f) \
|
||||
DEFINE_PROP_DEFAULT(_n, _s, _f, 0, qdev_prop_blocksize, uint16_t)
|
||||
DEFINE_PROP_UNSIGNED(_n, _s, _f, 0, qdev_prop_blocksize, uint16_t)
|
||||
#define DEFINE_PROP_PCI_HOST_DEVADDR(_n, _s, _f) \
|
||||
DEFINE_PROP(_n, _s, _f, qdev_prop_pci_host_devaddr, PCIHostDeviceAddress)
|
||||
|
||||
|
@@ -15,6 +15,7 @@
|
||||
|
||||
#include "qapi/qmp/qobject.h"
|
||||
#include "qapi/qmp/qlist.h"
|
||||
#include "qapi/qmp/qnum.h"
|
||||
#include "qemu/queue.h"
|
||||
|
||||
#define QDICT_BUCKET_MAX 512
|
||||
@@ -54,7 +55,7 @@ void qdict_destroy_obj(QObject *obj);
|
||||
|
||||
/* Helpers for int, bool, and string */
|
||||
#define qdict_put_int(qdict, key, value) \
|
||||
qdict_put(qdict, key, qint_from_int(value))
|
||||
qdict_put(qdict, key, qnum_from_int(value))
|
||||
#define qdict_put_bool(qdict, key, value) \
|
||||
qdict_put(qdict, key, qbool_from_bool(value))
|
||||
#define qdict_put_str(qdict, key, value) \
|
||||
|
@@ -1,29 +0,0 @@
|
||||
/*
|
||||
* QFloat Module
|
||||
*
|
||||
* Copyright IBM, Corp. 2009
|
||||
*
|
||||
* Authors:
|
||||
* Anthony Liguori <aliguori@us.ibm.com>
|
||||
*
|
||||
* This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
|
||||
* See the COPYING.LIB file in the top-level directory.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef QFLOAT_H
|
||||
#define QFLOAT_H
|
||||
|
||||
#include "qapi/qmp/qobject.h"
|
||||
|
||||
typedef struct QFloat {
|
||||
QObject base;
|
||||
double value;
|
||||
} QFloat;
|
||||
|
||||
QFloat *qfloat_from_double(double value);
|
||||
double qfloat_get_double(const QFloat *qi);
|
||||
QFloat *qobject_to_qfloat(const QObject *obj);
|
||||
void qfloat_destroy_obj(QObject *obj);
|
||||
|
||||
#endif /* QFLOAT_H */
|
@@ -1,28 +0,0 @@
|
||||
/*
|
||||
* QInt Module
|
||||
*
|
||||
* Copyright (C) 2009 Red Hat Inc.
|
||||
*
|
||||
* Authors:
|
||||
* Luiz Capitulino <lcapitulino@redhat.com>
|
||||
*
|
||||
* This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
|
||||
* See the COPYING.LIB file in the top-level directory.
|
||||
*/
|
||||
|
||||
#ifndef QINT_H
|
||||
#define QINT_H
|
||||
|
||||
#include "qapi/qmp/qobject.h"
|
||||
|
||||
typedef struct QInt {
|
||||
QObject base;
|
||||
int64_t value;
|
||||
} QInt;
|
||||
|
||||
QInt *qint_from_int(int64_t value);
|
||||
int64_t qint_get_int(const QInt *qi);
|
||||
QInt *qobject_to_qint(const QObject *obj);
|
||||
void qint_destroy_obj(QObject *obj);
|
||||
|
||||
#endif /* QINT_H */
|
@@ -14,6 +14,7 @@
|
||||
#define QLIST_H
|
||||
|
||||
#include "qapi/qmp/qobject.h"
|
||||
#include "qapi/qmp/qnum.h"
|
||||
#include "qemu/queue.h"
|
||||
|
||||
typedef struct QListEntry {
|
||||
@@ -31,7 +32,7 @@ typedef struct QList {
|
||||
|
||||
/* Helpers for int, bool, and string */
|
||||
#define qlist_append_int(qlist, value) \
|
||||
qlist_append(qlist, qint_from_int(value))
|
||||
qlist_append(qlist, qnum_from_int(value))
|
||||
#define qlist_append_bool(qlist, value) \
|
||||
qlist_append(qlist, qbool_from_bool(value))
|
||||
#define qlist_append_str(qlist, value) \
|
||||
|
53
include/qapi/qmp/qnum.h
Normal file
53
include/qapi/qmp/qnum.h
Normal file
@@ -0,0 +1,53 @@
|
||||
/*
|
||||
* QNum Module
|
||||
*
|
||||
* Copyright (C) 2009 Red Hat Inc.
|
||||
*
|
||||
* Authors:
|
||||
* Luiz Capitulino <lcapitulino@redhat.com>
|
||||
* Anthony Liguori <aliguori@us.ibm.com>
|
||||
* Marc-André Lureau <marcandre.lureau@redhat.com>
|
||||
*
|
||||
* This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
|
||||
* See the COPYING.LIB file in the top-level directory.
|
||||
*/
|
||||
|
||||
#ifndef QNUM_H
|
||||
#define QNUM_H
|
||||
|
||||
#include "qapi/qmp/qobject.h"
|
||||
|
||||
typedef enum {
|
||||
QNUM_I64,
|
||||
QNUM_U64,
|
||||
QNUM_DOUBLE
|
||||
} QNumKind;
|
||||
|
||||
typedef struct QNum {
|
||||
QObject base;
|
||||
QNumKind kind;
|
||||
union {
|
||||
int64_t i64;
|
||||
uint64_t u64;
|
||||
double dbl;
|
||||
} u;
|
||||
} QNum;
|
||||
|
||||
QNum *qnum_from_int(int64_t value);
|
||||
QNum *qnum_from_uint(uint64_t value);
|
||||
QNum *qnum_from_double(double value);
|
||||
|
||||
bool qnum_get_try_int(const QNum *qn, int64_t *val);
|
||||
int64_t qnum_get_int(const QNum *qn);
|
||||
|
||||
bool qnum_get_try_uint(const QNum *qn, uint64_t *val);
|
||||
uint64_t qnum_get_uint(const QNum *qn);
|
||||
|
||||
double qnum_get_double(QNum *qn);
|
||||
|
||||
char *qnum_to_string(QNum *qn);
|
||||
|
||||
QNum *qobject_to_qnum(const QObject *obj);
|
||||
void qnum_destroy_obj(QObject *obj);
|
||||
|
||||
#endif /* QNUM_H */
|
@@ -14,8 +14,7 @@
|
||||
#define QAPI_QMP_TYPES_H
|
||||
|
||||
#include "qapi/qmp/qobject.h"
|
||||
#include "qapi/qmp/qint.h"
|
||||
#include "qapi/qmp/qfloat.h"
|
||||
#include "qapi/qmp/qnum.h"
|
||||
#include "qapi/qmp/qbool.h"
|
||||
#include "qapi/qmp/qstring.h"
|
||||
#include "qapi/qmp/qdict.h"
|
||||
|
@@ -30,9 +30,9 @@ typedef struct QObjectInputVisitor QObjectInputVisitor;
|
||||
* visit_type_FOO() creates an instance of QAPI type FOO. The visited
|
||||
* QObject must match FOO. QDict matches struct/union types, QList
|
||||
* matches list types, QString matches type 'str' and enumeration
|
||||
* types, QInt matches integer types, QFloat matches type 'number',
|
||||
* QBool matches type 'bool'. Type 'any' is matched by QObject. A
|
||||
* QAPI alternate type is matched when one of its member types is.
|
||||
* types, QNum matches integer and float types, QBool matches type
|
||||
* 'bool'. Type 'any' is matched by QObject. A QAPI alternate type
|
||||
* is matched when one of its member types is.
|
||||
*
|
||||
* visit_start_struct() ... visit_end_struct() visits a QDict and
|
||||
* creates a QAPI struct/union. Visits in between visit the
|
||||
|
@@ -28,10 +28,10 @@ typedef struct QObjectOutputVisitor QObjectOutputVisitor;
|
||||
*
|
||||
* visit_type_FOO() creates a QObject for QAPI type FOO. It creates a
|
||||
* QDict for struct/union types, a QList for list types, QString for
|
||||
* type 'str' and enumeration types, QInt for integer types, QFloat
|
||||
* for type 'number', QBool for type 'bool'. For type 'any', it
|
||||
* increments the QObject's reference count. For QAPI alternate
|
||||
* types, it creates the QObject for the member that is in use.
|
||||
* type 'str' and enumeration types, QNum for integer and float
|
||||
* types, QBool for type 'bool'. For type 'any', it increments the
|
||||
* QObject's reference count. For QAPI alternate types, it creates
|
||||
* the QObject for the member that is in use.
|
||||
*
|
||||
* visit_start_struct() ... visit_end_struct() visits a QAPI
|
||||
* struct/union and creates a QDict. Visits in between visit the
|
||||
|
@@ -71,7 +71,7 @@ struct Visitor
|
||||
* optional for output visitors. */
|
||||
void (*start_alternate)(Visitor *v, const char *name,
|
||||
GenericAlternate **obj, size_t size,
|
||||
bool promote_int, Error **errp);
|
||||
Error **errp);
|
||||
|
||||
/* Optional, needed for dealloc visitor */
|
||||
void (*end_alternate)(Visitor *v, void **obj);
|
||||
|
@@ -410,15 +410,13 @@ void visit_end_list(Visitor *v, void **list);
|
||||
* the qtype of the next thing to be visited, stored in (*@obj)->type.
|
||||
* Other visitors will leave @obj unchanged.
|
||||
*
|
||||
* If @promote_int, treat integers as QTYPE_FLOAT.
|
||||
*
|
||||
* If successful, this must be paired with visit_end_alternate() with
|
||||
* the same @obj to clean up, even if visiting the contents of the
|
||||
* alternate fails.
|
||||
*/
|
||||
void visit_start_alternate(Visitor *v, const char *name,
|
||||
GenericAlternate **obj, size_t size,
|
||||
bool promote_int, Error **errp);
|
||||
Error **errp);
|
||||
|
||||
/*
|
||||
* Finish visiting an alternate type.
|
||||
|
@@ -483,4 +483,7 @@ char *qemu_get_pid_name(pid_t pid);
|
||||
*/
|
||||
pid_t qemu_fork(Error **errp);
|
||||
|
||||
extern int qemu_icache_linesize;
|
||||
extern int qemu_dcache_linesize;
|
||||
|
||||
#endif
|
||||
|
@@ -76,6 +76,7 @@ typedef struct PixelFormat PixelFormat;
|
||||
typedef struct PostcopyDiscardState PostcopyDiscardState;
|
||||
typedef struct Property Property;
|
||||
typedef struct PropertyInfo PropertyInfo;
|
||||
typedef struct PS2State PS2State;
|
||||
typedef struct QEMUBH QEMUBH;
|
||||
typedef struct QemuConsole QemuConsole;
|
||||
typedef struct QEMUFile QEMUFile;
|
||||
|
@@ -1093,6 +1093,29 @@ void object_property_set_int(Object *obj, int64_t value,
|
||||
int64_t object_property_get_int(Object *obj, const char *name,
|
||||
Error **errp);
|
||||
|
||||
/**
|
||||
* object_property_set_uint:
|
||||
* @value: the value to be written to the property
|
||||
* @name: the name of the property
|
||||
* @errp: returns an error if this function fails
|
||||
*
|
||||
* Writes an unsigned integer value to a property.
|
||||
*/
|
||||
void object_property_set_uint(Object *obj, uint64_t value,
|
||||
const char *name, Error **errp);
|
||||
|
||||
/**
|
||||
* object_property_get_uint:
|
||||
* @obj: the object
|
||||
* @name: the name of the property
|
||||
* @errp: returns an error if this function fails
|
||||
*
|
||||
* Returns: the value of the property, converted to an unsigned integer, or 0
|
||||
* an error occurs (including when the property value is not an integer).
|
||||
*/
|
||||
uint64_t object_property_get_uint(Object *obj, const char *name,
|
||||
Error **errp);
|
||||
|
||||
/**
|
||||
* object_property_get_enum:
|
||||
* @obj: the object
|
||||
|
@@ -2974,7 +2974,7 @@ static QDict *monitor_parse_arguments(Monitor *mon,
|
||||
monitor_printf(mon, "Unknown unit suffix\n");
|
||||
goto fail;
|
||||
}
|
||||
qdict_put(qdict, key, qfloat_from_double(val));
|
||||
qdict_put(qdict, key, qnum_from_double(val));
|
||||
}
|
||||
break;
|
||||
case 'b':
|
||||
|
@@ -328,7 +328,7 @@ static void filter_dump_instance_init(Object *obj)
|
||||
|
||||
nfds->maxlen = 65536;
|
||||
|
||||
object_property_add(obj, "maxlen", "int", filter_dump_get_maxlen,
|
||||
object_property_add(obj, "maxlen", "uint32", filter_dump_get_maxlen,
|
||||
filter_dump_set_maxlen, NULL, NULL, NULL);
|
||||
object_property_add_str(obj, "file", file_dump_get_filename,
|
||||
file_dump_set_filename, NULL);
|
||||
|
@@ -191,7 +191,7 @@ out:
|
||||
|
||||
static void filter_buffer_init(Object *obj)
|
||||
{
|
||||
object_property_add(obj, "interval", "int",
|
||||
object_property_add(obj, "interval", "uint32",
|
||||
filter_buffer_get_interval,
|
||||
filter_buffer_set_interval, NULL, NULL, NULL);
|
||||
}
|
||||
|
6
numa.c
6
numa.c
@@ -216,7 +216,7 @@ static void parse_numa_node(MachineState *ms, NumaNodeOptions *node,
|
||||
}
|
||||
|
||||
object_ref(o);
|
||||
numa_info[nodenr].node_mem = object_property_get_int(o, "size", NULL);
|
||||
numa_info[nodenr].node_mem = object_property_get_uint(o, "size", NULL);
|
||||
numa_info[nodenr].node_memdev = MEMORY_BACKEND(o);
|
||||
}
|
||||
numa_info[nodenr].present = true;
|
||||
@@ -641,8 +641,8 @@ static int query_memdev(Object *obj, void *opaque)
|
||||
m->value->id = object_property_get_str(obj, "id", NULL);
|
||||
m->value->has_id = !!m->value->id;
|
||||
|
||||
m->value->size = object_property_get_int(obj, "size",
|
||||
&error_abort);
|
||||
m->value->size = object_property_get_uint(obj, "size",
|
||||
&error_abort);
|
||||
m->value->merge = object_property_get_bool(obj, "merge",
|
||||
&error_abort);
|
||||
m->value->dump = object_property_get_bool(obj, "dump",
|
||||
|
@@ -70,7 +70,7 @@ static GenericList *qapi_clone_next_list(Visitor *v, GenericList *tail,
|
||||
|
||||
static void qapi_clone_start_alternate(Visitor *v, const char *name,
|
||||
GenericAlternate **obj, size_t size,
|
||||
bool promote_int, Error **errp)
|
||||
Error **errp)
|
||||
{
|
||||
qapi_clone_start_struct(v, name, (void **)obj, size, errp);
|
||||
}
|
||||
|
@@ -38,7 +38,7 @@ static void qapi_dealloc_end_struct(Visitor *v, void **obj)
|
||||
|
||||
static void qapi_dealloc_start_alternate(Visitor *v, const char *name,
|
||||
GenericAlternate **obj, size_t size,
|
||||
bool promote_int, Error **errp)
|
||||
Error **errp)
|
||||
{
|
||||
}
|
||||
|
||||
|
@@ -106,15 +106,15 @@ void visit_end_list(Visitor *v, void **obj)
|
||||
|
||||
void visit_start_alternate(Visitor *v, const char *name,
|
||||
GenericAlternate **obj, size_t size,
|
||||
bool promote_int, Error **errp)
|
||||
Error **errp)
|
||||
{
|
||||
Error *err = NULL;
|
||||
|
||||
assert(obj && size >= sizeof(GenericAlternate));
|
||||
assert(!(v->type & VISITOR_OUTPUT) || *obj);
|
||||
trace_visit_start_alternate(v, name, obj, size, promote_int);
|
||||
trace_visit_start_alternate(v, name, obj, size);
|
||||
if (v->start_alternate) {
|
||||
v->start_alternate(v, name, obj, size, promote_int, &err);
|
||||
v->start_alternate(v, name, obj, size, &err);
|
||||
}
|
||||
if (v->type & VISITOR_INPUT) {
|
||||
assert(v->start_alternate && !err != !*obj);
|
||||
|
@@ -367,7 +367,7 @@ static void qobject_input_end_list(Visitor *v, void **obj)
|
||||
|
||||
static void qobject_input_start_alternate(Visitor *v, const char *name,
|
||||
GenericAlternate **obj, size_t size,
|
||||
bool promote_int, Error **errp)
|
||||
Error **errp)
|
||||
{
|
||||
QObjectInputVisitor *qiv = to_qiv(v);
|
||||
QObject *qobj = qobject_input_get_object(qiv, name, false, errp);
|
||||
@@ -378,9 +378,6 @@ static void qobject_input_start_alternate(Visitor *v, const char *name,
|
||||
}
|
||||
*obj = g_malloc0(size);
|
||||
(*obj)->type = qobject_type(qobj);
|
||||
if (promote_int && (*obj)->type == QTYPE_QINT) {
|
||||
(*obj)->type = QTYPE_QFLOAT;
|
||||
}
|
||||
}
|
||||
|
||||
static void qobject_input_type_int64(Visitor *v, const char *name, int64_t *obj,
|
||||
@@ -388,22 +385,18 @@ static void qobject_input_type_int64(Visitor *v, const char *name, int64_t *obj,
|
||||
{
|
||||
QObjectInputVisitor *qiv = to_qiv(v);
|
||||
QObject *qobj = qobject_input_get_object(qiv, name, true, errp);
|
||||
QInt *qint;
|
||||
QNum *qnum;
|
||||
|
||||
if (!qobj) {
|
||||
return;
|
||||
}
|
||||
qint = qobject_to_qint(qobj);
|
||||
if (!qint) {
|
||||
qnum = qobject_to_qnum(qobj);
|
||||
if (!qnum || !qnum_get_try_int(qnum, obj)) {
|
||||
error_setg(errp, QERR_INVALID_PARAMETER_TYPE,
|
||||
full_name(qiv, name), "integer");
|
||||
return;
|
||||
}
|
||||
|
||||
*obj = qint_get_int(qint);
|
||||
}
|
||||
|
||||
|
||||
static void qobject_input_type_int64_keyval(Visitor *v, const char *name,
|
||||
int64_t *obj, Error **errp)
|
||||
{
|
||||
@@ -424,22 +417,32 @@ static void qobject_input_type_int64_keyval(Visitor *v, const char *name,
|
||||
static void qobject_input_type_uint64(Visitor *v, const char *name,
|
||||
uint64_t *obj, Error **errp)
|
||||
{
|
||||
/* FIXME: qobject_to_qint mishandles values over INT64_MAX */
|
||||
QObjectInputVisitor *qiv = to_qiv(v);
|
||||
QObject *qobj = qobject_input_get_object(qiv, name, true, errp);
|
||||
QInt *qint;
|
||||
QNum *qnum;
|
||||
int64_t val;
|
||||
|
||||
if (!qobj) {
|
||||
return;
|
||||
}
|
||||
qint = qobject_to_qint(qobj);
|
||||
if (!qint) {
|
||||
error_setg(errp, QERR_INVALID_PARAMETER_TYPE,
|
||||
full_name(qiv, name), "integer");
|
||||
qnum = qobject_to_qnum(qobj);
|
||||
if (!qnum) {
|
||||
goto err;
|
||||
}
|
||||
|
||||
if (qnum_get_try_uint(qnum, obj)) {
|
||||
return;
|
||||
}
|
||||
|
||||
*obj = qint_get_int(qint);
|
||||
/* Need to accept negative values for backward compatibility */
|
||||
if (qnum_get_try_int(qnum, &val)) {
|
||||
*obj = val;
|
||||
return;
|
||||
}
|
||||
|
||||
err:
|
||||
error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
|
||||
full_name(qiv, name), "uint64");
|
||||
}
|
||||
|
||||
static void qobject_input_type_uint64_keyval(Visitor *v, const char *name,
|
||||
@@ -534,26 +537,19 @@ static void qobject_input_type_number(Visitor *v, const char *name, double *obj,
|
||||
{
|
||||
QObjectInputVisitor *qiv = to_qiv(v);
|
||||
QObject *qobj = qobject_input_get_object(qiv, name, true, errp);
|
||||
QInt *qint;
|
||||
QFloat *qfloat;
|
||||
QNum *qnum;
|
||||
|
||||
if (!qobj) {
|
||||
return;
|
||||
}
|
||||
qint = qobject_to_qint(qobj);
|
||||
if (qint) {
|
||||
*obj = qint_get_int(qobject_to_qint(qobj));
|
||||
qnum = qobject_to_qnum(qobj);
|
||||
if (!qnum) {
|
||||
error_setg(errp, QERR_INVALID_PARAMETER_TYPE,
|
||||
full_name(qiv, name), "number");
|
||||
return;
|
||||
}
|
||||
|
||||
qfloat = qobject_to_qfloat(qobj);
|
||||
if (qfloat) {
|
||||
*obj = qfloat_get_double(qobject_to_qfloat(qobj));
|
||||
return;
|
||||
}
|
||||
|
||||
error_setg(errp, QERR_INVALID_PARAMETER_TYPE,
|
||||
full_name(qiv, name), "number");
|
||||
*obj = qnum_get_double(qnum);
|
||||
}
|
||||
|
||||
static void qobject_input_type_number_keyval(Visitor *v, const char *name,
|
||||
|
@@ -144,15 +144,14 @@ static void qobject_output_type_int64(Visitor *v, const char *name,
|
||||
int64_t *obj, Error **errp)
|
||||
{
|
||||
QObjectOutputVisitor *qov = to_qov(v);
|
||||
qobject_output_add(qov, name, qint_from_int(*obj));
|
||||
qobject_output_add(qov, name, qnum_from_int(*obj));
|
||||
}
|
||||
|
||||
static void qobject_output_type_uint64(Visitor *v, const char *name,
|
||||
uint64_t *obj, Error **errp)
|
||||
{
|
||||
/* FIXME values larger than INT64_MAX become negative */
|
||||
QObjectOutputVisitor *qov = to_qov(v);
|
||||
qobject_output_add(qov, name, qint_from_int(*obj));
|
||||
qobject_output_add(qov, name, qnum_from_uint(*obj));
|
||||
}
|
||||
|
||||
static void qobject_output_type_bool(Visitor *v, const char *name, bool *obj,
|
||||
@@ -177,7 +176,7 @@ static void qobject_output_type_number(Visitor *v, const char *name,
|
||||
double *obj, Error **errp)
|
||||
{
|
||||
QObjectOutputVisitor *qov = to_qov(v);
|
||||
qobject_output_add(qov, name, qfloat_from_double(*obj));
|
||||
qobject_output_add(qov, name, qnum_from_double(*obj));
|
||||
}
|
||||
|
||||
static void qobject_output_type_any(Visitor *v, const char *name,
|
||||
|
@@ -11,7 +11,7 @@ visit_next_list(void *v, void *tail, size_t size) "v=%p tail=%p size=%zu"
|
||||
visit_check_list(void *v) "v=%p"
|
||||
visit_end_list(void *v, void *obj) "v=%p obj=%p"
|
||||
|
||||
visit_start_alternate(void *v, const char *name, void *obj, size_t size, bool promote_int) "v=%p name=%s obj=%p size=%zu promote_int=%d"
|
||||
visit_start_alternate(void *v, const char *name, void *obj, size_t size) "v=%p name=%s obj=%p size=%zu"
|
||||
visit_end_alternate(void *v, void *obj) "v=%p obj=%p"
|
||||
|
||||
visit_optional(void *v, const char *name, bool *present) "v=%p name=%s present=%p"
|
||||
|
@@ -485,7 +485,7 @@ int ga_parse_whence(GuestFileWhence *whence, Error **errp)
|
||||
{
|
||||
/* Exploit the fact that we picked values to match QGA_SEEK_*. */
|
||||
if (whence->type == QTYPE_QSTRING) {
|
||||
whence->type = QTYPE_QINT;
|
||||
whence->type = QTYPE_QNUM;
|
||||
whence->u.value = whence->u.name;
|
||||
}
|
||||
switch (whence->u.value) {
|
||||
|
@@ -19,7 +19,6 @@
|
||||
#endif
|
||||
#include "qapi/qmp/json-streamer.h"
|
||||
#include "qapi/qmp/json-parser.h"
|
||||
#include "qapi/qmp/qint.h"
|
||||
#include "qapi/qmp/qjson.h"
|
||||
#include "qga/guest-agent-core.h"
|
||||
#include "qemu/module.h"
|
||||
|
@@ -1,2 +1,2 @@
|
||||
util-obj-y = qnull.o qint.o qstring.o qdict.o qlist.o qfloat.o qbool.o
|
||||
util-obj-y = qnull.o qnum.o qstring.o qdict.o qlist.o qbool.o
|
||||
util-obj-y += qjson.o qobject.o json-lexer.o json-streamer.o json-parser.o
|
||||
|
@@ -227,15 +227,18 @@ static const uint8_t json_lexer[][256] = {
|
||||
/* escape */
|
||||
[IN_ESCAPE_LL] = {
|
||||
['d'] = JSON_ESCAPE,
|
||||
['u'] = JSON_ESCAPE,
|
||||
},
|
||||
|
||||
[IN_ESCAPE_L] = {
|
||||
['d'] = JSON_ESCAPE,
|
||||
['l'] = IN_ESCAPE_LL,
|
||||
['u'] = JSON_ESCAPE,
|
||||
},
|
||||
|
||||
[IN_ESCAPE_I64] = {
|
||||
['d'] = JSON_ESCAPE,
|
||||
['u'] = JSON_ESCAPE,
|
||||
},
|
||||
|
||||
[IN_ESCAPE_I6] = {
|
||||
@@ -251,6 +254,7 @@ static const uint8_t json_lexer[][256] = {
|
||||
['i'] = JSON_ESCAPE,
|
||||
['p'] = JSON_ESCAPE,
|
||||
['s'] = JSON_ESCAPE,
|
||||
['u'] = JSON_ESCAPE,
|
||||
['f'] = JSON_ESCAPE,
|
||||
['l'] = IN_ESCAPE_L,
|
||||
['I'] = IN_ESCAPE_I,
|
||||
|
@@ -12,6 +12,7 @@
|
||||
*/
|
||||
|
||||
#include "qemu/osdep.h"
|
||||
#include "qemu/cutils.h"
|
||||
#include "qapi/error.h"
|
||||
#include "qemu-common.h"
|
||||
#include "qapi/qmp/types.h"
|
||||
@@ -466,16 +467,23 @@ static QObject *parse_escape(JSONParserContext *ctxt, va_list *ap)
|
||||
} else if (!strcmp(token->str, "%i")) {
|
||||
return QOBJECT(qbool_from_bool(va_arg(*ap, int)));
|
||||
} else if (!strcmp(token->str, "%d")) {
|
||||
return QOBJECT(qint_from_int(va_arg(*ap, int)));
|
||||
return QOBJECT(qnum_from_int(va_arg(*ap, int)));
|
||||
} else if (!strcmp(token->str, "%ld")) {
|
||||
return QOBJECT(qint_from_int(va_arg(*ap, long)));
|
||||
return QOBJECT(qnum_from_int(va_arg(*ap, long)));
|
||||
} else if (!strcmp(token->str, "%lld") ||
|
||||
!strcmp(token->str, "%I64d")) {
|
||||
return QOBJECT(qint_from_int(va_arg(*ap, long long)));
|
||||
return QOBJECT(qnum_from_int(va_arg(*ap, long long)));
|
||||
} else if (!strcmp(token->str, "%u")) {
|
||||
return QOBJECT(qnum_from_uint(va_arg(*ap, unsigned int)));
|
||||
} else if (!strcmp(token->str, "%lu")) {
|
||||
return QOBJECT(qnum_from_uint(va_arg(*ap, unsigned long)));
|
||||
} else if (!strcmp(token->str, "%llu") ||
|
||||
!strcmp(token->str, "%I64u")) {
|
||||
return QOBJECT(qnum_from_uint(va_arg(*ap, unsigned long long)));
|
||||
} else if (!strcmp(token->str, "%s")) {
|
||||
return QOBJECT(qstring_from_str(va_arg(*ap, const char *)));
|
||||
} else if (!strcmp(token->str, "%f")) {
|
||||
return QOBJECT(qfloat_from_double(va_arg(*ap, double)));
|
||||
return QOBJECT(qnum_from_double(va_arg(*ap, double)));
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
@@ -491,24 +499,34 @@ static QObject *parse_literal(JSONParserContext *ctxt)
|
||||
case JSON_STRING:
|
||||
return QOBJECT(qstring_from_escaped_str(ctxt, token));
|
||||
case JSON_INTEGER: {
|
||||
/* A possibility exists that this is a whole-valued float where the
|
||||
* fractional part was left out due to being 0 (.0). It's not a big
|
||||
* deal to treat these as ints in the parser, so long as users of the
|
||||
* resulting QObject know to expect a QInt in place of a QFloat in
|
||||
* cases like these.
|
||||
/*
|
||||
* Represent JSON_INTEGER as QNUM_I64 if possible, else as
|
||||
* QNUM_U64, else as QNUM_DOUBLE. Note that qemu_strtoi64()
|
||||
* and qemu_strtou64() fail with ERANGE when it's not
|
||||
* possible.
|
||||
*
|
||||
* However, in some cases these values will overflow/underflow a
|
||||
* QInt/int64 container, thus we should assume these are to be handled
|
||||
* as QFloats/doubles rather than silently changing their values.
|
||||
*
|
||||
* strtoll() indicates these instances by setting errno to ERANGE
|
||||
* qnum_get_int() will then work for any signed 64-bit
|
||||
* JSON_INTEGER, qnum_get_uint() for any unsigned 64-bit
|
||||
* integer, and qnum_get_double() both for any JSON_INTEGER
|
||||
* and any JSON_FLOAT (with precision loss for integers beyond
|
||||
* 53 bits)
|
||||
*/
|
||||
int ret;
|
||||
int64_t value;
|
||||
uint64_t uvalue;
|
||||
|
||||
errno = 0; /* strtoll doesn't set errno on success */
|
||||
value = strtoll(token->str, NULL, 10);
|
||||
if (errno != ERANGE) {
|
||||
return QOBJECT(qint_from_int(value));
|
||||
ret = qemu_strtoi64(token->str, NULL, 10, &value);
|
||||
if (!ret) {
|
||||
return QOBJECT(qnum_from_int(value));
|
||||
}
|
||||
assert(ret == -ERANGE);
|
||||
|
||||
if (token->str[0] != '-') {
|
||||
ret = qemu_strtou64(token->str, NULL, 10, &uvalue);
|
||||
if (!ret) {
|
||||
return QOBJECT(qnum_from_uint(uvalue));
|
||||
}
|
||||
assert(ret == -ERANGE);
|
||||
}
|
||||
/* fall through to JSON_FLOAT */
|
||||
}
|
||||
@@ -516,7 +534,7 @@ static QObject *parse_literal(JSONParserContext *ctxt)
|
||||
/* FIXME dependent on locale; a pervasive issue in QEMU */
|
||||
/* FIXME our lexer matches RFC 7159 in forbidding Inf or NaN,
|
||||
* but those might be useful extensions beyond JSON */
|
||||
return QOBJECT(qfloat_from_double(strtod(token->str, NULL)));
|
||||
return QOBJECT(qnum_from_double(strtod(token->str, NULL)));
|
||||
default:
|
||||
abort();
|
||||
}
|
||||
|
@@ -11,8 +11,7 @@
|
||||
*/
|
||||
|
||||
#include "qemu/osdep.h"
|
||||
#include "qapi/qmp/qint.h"
|
||||
#include "qapi/qmp/qfloat.h"
|
||||
#include "qapi/qmp/qnum.h"
|
||||
#include "qapi/qmp/qdict.h"
|
||||
#include "qapi/qmp/qbool.h"
|
||||
#include "qapi/qmp/qstring.h"
|
||||
@@ -180,37 +179,26 @@ size_t qdict_size(const QDict *qdict)
|
||||
/**
|
||||
* qdict_get_double(): Get an number mapped by 'key'
|
||||
*
|
||||
* This function assumes that 'key' exists and it stores a
|
||||
* QFloat or QInt object.
|
||||
* This function assumes that 'key' exists and it stores a QNum.
|
||||
*
|
||||
* Return number mapped by 'key'.
|
||||
*/
|
||||
double qdict_get_double(const QDict *qdict, const char *key)
|
||||
{
|
||||
QObject *obj = qdict_get(qdict, key);
|
||||
|
||||
assert(obj);
|
||||
switch (qobject_type(obj)) {
|
||||
case QTYPE_QFLOAT:
|
||||
return qfloat_get_double(qobject_to_qfloat(obj));
|
||||
case QTYPE_QINT:
|
||||
return qint_get_int(qobject_to_qint(obj));
|
||||
default:
|
||||
abort();
|
||||
}
|
||||
return qnum_get_double(qobject_to_qnum(qdict_get(qdict, key)));
|
||||
}
|
||||
|
||||
/**
|
||||
* qdict_get_int(): Get an integer mapped by 'key'
|
||||
*
|
||||
* This function assumes that 'key' exists and it stores a
|
||||
* QInt object.
|
||||
* QNum representable as int.
|
||||
*
|
||||
* Return integer mapped by 'key'.
|
||||
*/
|
||||
int64_t qdict_get_int(const QDict *qdict, const char *key)
|
||||
{
|
||||
return qint_get_int(qobject_to_qint(qdict_get(qdict, key)));
|
||||
return qnum_get_int(qobject_to_qnum(qdict_get(qdict, key)));
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -259,16 +247,21 @@ const char *qdict_get_str(const QDict *qdict, const char *key)
|
||||
/**
|
||||
* qdict_get_try_int(): Try to get integer mapped by 'key'
|
||||
*
|
||||
* Return integer mapped by 'key', if it is not present in
|
||||
* the dictionary or if the stored object is not of QInt type
|
||||
* 'def_value' will be returned.
|
||||
* Return integer mapped by 'key', if it is not present in the
|
||||
* dictionary or if the stored object is not a QNum representing an
|
||||
* integer, 'def_value' will be returned.
|
||||
*/
|
||||
int64_t qdict_get_try_int(const QDict *qdict, const char *key,
|
||||
int64_t def_value)
|
||||
{
|
||||
QInt *qint = qobject_to_qint(qdict_get(qdict, key));
|
||||
QNum *qnum = qobject_to_qnum(qdict_get(qdict, key));
|
||||
int64_t val;
|
||||
|
||||
return qint ? qint_get_int(qint) : def_value;
|
||||
if (!qnum || !qnum_get_try_int(qnum, &val)) {
|
||||
return def_value;
|
||||
}
|
||||
|
||||
return val;
|
||||
}
|
||||
|
||||
/**
|
||||
|
@@ -1,62 +0,0 @@
|
||||
/*
|
||||
* QFloat Module
|
||||
*
|
||||
* Copyright IBM, Corp. 2009
|
||||
*
|
||||
* Authors:
|
||||
* Anthony Liguori <aliguori@us.ibm.com>
|
||||
*
|
||||
* This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
|
||||
* See the COPYING.LIB file in the top-level directory.
|
||||
*
|
||||
*/
|
||||
|
||||
#include "qemu/osdep.h"
|
||||
#include "qapi/qmp/qfloat.h"
|
||||
#include "qapi/qmp/qobject.h"
|
||||
#include "qemu-common.h"
|
||||
|
||||
/**
|
||||
* qfloat_from_int(): Create a new QFloat from a float
|
||||
*
|
||||
* Return strong reference.
|
||||
*/
|
||||
QFloat *qfloat_from_double(double value)
|
||||
{
|
||||
QFloat *qf;
|
||||
|
||||
qf = g_malloc(sizeof(*qf));
|
||||
qobject_init(QOBJECT(qf), QTYPE_QFLOAT);
|
||||
qf->value = value;
|
||||
|
||||
return qf;
|
||||
}
|
||||
|
||||
/**
|
||||
* qfloat_get_double(): Get the stored float
|
||||
*/
|
||||
double qfloat_get_double(const QFloat *qf)
|
||||
{
|
||||
return qf->value;
|
||||
}
|
||||
|
||||
/**
|
||||
* qobject_to_qfloat(): Convert a QObject into a QFloat
|
||||
*/
|
||||
QFloat *qobject_to_qfloat(const QObject *obj)
|
||||
{
|
||||
if (!obj || qobject_type(obj) != QTYPE_QFLOAT) {
|
||||
return NULL;
|
||||
}
|
||||
return container_of(obj, QFloat, base);
|
||||
}
|
||||
|
||||
/**
|
||||
* qfloat_destroy_obj(): Free all memory allocated by a
|
||||
* QFloat object
|
||||
*/
|
||||
void qfloat_destroy_obj(QObject *obj)
|
||||
{
|
||||
assert(obj != NULL);
|
||||
g_free(qobject_to_qfloat(obj));
|
||||
}
|
@@ -1,61 +0,0 @@
|
||||
/*
|
||||
* QInt Module
|
||||
*
|
||||
* Copyright (C) 2009 Red Hat Inc.
|
||||
*
|
||||
* Authors:
|
||||
* Luiz Capitulino <lcapitulino@redhat.com>
|
||||
*
|
||||
* This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
|
||||
* See the COPYING.LIB file in the top-level directory.
|
||||
*/
|
||||
|
||||
#include "qemu/osdep.h"
|
||||
#include "qapi/qmp/qint.h"
|
||||
#include "qapi/qmp/qobject.h"
|
||||
#include "qemu-common.h"
|
||||
|
||||
/**
|
||||
* qint_from_int(): Create a new QInt from an int64_t
|
||||
*
|
||||
* Return strong reference.
|
||||
*/
|
||||
QInt *qint_from_int(int64_t value)
|
||||
{
|
||||
QInt *qi;
|
||||
|
||||
qi = g_malloc(sizeof(*qi));
|
||||
qobject_init(QOBJECT(qi), QTYPE_QINT);
|
||||
qi->value = value;
|
||||
|
||||
return qi;
|
||||
}
|
||||
|
||||
/**
|
||||
* qint_get_int(): Get the stored integer
|
||||
*/
|
||||
int64_t qint_get_int(const QInt *qi)
|
||||
{
|
||||
return qi->value;
|
||||
}
|
||||
|
||||
/**
|
||||
* qobject_to_qint(): Convert a QObject into a QInt
|
||||
*/
|
||||
QInt *qobject_to_qint(const QObject *obj)
|
||||
{
|
||||
if (!obj || qobject_type(obj) != QTYPE_QINT) {
|
||||
return NULL;
|
||||
}
|
||||
return container_of(obj, QInt, base);
|
||||
}
|
||||
|
||||
/**
|
||||
* qint_destroy_obj(): Free all memory allocated by a
|
||||
* QInt object
|
||||
*/
|
||||
void qint_destroy_obj(QObject *obj)
|
||||
{
|
||||
assert(obj != NULL);
|
||||
g_free(qobject_to_qint(obj));
|
||||
}
|
@@ -132,12 +132,11 @@ static void to_json(const QObject *obj, QString *str, int pretty, int indent)
|
||||
case QTYPE_QNULL:
|
||||
qstring_append(str, "null");
|
||||
break;
|
||||
case QTYPE_QINT: {
|
||||
QInt *val = qobject_to_qint(obj);
|
||||
char buffer[1024];
|
||||
|
||||
snprintf(buffer, sizeof(buffer), "%" PRId64, qint_get_int(val));
|
||||
case QTYPE_QNUM: {
|
||||
QNum *val = qobject_to_qnum(obj);
|
||||
char *buffer = qnum_to_string(val);
|
||||
qstring_append(str, buffer);
|
||||
g_free(buffer);
|
||||
break;
|
||||
}
|
||||
case QTYPE_QSTRING: {
|
||||
@@ -234,34 +233,6 @@ static void to_json(const QObject *obj, QString *str, int pretty, int indent)
|
||||
qstring_append(str, "]");
|
||||
break;
|
||||
}
|
||||
case QTYPE_QFLOAT: {
|
||||
QFloat *val = qobject_to_qfloat(obj);
|
||||
char buffer[1024];
|
||||
int len;
|
||||
|
||||
/* FIXME: snprintf() is locale dependent; but JSON requires
|
||||
* numbers to be formatted as if in the C locale. Dependence
|
||||
* on C locale is a pervasive issue in QEMU. */
|
||||
/* FIXME: This risks printing Inf or NaN, which are not valid
|
||||
* JSON values. */
|
||||
/* FIXME: the default precision of 6 for %f often causes
|
||||
* rounding errors; we should be using DBL_DECIMAL_DIG (17),
|
||||
* and only rounding to a shorter number if the result would
|
||||
* still produce the same floating point value. */
|
||||
len = snprintf(buffer, sizeof(buffer), "%f", qfloat_get_double(val));
|
||||
while (len > 0 && buffer[len - 1] == '0') {
|
||||
len--;
|
||||
}
|
||||
|
||||
if (len && buffer[len - 1] == '.') {
|
||||
buffer[len - 1] = 0;
|
||||
} else {
|
||||
buffer[len] = 0;
|
||||
}
|
||||
|
||||
qstring_append(str, buffer);
|
||||
break;
|
||||
}
|
||||
case QTYPE_QBOOL: {
|
||||
QBool *val = qobject_to_qbool(obj);
|
||||
|
||||
|
223
qobject/qnum.c
Normal file
223
qobject/qnum.c
Normal file
@@ -0,0 +1,223 @@
|
||||
/*
|
||||
* QNum Module
|
||||
*
|
||||
* Copyright (C) 2009 Red Hat Inc.
|
||||
*
|
||||
* Authors:
|
||||
* Luiz Capitulino <lcapitulino@redhat.com>
|
||||
* Anthony Liguori <aliguori@us.ibm.com>
|
||||
* Marc-André Lureau <marcandre.lureau@redhat.com>
|
||||
*
|
||||
* This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
|
||||
* See the COPYING.LIB file in the top-level directory.
|
||||
*/
|
||||
|
||||
#include "qemu/osdep.h"
|
||||
#include "qapi/error.h"
|
||||
#include "qapi/qmp/qnum.h"
|
||||
#include "qapi/qmp/qobject.h"
|
||||
#include "qemu-common.h"
|
||||
|
||||
/**
|
||||
* qnum_from_int(): Create a new QNum from an int64_t
|
||||
*
|
||||
* Return strong reference.
|
||||
*/
|
||||
QNum *qnum_from_int(int64_t value)
|
||||
{
|
||||
QNum *qn = g_new(QNum, 1);
|
||||
|
||||
qobject_init(QOBJECT(qn), QTYPE_QNUM);
|
||||
qn->kind = QNUM_I64;
|
||||
qn->u.i64 = value;
|
||||
|
||||
return qn;
|
||||
}
|
||||
|
||||
/**
|
||||
* qnum_from_uint(): Create a new QNum from an uint64_t
|
||||
*
|
||||
* Return strong reference.
|
||||
*/
|
||||
QNum *qnum_from_uint(uint64_t value)
|
||||
{
|
||||
QNum *qn = g_new(QNum, 1);
|
||||
|
||||
qobject_init(QOBJECT(qn), QTYPE_QNUM);
|
||||
qn->kind = QNUM_U64;
|
||||
qn->u.u64 = value;
|
||||
|
||||
return qn;
|
||||
}
|
||||
|
||||
/**
|
||||
* qnum_from_double(): Create a new QNum from a double
|
||||
*
|
||||
* Return strong reference.
|
||||
*/
|
||||
QNum *qnum_from_double(double value)
|
||||
{
|
||||
QNum *qn = g_new(QNum, 1);
|
||||
|
||||
qobject_init(QOBJECT(qn), QTYPE_QNUM);
|
||||
qn->kind = QNUM_DOUBLE;
|
||||
qn->u.dbl = value;
|
||||
|
||||
return qn;
|
||||
}
|
||||
|
||||
/**
|
||||
* qnum_get_try_int(): Get an integer representation of the number
|
||||
*
|
||||
* Return true on success.
|
||||
*/
|
||||
bool qnum_get_try_int(const QNum *qn, int64_t *val)
|
||||
{
|
||||
switch (qn->kind) {
|
||||
case QNUM_I64:
|
||||
*val = qn->u.i64;
|
||||
return true;
|
||||
case QNUM_U64:
|
||||
if (qn->u.u64 > INT64_MAX) {
|
||||
return false;
|
||||
}
|
||||
*val = qn->u.u64;
|
||||
return true;
|
||||
case QNUM_DOUBLE:
|
||||
return false;
|
||||
}
|
||||
|
||||
assert(0);
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* qnum_get_int(): Get an integer representation of the number
|
||||
*
|
||||
* assert() on failure.
|
||||
*/
|
||||
int64_t qnum_get_int(const QNum *qn)
|
||||
{
|
||||
int64_t val;
|
||||
bool success = qnum_get_try_int(qn, &val);
|
||||
assert(success);
|
||||
return val;
|
||||
}
|
||||
|
||||
/**
|
||||
* qnum_get_uint(): Get an unsigned integer from the number
|
||||
*
|
||||
* Return true on success.
|
||||
*/
|
||||
bool qnum_get_try_uint(const QNum *qn, uint64_t *val)
|
||||
{
|
||||
switch (qn->kind) {
|
||||
case QNUM_I64:
|
||||
if (qn->u.i64 < 0) {
|
||||
return false;
|
||||
}
|
||||
*val = qn->u.i64;
|
||||
return true;
|
||||
case QNUM_U64:
|
||||
*val = qn->u.u64;
|
||||
return true;
|
||||
case QNUM_DOUBLE:
|
||||
return false;
|
||||
}
|
||||
|
||||
assert(0);
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* qnum_get_uint(): Get an unsigned integer from the number
|
||||
*
|
||||
* assert() on failure.
|
||||
*/
|
||||
uint64_t qnum_get_uint(const QNum *qn)
|
||||
{
|
||||
uint64_t val;
|
||||
bool success = qnum_get_try_uint(qn, &val);
|
||||
assert(success);
|
||||
return val;
|
||||
}
|
||||
|
||||
/**
|
||||
* qnum_get_double(): Get a float representation of the number
|
||||
*
|
||||
* qnum_get_double() loses precision for integers beyond 53 bits.
|
||||
*/
|
||||
double qnum_get_double(QNum *qn)
|
||||
{
|
||||
switch (qn->kind) {
|
||||
case QNUM_I64:
|
||||
return qn->u.i64;
|
||||
case QNUM_U64:
|
||||
return qn->u.u64;
|
||||
case QNUM_DOUBLE:
|
||||
return qn->u.dbl;
|
||||
}
|
||||
|
||||
assert(0);
|
||||
return 0.0;
|
||||
}
|
||||
|
||||
char *qnum_to_string(QNum *qn)
|
||||
{
|
||||
char *buffer;
|
||||
int len;
|
||||
|
||||
switch (qn->kind) {
|
||||
case QNUM_I64:
|
||||
return g_strdup_printf("%" PRId64, qn->u.i64);
|
||||
case QNUM_U64:
|
||||
return g_strdup_printf("%" PRIu64, qn->u.u64);
|
||||
case QNUM_DOUBLE:
|
||||
/* FIXME: snprintf() is locale dependent; but JSON requires
|
||||
* numbers to be formatted as if in the C locale. Dependence
|
||||
* on C locale is a pervasive issue in QEMU. */
|
||||
/* FIXME: This risks printing Inf or NaN, which are not valid
|
||||
* JSON values. */
|
||||
/* FIXME: the default precision of 6 for %f often causes
|
||||
* rounding errors; we should be using DBL_DECIMAL_DIG (17),
|
||||
* and only rounding to a shorter number if the result would
|
||||
* still produce the same floating point value. */
|
||||
buffer = g_strdup_printf("%f" , qn->u.dbl);
|
||||
len = strlen(buffer);
|
||||
while (len > 0 && buffer[len - 1] == '0') {
|
||||
len--;
|
||||
}
|
||||
|
||||
if (len && buffer[len - 1] == '.') {
|
||||
buffer[len - 1] = 0;
|
||||
} else {
|
||||
buffer[len] = 0;
|
||||
}
|
||||
|
||||
return buffer;
|
||||
}
|
||||
|
||||
assert(0);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/**
|
||||
* qobject_to_qnum(): Convert a QObject into a QNum
|
||||
*/
|
||||
QNum *qobject_to_qnum(const QObject *obj)
|
||||
{
|
||||
if (!obj || qobject_type(obj) != QTYPE_QNUM) {
|
||||
return NULL;
|
||||
}
|
||||
return container_of(obj, QNum, base);
|
||||
}
|
||||
|
||||
/**
|
||||
* qnum_destroy_obj(): Free all memory allocated by a
|
||||
* QNum object
|
||||
*/
|
||||
void qnum_destroy_obj(QObject *obj)
|
||||
{
|
||||
assert(obj != NULL);
|
||||
g_free(qobject_to_qnum(obj));
|
||||
}
|
@@ -14,11 +14,10 @@
|
||||
static void (*qdestroy[QTYPE__MAX])(QObject *) = {
|
||||
[QTYPE_NONE] = NULL, /* No such object exists */
|
||||
[QTYPE_QNULL] = NULL, /* qnull_ is indestructible */
|
||||
[QTYPE_QINT] = qint_destroy_obj,
|
||||
[QTYPE_QNUM] = qnum_destroy_obj,
|
||||
[QTYPE_QSTRING] = qstring_destroy_obj,
|
||||
[QTYPE_QDICT] = qdict_destroy_obj,
|
||||
[QTYPE_QLIST] = qlist_destroy_obj,
|
||||
[QTYPE_QFLOAT] = qfloat_destroy_obj,
|
||||
[QTYPE_QBOOL] = qbool_destroy_obj,
|
||||
};
|
||||
|
||||
|
51
qom/object.c
51
qom/object.c
@@ -27,7 +27,6 @@
|
||||
#include "qom/qom-qobject.h"
|
||||
#include "qapi/qmp/qobject.h"
|
||||
#include "qapi/qmp/qbool.h"
|
||||
#include "qapi/qmp/qint.h"
|
||||
#include "qapi/qmp/qstring.h"
|
||||
|
||||
#define MAX_INTERFACES 32
|
||||
@@ -1122,7 +1121,7 @@ char *object_property_get_str(Object *obj, const char *name,
|
||||
retval = g_strdup(qstring_get_str(qstring));
|
||||
}
|
||||
|
||||
QDECREF(qstring);
|
||||
qobject_decref(ret);
|
||||
return retval;
|
||||
}
|
||||
|
||||
@@ -1183,38 +1182,66 @@ bool object_property_get_bool(Object *obj, const char *name,
|
||||
retval = qbool_get_bool(qbool);
|
||||
}
|
||||
|
||||
QDECREF(qbool);
|
||||
qobject_decref(ret);
|
||||
return retval;
|
||||
}
|
||||
|
||||
void object_property_set_int(Object *obj, int64_t value,
|
||||
const char *name, Error **errp)
|
||||
{
|
||||
QInt *qint = qint_from_int(value);
|
||||
object_property_set_qobject(obj, QOBJECT(qint), name, errp);
|
||||
QNum *qnum = qnum_from_int(value);
|
||||
object_property_set_qobject(obj, QOBJECT(qnum), name, errp);
|
||||
|
||||
QDECREF(qint);
|
||||
QDECREF(qnum);
|
||||
}
|
||||
|
||||
int64_t object_property_get_int(Object *obj, const char *name,
|
||||
Error **errp)
|
||||
{
|
||||
QObject *ret = object_property_get_qobject(obj, name, errp);
|
||||
QInt *qint;
|
||||
QNum *qnum;
|
||||
int64_t retval;
|
||||
|
||||
if (!ret) {
|
||||
return -1;
|
||||
}
|
||||
qint = qobject_to_qint(ret);
|
||||
if (!qint) {
|
||||
|
||||
qnum = qobject_to_qnum(ret);
|
||||
if (!qnum || !qnum_get_try_int(qnum, &retval)) {
|
||||
error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name, "int");
|
||||
retval = -1;
|
||||
} else {
|
||||
retval = qint_get_int(qint);
|
||||
}
|
||||
|
||||
QDECREF(qint);
|
||||
qobject_decref(ret);
|
||||
return retval;
|
||||
}
|
||||
|
||||
void object_property_set_uint(Object *obj, uint64_t value,
|
||||
const char *name, Error **errp)
|
||||
{
|
||||
QNum *qnum = qnum_from_uint(value);
|
||||
|
||||
object_property_set_qobject(obj, QOBJECT(qnum), name, errp);
|
||||
QDECREF(qnum);
|
||||
}
|
||||
|
||||
uint64_t object_property_get_uint(Object *obj, const char *name,
|
||||
Error **errp)
|
||||
{
|
||||
QObject *ret = object_property_get_qobject(obj, name, errp);
|
||||
QNum *qnum;
|
||||
uint64_t retval;
|
||||
|
||||
if (!ret) {
|
||||
return 0;
|
||||
}
|
||||
qnum = qobject_to_qnum(ret);
|
||||
if (!qnum || !qnum_get_try_uint(qnum, &retval)) {
|
||||
error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name, "uint");
|
||||
retval = 0;
|
||||
}
|
||||
|
||||
qobject_decref(ret);
|
||||
return retval;
|
||||
}
|
||||
|
||||
|
@@ -6,7 +6,7 @@ expression Obj, Key, E;
|
||||
- qdict_put_obj(Obj, Key, QOBJECT(E));
|
||||
+ qdict_put(Obj, Key, E);
|
||||
|
|
||||
- qdict_put(Obj, Key, qint_from_int(E));
|
||||
- qdict_put(Obj, Key, qnum_from_int(E));
|
||||
+ qdict_put_int(Obj, Key, E);
|
||||
|
|
||||
- qdict_put(Obj, Key, qbool_from_bool(E));
|
||||
@@ -24,7 +24,7 @@ expression Obj, E;
|
||||
- qlist_append_obj(Obj, QOBJECT(E));
|
||||
+ qlist_append(Obj, E);
|
||||
|
|
||||
- qlist_append(Obj, qint_from_int(E));
|
||||
- qlist_append(Obj, qnum_from_int(E));
|
||||
+ qlist_append_int(Obj, E);
|
||||
|
|
||||
- qlist_append(Obj, qbool_from_bool(E));
|
||||
|
@@ -161,20 +161,14 @@ void visit_type_%(c_name)s(Visitor *v, const char *name, %(c_name)s *obj, Error
|
||||
|
||||
|
||||
def gen_visit_alternate(name, variants):
|
||||
promote_int = 'true'
|
||||
ret = ''
|
||||
for var in variants.variants:
|
||||
if var.type.alternate_qtype() == 'QTYPE_QINT':
|
||||
promote_int = 'false'
|
||||
|
||||
ret += mcgen('''
|
||||
ret = mcgen('''
|
||||
|
||||
void visit_type_%(c_name)s(Visitor *v, const char *name, %(c_name)s **obj, Error **errp)
|
||||
{
|
||||
Error *err = NULL;
|
||||
|
||||
visit_start_alternate(v, name, (GenericAlternate **)obj, sizeof(**obj),
|
||||
%(promote_int)s, &err);
|
||||
&err);
|
||||
if (err) {
|
||||
goto out;
|
||||
}
|
||||
@@ -183,7 +177,7 @@ void visit_type_%(c_name)s(Visitor *v, const char *name, %(c_name)s **obj, Error
|
||||
}
|
||||
switch ((*obj)->type) {
|
||||
''',
|
||||
c_name=c_name(name), promote_int=promote_int)
|
||||
c_name=c_name(name))
|
||||
|
||||
for var in variants.variants:
|
||||
ret += mcgen('''
|
||||
|
@@ -21,18 +21,18 @@ from ordereddict import OrderedDict
|
||||
|
||||
builtin_types = {
|
||||
'str': 'QTYPE_QSTRING',
|
||||
'int': 'QTYPE_QINT',
|
||||
'number': 'QTYPE_QFLOAT',
|
||||
'int': 'QTYPE_QNUM',
|
||||
'number': 'QTYPE_QNUM',
|
||||
'bool': 'QTYPE_QBOOL',
|
||||
'int8': 'QTYPE_QINT',
|
||||
'int16': 'QTYPE_QINT',
|
||||
'int32': 'QTYPE_QINT',
|
||||
'int64': 'QTYPE_QINT',
|
||||
'uint8': 'QTYPE_QINT',
|
||||
'uint16': 'QTYPE_QINT',
|
||||
'uint32': 'QTYPE_QINT',
|
||||
'uint64': 'QTYPE_QINT',
|
||||
'size': 'QTYPE_QINT',
|
||||
'int8': 'QTYPE_QNUM',
|
||||
'int16': 'QTYPE_QNUM',
|
||||
'int32': 'QTYPE_QNUM',
|
||||
'int64': 'QTYPE_QNUM',
|
||||
'uint8': 'QTYPE_QNUM',
|
||||
'uint16': 'QTYPE_QNUM',
|
||||
'uint32': 'QTYPE_QNUM',
|
||||
'uint64': 'QTYPE_QNUM',
|
||||
'size': 'QTYPE_QNUM',
|
||||
'any': None, # any QType possible, actually
|
||||
'QType': 'QTYPE_QSTRING',
|
||||
}
|
||||
@@ -820,11 +820,9 @@ def check_alternate(expr, info):
|
||||
if v in ['on', 'off']:
|
||||
conflicting.add('QTYPE_QBOOL')
|
||||
if re.match(r'[-+0-9.]', v): # lazy, could be tightened
|
||||
conflicting.add('QTYPE_QINT')
|
||||
conflicting.add('QTYPE_QFLOAT')
|
||||
conflicting.add('QTYPE_QNUM')
|
||||
else:
|
||||
conflicting.add('QTYPE_QINT')
|
||||
conflicting.add('QTYPE_QFLOAT')
|
||||
conflicting.add('QTYPE_QNUM')
|
||||
conflicting.add('QTYPE_QBOOL')
|
||||
if conflicting & set(types_seen):
|
||||
raise QAPISemError(info, "Alternate '%s' member '%s' can't "
|
||||
@@ -1059,8 +1057,8 @@ class QAPISchemaType(QAPISchemaEntity):
|
||||
def alternate_qtype(self):
|
||||
json2qtype = {
|
||||
'string': 'QTYPE_QSTRING',
|
||||
'number': 'QTYPE_QFLOAT',
|
||||
'int': 'QTYPE_QINT',
|
||||
'number': 'QTYPE_QNUM',
|
||||
'int': 'QTYPE_QNUM',
|
||||
'boolean': 'QTYPE_QBOOL',
|
||||
'object': 'QTYPE_QDICT'
|
||||
}
|
||||
@@ -1522,9 +1520,9 @@ class QAPISchema(object):
|
||||
self.the_empty_object_type = QAPISchemaObjectType(
|
||||
'q_empty', None, None, None, [], None)
|
||||
self._def_entity(self.the_empty_object_type)
|
||||
qtype_values = self._make_enum_members(['none', 'qnull', 'qint',
|
||||
qtype_values = self._make_enum_members(['none', 'qnull', 'qnum',
|
||||
'qstring', 'qdict', 'qlist',
|
||||
'qfloat', 'qbool'])
|
||||
'qbool'])
|
||||
self._def_entity(QAPISchemaEnumType('QType', None, None,
|
||||
qtype_values, 'QTYPE'))
|
||||
|
||||
|
@@ -84,6 +84,7 @@ typedef enum {
|
||||
the PC (for whatever reason), so there's no need to do it again on
|
||||
exiting the TB. */
|
||||
EXIT_PC_UPDATED,
|
||||
EXIT_PC_UPDATED_NOCHAIN,
|
||||
|
||||
/* We are exiting the TB, but have neither emitted a goto_tb, nor
|
||||
updated the PC for the next instruction to be executed. */
|
||||
@@ -458,11 +459,17 @@ static bool in_superpage(DisasContext *ctx, int64_t addr)
|
||||
#endif
|
||||
}
|
||||
|
||||
static bool use_exit_tb(DisasContext *ctx)
|
||||
{
|
||||
return ((ctx->tb->cflags & CF_LAST_IO)
|
||||
|| ctx->singlestep_enabled
|
||||
|| singlestep);
|
||||
}
|
||||
|
||||
static bool use_goto_tb(DisasContext *ctx, uint64_t dest)
|
||||
{
|
||||
/* Suppress goto_tb in the case of single-steping and IO. */
|
||||
if ((ctx->tb->cflags & CF_LAST_IO)
|
||||
|| ctx->singlestep_enabled || singlestep) {
|
||||
if (unlikely(use_exit_tb(ctx))) {
|
||||
return false;
|
||||
}
|
||||
#ifndef CONFIG_USER_ONLY
|
||||
@@ -1198,7 +1205,10 @@ static ExitStatus gen_call_pal(DisasContext *ctx, int palcode)
|
||||
tcg_gen_andi_i64(tmp, ctx->ir[IR_A0], PS_INT_MASK);
|
||||
tcg_gen_st8_i64(tmp, cpu_env, offsetof(CPUAlphaState, ps));
|
||||
tcg_temp_free(tmp);
|
||||
break;
|
||||
|
||||
/* Allow interrupts to be recognized right away. */
|
||||
tcg_gen_movi_i64(cpu_pc, ctx->pc);
|
||||
return EXIT_PC_UPDATED_NOCHAIN;
|
||||
|
||||
case 0x36:
|
||||
/* RDPS */
|
||||
@@ -1266,7 +1276,7 @@ static ExitStatus gen_call_pal(DisasContext *ctx, int palcode)
|
||||
need the page permissions check. We'll see the existence of
|
||||
the page when we create the TB, and we'll flush all TBs if
|
||||
we change the PAL base register. */
|
||||
if (!ctx->singlestep_enabled && !(ctx->tb->cflags & CF_LAST_IO)) {
|
||||
if (!use_exit_tb(ctx)) {
|
||||
tcg_gen_goto_tb(0);
|
||||
tcg_gen_movi_i64(cpu_pc, entry);
|
||||
tcg_gen_exit_tb((uintptr_t)ctx->tb);
|
||||
@@ -2686,7 +2696,8 @@ static ExitStatus translate_one(DisasContext *ctx, uint32_t insn)
|
||||
tcg_gen_andi_i64(tmp, vb, 1);
|
||||
tcg_gen_st8_i64(tmp, cpu_env, offsetof(CPUAlphaState, pal_mode));
|
||||
tcg_gen_andi_i64(cpu_pc, vb, ~3);
|
||||
ret = EXIT_PC_UPDATED;
|
||||
/* Allow interrupts to be recognized right away. */
|
||||
ret = EXIT_PC_UPDATED_NOCHAIN;
|
||||
break;
|
||||
#else
|
||||
goto invalid_opc;
|
||||
@@ -3010,6 +3021,12 @@ void gen_intermediate_code(CPUAlphaState *env, struct TranslationBlock *tb)
|
||||
tcg_gen_movi_i64(cpu_pc, ctx.pc);
|
||||
/* FALLTHRU */
|
||||
case EXIT_PC_UPDATED:
|
||||
if (!use_exit_tb(&ctx)) {
|
||||
tcg_gen_lookup_and_goto_ptr(cpu_pc);
|
||||
break;
|
||||
}
|
||||
/* FALLTHRU */
|
||||
case EXIT_PC_UPDATED_NOCHAIN:
|
||||
if (ctx.singlestep_enabled) {
|
||||
gen_excp_1(EXCP_DEBUG, 0);
|
||||
} else {
|
||||
|
@@ -1422,7 +1422,9 @@ static void handle_msr_i(DisasContext *s, uint32_t insn,
|
||||
gen_helper_msr_i_pstate(cpu_env, tcg_op, tcg_imm);
|
||||
tcg_temp_free_i32(tcg_imm);
|
||||
tcg_temp_free_i32(tcg_op);
|
||||
s->is_jmp = DISAS_UPDATE;
|
||||
/* For DAIFClear, exit the cpu loop to re-evaluate pending IRQs. */
|
||||
gen_a64_set_pc_im(s->pc);
|
||||
s->is_jmp = (op == 0x1f ? DISAS_EXIT : DISAS_JUMP);
|
||||
break;
|
||||
}
|
||||
default:
|
||||
@@ -11369,6 +11371,9 @@ void gen_intermediate_code_a64(ARMCPU *cpu, TranslationBlock *tb)
|
||||
case DISAS_JUMP:
|
||||
tcg_gen_lookup_and_goto_ptr(cpu_pc);
|
||||
break;
|
||||
case DISAS_EXIT:
|
||||
tcg_gen_exit_tb(0);
|
||||
break;
|
||||
case DISAS_TB_JUMP:
|
||||
case DISAS_EXC:
|
||||
case DISAS_SWI:
|
||||
|
@@ -29,11 +29,7 @@
|
||||
#include "qemu/option.h"
|
||||
#include "qemu/config-file.h"
|
||||
#include "qapi/qmp/qerror.h"
|
||||
#include "qapi/qmp/qstring.h"
|
||||
#include "qapi/qmp/qdict.h"
|
||||
#include "qapi/qmp/qbool.h"
|
||||
#include "qapi/qmp/qint.h"
|
||||
#include "qapi/qmp/qfloat.h"
|
||||
#include "qapi/qmp/types.h"
|
||||
|
||||
#include "qapi-types.h"
|
||||
#include "qapi-visit.h"
|
||||
@@ -2328,8 +2324,8 @@ static void x86_cpu_load_def(X86CPU *cpu, X86CPUDefinition *def, Error **errp)
|
||||
*/
|
||||
|
||||
/* CPU models only set _minimum_ values for level/xlevel: */
|
||||
object_property_set_int(OBJECT(cpu), def->level, "min-level", errp);
|
||||
object_property_set_int(OBJECT(cpu), def->xlevel, "min-xlevel", errp);
|
||||
object_property_set_uint(OBJECT(cpu), def->level, "min-level", errp);
|
||||
object_property_set_uint(OBJECT(cpu), def->xlevel, "min-xlevel", errp);
|
||||
|
||||
object_property_set_int(OBJECT(cpu), def->family, "family", errp);
|
||||
object_property_set_int(OBJECT(cpu), def->model, "model", errp);
|
||||
|
@@ -1173,6 +1173,8 @@ typedef enum {
|
||||
/* We are exiting the TB, but have neither emitted a goto_tb, nor
|
||||
updated the PC for the next instruction to be executed. */
|
||||
EXIT_PC_STALE,
|
||||
/* We are exiting the TB to the main loop. */
|
||||
EXIT_PC_STALE_NOCHAIN,
|
||||
/* We are ending the TB with a noreturn function call, e.g. longjmp.
|
||||
No following code will be executed. */
|
||||
EXIT_NORETURN,
|
||||
@@ -3795,7 +3797,8 @@ static ExitStatus op_ssm(DisasContext *s, DisasOps *o)
|
||||
{
|
||||
check_privileged(s);
|
||||
tcg_gen_deposit_i64(psw_mask, psw_mask, o->in2, 56, 8);
|
||||
return NO_EXIT;
|
||||
/* Exit to main loop to reevaluate s390_cpu_exec_interrupt. */
|
||||
return EXIT_PC_STALE_NOCHAIN;
|
||||
}
|
||||
|
||||
static ExitStatus op_stap(DisasContext *s, DisasOps *o)
|
||||
@@ -4038,7 +4041,9 @@ static ExitStatus op_stnosm(DisasContext *s, DisasOps *o)
|
||||
} else {
|
||||
tcg_gen_ori_i64(psw_mask, psw_mask, i2 << 56);
|
||||
}
|
||||
return NO_EXIT;
|
||||
|
||||
/* Exit to main loop to reevaluate s390_cpu_exec_interrupt. */
|
||||
return EXIT_PC_STALE_NOCHAIN;
|
||||
}
|
||||
|
||||
static ExitStatus op_stura(DisasContext *s, DisasOps *o)
|
||||
@@ -5788,6 +5793,7 @@ void gen_intermediate_code(CPUS390XState *env, struct TranslationBlock *tb)
|
||||
case EXIT_NORETURN:
|
||||
break;
|
||||
case EXIT_PC_STALE:
|
||||
case EXIT_PC_STALE_NOCHAIN:
|
||||
update_psw_addr(&dc);
|
||||
/* FALLTHRU */
|
||||
case EXIT_PC_UPDATED:
|
||||
@@ -5799,14 +5805,14 @@ void gen_intermediate_code(CPUS390XState *env, struct TranslationBlock *tb)
|
||||
/* Exit the TB, either by raising a debug exception or by return. */
|
||||
if (do_debug) {
|
||||
gen_exception(EXCP_DEBUG);
|
||||
} else if (use_exit_tb(&dc)) {
|
||||
} else if (use_exit_tb(&dc) || status == EXIT_PC_STALE_NOCHAIN) {
|
||||
tcg_gen_exit_tb(0);
|
||||
} else {
|
||||
tcg_gen_lookup_and_goto_ptr(psw_addr);
|
||||
}
|
||||
break;
|
||||
default:
|
||||
abort();
|
||||
g_assert_not_reached();
|
||||
}
|
||||
|
||||
gen_tb_end(tb, num_insns);
|
||||
|
@@ -616,7 +616,12 @@ static void tcg_out_movi(TCGContext *s, TCGType type, TCGReg rd,
|
||||
/* Look for host pointer values within 4G of the PC. This happens
|
||||
often when loading pointers to QEMU's own data structures. */
|
||||
if (type == TCG_TYPE_I64) {
|
||||
tcg_target_long disp = (value >> 12) - ((intptr_t)s->code_ptr >> 12);
|
||||
tcg_target_long disp = value - (intptr_t)s->code_ptr;
|
||||
if (disp == sextract64(disp, 0, 21)) {
|
||||
tcg_out_insn(s, 3406, ADR, rd, disp);
|
||||
return;
|
||||
}
|
||||
disp = (value >> 12) - ((intptr_t)s->code_ptr >> 12);
|
||||
if (disp == sextract64(disp, 0, 21)) {
|
||||
tcg_out_insn(s, 3406, ADRP, rd, disp);
|
||||
if (value & 0xfff) {
|
||||
|
@@ -418,23 +418,37 @@ static inline void tcg_out_dat_imm(TCGContext *s,
|
||||
|
||||
static void tcg_out_movi32(TCGContext *s, int cond, int rd, uint32_t arg)
|
||||
{
|
||||
int rot, opc, rn;
|
||||
int rot, opc, rn, diff;
|
||||
|
||||
/* For armv7, make sure not to use movw+movt when mov/mvn would do.
|
||||
Speed things up by only checking when movt would be required.
|
||||
Prior to armv7, have one go at fully rotated immediates before
|
||||
doing the decomposition thing below. */
|
||||
if (!use_armv7_instructions || (arg & 0xffff0000)) {
|
||||
rot = encode_imm(arg);
|
||||
/* Check a single MOV/MVN before anything else. */
|
||||
rot = encode_imm(arg);
|
||||
if (rot >= 0) {
|
||||
tcg_out_dat_imm(s, cond, ARITH_MOV, rd, 0,
|
||||
rotl(arg, rot) | (rot << 7));
|
||||
return;
|
||||
}
|
||||
rot = encode_imm(~arg);
|
||||
if (rot >= 0) {
|
||||
tcg_out_dat_imm(s, cond, ARITH_MVN, rd, 0,
|
||||
rotl(~arg, rot) | (rot << 7));
|
||||
return;
|
||||
}
|
||||
|
||||
/* Check for a pc-relative address. This will usually be the TB,
|
||||
or within the TB, which is immediately before the code block. */
|
||||
diff = arg - ((intptr_t)s->code_ptr + 8);
|
||||
if (diff >= 0) {
|
||||
rot = encode_imm(diff);
|
||||
if (rot >= 0) {
|
||||
tcg_out_dat_imm(s, cond, ARITH_MOV, rd, 0,
|
||||
rotl(arg, rot) | (rot << 7));
|
||||
tcg_out_dat_imm(s, cond, ARITH_ADD, rd, TCG_REG_PC,
|
||||
rotl(diff, rot) | (rot << 7));
|
||||
return;
|
||||
}
|
||||
rot = encode_imm(~arg);
|
||||
} else {
|
||||
rot = encode_imm(-diff);
|
||||
if (rot >= 0) {
|
||||
tcg_out_dat_imm(s, cond, ARITH_MVN, rd, 0,
|
||||
rotl(~arg, rot) | (rot << 7));
|
||||
tcg_out_dat_imm(s, cond, ARITH_SUB, rd, TCG_REG_PC,
|
||||
rotl(-diff, rot) | (rot << 7));
|
||||
return;
|
||||
}
|
||||
}
|
||||
@@ -1026,16 +1040,6 @@ static void tcg_out_call(TCGContext *s, tcg_insn_unit *addr)
|
||||
}
|
||||
}
|
||||
|
||||
void arm_tb_set_jmp_target(uintptr_t jmp_addr, uintptr_t addr)
|
||||
{
|
||||
tcg_insn_unit *code_ptr = (tcg_insn_unit *)jmp_addr;
|
||||
tcg_insn_unit *target = (tcg_insn_unit *)addr;
|
||||
|
||||
/* we could use a ldr pc, [pc, #-4] kind of branch and avoid the flush */
|
||||
reloc_pc24_atomic(code_ptr, target);
|
||||
flush_icache_range(jmp_addr, jmp_addr + 4);
|
||||
}
|
||||
|
||||
static inline void tcg_out_goto_label(TCGContext *s, int cond, TCGLabel *l)
|
||||
{
|
||||
if (l->has_value) {
|
||||
@@ -1665,17 +1669,27 @@ static inline void tcg_out_op(TCGContext *s, TCGOpcode opc,
|
||||
}
|
||||
break;
|
||||
case INDEX_op_goto_tb:
|
||||
if (s->tb_jmp_insn_offset) {
|
||||
/* Direct jump method */
|
||||
s->tb_jmp_insn_offset[args[0]] = tcg_current_code_size(s);
|
||||
tcg_out_b_noaddr(s, COND_AL);
|
||||
} else {
|
||||
{
|
||||
/* Indirect jump method */
|
||||
intptr_t ptr = (intptr_t)(s->tb_jmp_target_addr + args[0]);
|
||||
tcg_out_movi32(s, COND_AL, TCG_REG_R0, ptr & ~0xfff);
|
||||
tcg_out_ld32_12(s, COND_AL, TCG_REG_PC, TCG_REG_R0, ptr & 0xfff);
|
||||
intptr_t ptr, dif, dil;
|
||||
TCGReg base = TCG_REG_PC;
|
||||
|
||||
tcg_debug_assert(s->tb_jmp_insn_offset == 0);
|
||||
ptr = (intptr_t)(s->tb_jmp_target_addr + args[0]);
|
||||
dif = ptr - ((intptr_t)s->code_ptr + 8);
|
||||
dil = sextract32(dif, 0, 12);
|
||||
if (dif != dil) {
|
||||
/* The TB is close, but outside the 12 bits addressable by
|
||||
the load. We can extend this to 20 bits with a sub of a
|
||||
shifted immediate from pc. In the vastly unlikely event
|
||||
the code requires more than 1MB, we'll use 2 insns and
|
||||
be no worse off. */
|
||||
base = TCG_REG_R0;
|
||||
tcg_out_movi32(s, COND_AL, base, ptr - dil);
|
||||
}
|
||||
tcg_out_ld32_12(s, COND_AL, TCG_REG_PC, base, dil);
|
||||
s->tb_jmp_reset_offset[args[0]] = tcg_current_code_size(s);
|
||||
}
|
||||
s->tb_jmp_reset_offset[args[0]] = tcg_current_code_size(s);
|
||||
break;
|
||||
case INDEX_op_goto_ptr:
|
||||
tcg_out_bx(s, COND_AL, args[0]);
|
||||
|
@@ -2820,14 +2820,11 @@ void tcg_register_jit(void *buf, size_t buf_size)
|
||||
}
|
||||
#endif /* __ELF__ */
|
||||
|
||||
static size_t dcache_bsize = 16;
|
||||
static size_t icache_bsize = 16;
|
||||
|
||||
void flush_icache_range(uintptr_t start, uintptr_t stop)
|
||||
{
|
||||
uintptr_t p, start1, stop1;
|
||||
size_t dsize = dcache_bsize;
|
||||
size_t isize = icache_bsize;
|
||||
size_t dsize = qemu_dcache_linesize;
|
||||
size_t isize = qemu_icache_linesize;
|
||||
|
||||
start1 = start & ~(dsize - 1);
|
||||
stop1 = (stop + dsize - 1) & ~(dsize - 1);
|
||||
@@ -2844,67 +2841,3 @@ void flush_icache_range(uintptr_t start, uintptr_t stop)
|
||||
asm volatile ("sync" : : : "memory");
|
||||
asm volatile ("isync" : : : "memory");
|
||||
}
|
||||
|
||||
#if defined _AIX
|
||||
#include <sys/systemcfg.h>
|
||||
|
||||
static void __attribute__((constructor)) tcg_cache_init(void)
|
||||
{
|
||||
icache_bsize = _system_configuration.icache_line;
|
||||
dcache_bsize = _system_configuration.dcache_line;
|
||||
}
|
||||
|
||||
#elif defined __linux__
|
||||
static void __attribute__((constructor)) tcg_cache_init(void)
|
||||
{
|
||||
unsigned long dsize = qemu_getauxval(AT_DCACHEBSIZE);
|
||||
unsigned long isize = qemu_getauxval(AT_ICACHEBSIZE);
|
||||
|
||||
if (dsize == 0 || isize == 0) {
|
||||
if (dsize == 0) {
|
||||
fprintf(stderr, "getauxval AT_DCACHEBSIZE failed\n");
|
||||
}
|
||||
if (isize == 0) {
|
||||
fprintf(stderr, "getauxval AT_ICACHEBSIZE failed\n");
|
||||
}
|
||||
exit(1);
|
||||
}
|
||||
dcache_bsize = dsize;
|
||||
icache_bsize = isize;
|
||||
}
|
||||
|
||||
#elif defined __APPLE__
|
||||
#include <sys/sysctl.h>
|
||||
|
||||
static void __attribute__((constructor)) tcg_cache_init(void)
|
||||
{
|
||||
size_t len;
|
||||
unsigned cacheline;
|
||||
int name[2] = { CTL_HW, HW_CACHELINE };
|
||||
|
||||
len = sizeof(cacheline);
|
||||
if (sysctl(name, 2, &cacheline, &len, NULL, 0)) {
|
||||
perror("sysctl CTL_HW HW_CACHELINE failed");
|
||||
exit(1);
|
||||
}
|
||||
dcache_bsize = cacheline;
|
||||
icache_bsize = cacheline;
|
||||
}
|
||||
|
||||
#elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
|
||||
#include <sys/sysctl.h>
|
||||
|
||||
static void __attribute__((constructor)) tcg_cache_init(void)
|
||||
{
|
||||
size_t len = 4;
|
||||
unsigned cacheline;
|
||||
|
||||
if (sysctlbyname ("machdep.cacheline_size", &cacheline, &len, NULL, 0)) {
|
||||
fprintf(stderr, "sysctlbyname machdep.cacheline_size failed: %s\n",
|
||||
strerror(errno));
|
||||
exit(1);
|
||||
}
|
||||
dcache_bsize = cacheline;
|
||||
icache_bsize = cacheline;
|
||||
}
|
||||
#endif
|
||||
|
@@ -149,23 +149,23 @@ void *HELPER(lookup_tb_ptr)(CPUArchState *env, target_ulong addr)
|
||||
CPUState *cpu = ENV_GET_CPU(env);
|
||||
TranslationBlock *tb;
|
||||
target_ulong cs_base, pc;
|
||||
uint32_t flags;
|
||||
uint32_t flags, addr_hash;
|
||||
|
||||
tb = atomic_rcu_read(&cpu->tb_jmp_cache[tb_jmp_cache_hash_func(addr)]);
|
||||
if (likely(tb)) {
|
||||
cpu_get_tb_cpu_state(env, &pc, &cs_base, &flags);
|
||||
if (likely(tb->pc == addr && tb->cs_base == cs_base &&
|
||||
tb->flags == flags)) {
|
||||
goto found;
|
||||
}
|
||||
addr_hash = tb_jmp_cache_hash_func(addr);
|
||||
tb = atomic_rcu_read(&cpu->tb_jmp_cache[addr_hash]);
|
||||
cpu_get_tb_cpu_state(env, &pc, &cs_base, &flags);
|
||||
|
||||
if (unlikely(!(tb
|
||||
&& tb->pc == addr
|
||||
&& tb->cs_base == cs_base
|
||||
&& tb->flags == flags))) {
|
||||
tb = tb_htable_lookup(cpu, addr, cs_base, flags);
|
||||
if (likely(tb)) {
|
||||
atomic_set(&cpu->tb_jmp_cache[tb_jmp_cache_hash_func(addr)], tb);
|
||||
goto found;
|
||||
if (!tb) {
|
||||
return tcg_ctx.code_gen_epilogue;
|
||||
}
|
||||
atomic_set(&cpu->tb_jmp_cache[addr_hash], tb);
|
||||
}
|
||||
return tcg_ctx.code_gen_epilogue;
|
||||
found:
|
||||
|
||||
qemu_log_mask_and_addr(CPU_LOG_EXEC, addr,
|
||||
"Chain %p [%d: " TARGET_FMT_lx "] %s\n",
|
||||
tb->tc_ptr, cpu->cpu_index, addr,
|
||||
|
20
tcg/tcg.c
20
tcg/tcg.c
@@ -383,6 +383,26 @@ void tcg_context_init(TCGContext *s)
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Allocate TBs right before their corresponding translated code, making
|
||||
* sure that TBs and code are on different cache lines.
|
||||
*/
|
||||
TranslationBlock *tcg_tb_alloc(TCGContext *s)
|
||||
{
|
||||
uintptr_t align = qemu_icache_linesize;
|
||||
TranslationBlock *tb;
|
||||
void *next;
|
||||
|
||||
tb = (void *)ROUND_UP((uintptr_t)s->code_gen_ptr, align);
|
||||
next = (void *)ROUND_UP((uintptr_t)(tb + 1), align);
|
||||
|
||||
if (unlikely(next > s->code_gen_highwater)) {
|
||||
return NULL;
|
||||
}
|
||||
s->code_gen_ptr = next;
|
||||
return tb;
|
||||
}
|
||||
|
||||
void tcg_prologue_init(TCGContext *s)
|
||||
{
|
||||
size_t prologue_size, total_size;
|
||||
|
@@ -697,7 +697,6 @@ struct TCGContext {
|
||||
here, because there's too much arithmetic throughout that relies
|
||||
on addition and subtraction working on bytes. Rely on the GCC
|
||||
extension that allows arithmetic on void*. */
|
||||
int code_gen_max_blocks;
|
||||
void *code_gen_prologue;
|
||||
void *code_gen_epilogue;
|
||||
void *code_gen_buffer;
|
||||
@@ -756,6 +755,7 @@ static inline bool tcg_op_buf_full(void)
|
||||
/* tb_lock must be held for tcg_malloc_internal. */
|
||||
void *tcg_malloc_internal(TCGContext *s, int size);
|
||||
void tcg_pool_reset(TCGContext *s);
|
||||
TranslationBlock *tcg_tb_alloc(TCGContext *s);
|
||||
|
||||
void tb_lock(void);
|
||||
void tb_unlock(void);
|
||||
|
3
tests/.gitignore
vendored
3
tests/.gitignore
vendored
@@ -1,7 +1,6 @@
|
||||
atomic_add-bench
|
||||
check-qdict
|
||||
check-qfloat
|
||||
check-qint
|
||||
check-qnum
|
||||
check-qjson
|
||||
check-qlist
|
||||
check-qnull
|
||||
|
@@ -10,10 +10,8 @@ check-unit-y = tests/check-qdict$(EXESUF)
|
||||
gcov-files-check-qdict-y = qobject/qdict.c
|
||||
check-unit-y += tests/test-char$(EXESUF)
|
||||
gcov-files-check-qdict-y = chardev/char.c
|
||||
check-unit-y += tests/check-qfloat$(EXESUF)
|
||||
gcov-files-check-qfloat-y = qobject/qfloat.c
|
||||
check-unit-y += tests/check-qint$(EXESUF)
|
||||
gcov-files-check-qint-y = qobject/qint.c
|
||||
check-unit-y += tests/check-qnum$(EXESUF)
|
||||
gcov-files-check-qnum-y = qobject/qnum.c
|
||||
check-unit-y += tests/check-qstring$(EXESUF)
|
||||
gcov-files-check-qstring-y = qobject/qstring.c
|
||||
check-unit-y += tests/check-qlist$(EXESUF)
|
||||
@@ -508,8 +506,8 @@ GENERATED_FILES += tests/test-qapi-types.h tests/test-qapi-visit.h \
|
||||
tests/test-qmp-commands.h tests/test-qapi-event.h \
|
||||
tests/test-qmp-introspect.h
|
||||
|
||||
test-obj-y = tests/check-qint.o tests/check-qstring.o tests/check-qdict.o \
|
||||
tests/check-qlist.o tests/check-qfloat.o tests/check-qnull.o \
|
||||
test-obj-y = tests/check-qnum.o tests/check-qstring.o tests/check-qdict.o \
|
||||
tests/check-qlist.o tests/check-qnull.o \
|
||||
tests/check-qjson.o \
|
||||
tests/test-coroutine.o tests/test-string-output-visitor.o \
|
||||
tests/test-string-input-visitor.o tests/test-qobject-output-visitor.o \
|
||||
@@ -537,11 +535,10 @@ test-crypto-obj-y = $(crypto-obj-y) $(test-qom-obj-y)
|
||||
test-io-obj-y = $(io-obj-y) $(test-crypto-obj-y)
|
||||
test-block-obj-y = $(block-obj-y) $(test-io-obj-y) tests/iothread.o
|
||||
|
||||
tests/check-qint$(EXESUF): tests/check-qint.o $(test-util-obj-y)
|
||||
tests/check-qnum$(EXESUF): tests/check-qnum.o $(test-util-obj-y)
|
||||
tests/check-qstring$(EXESUF): tests/check-qstring.o $(test-util-obj-y)
|
||||
tests/check-qdict$(EXESUF): tests/check-qdict.o $(test-util-obj-y)
|
||||
tests/check-qlist$(EXESUF): tests/check-qlist.o $(test-util-obj-y)
|
||||
tests/check-qfloat$(EXESUF): tests/check-qfloat.o $(test-util-obj-y)
|
||||
tests/check-qnull$(EXESUF): tests/check-qnull.o $(test-util-obj-y)
|
||||
tests/check-qjson$(EXESUF): tests/check-qjson.o $(test-util-obj-y)
|
||||
tests/check-qom-interface$(EXESUF): tests/check-qom-interface.o $(test-qom-obj-y)
|
||||
|
@@ -11,7 +11,6 @@
|
||||
*/
|
||||
#include "qemu/osdep.h"
|
||||
|
||||
#include "qapi/qmp/qint.h"
|
||||
#include "qapi/qmp/qdict.h"
|
||||
#include "qapi/qmp/qstring.h"
|
||||
#include "qapi/error.h"
|
||||
@@ -33,13 +32,12 @@ static void qdict_new_test(void)
|
||||
g_assert(qdict->base.refcnt == 1);
|
||||
g_assert(qobject_type(QOBJECT(qdict)) == QTYPE_QDICT);
|
||||
|
||||
// destroy doesn't exit yet
|
||||
g_free(qdict);
|
||||
QDECREF(qdict);
|
||||
}
|
||||
|
||||
static void qdict_put_obj_test(void)
|
||||
{
|
||||
QInt *qi;
|
||||
QNum *qn;
|
||||
QDict *qdict;
|
||||
QDictEntry *ent;
|
||||
const int num = 42;
|
||||
@@ -51,14 +49,10 @@ static void qdict_put_obj_test(void)
|
||||
|
||||
g_assert(qdict_size(qdict) == 1);
|
||||
ent = QLIST_FIRST(&qdict->table[12345 % QDICT_BUCKET_MAX]);
|
||||
qi = qobject_to_qint(ent->value);
|
||||
g_assert(qint_get_int(qi) == num);
|
||||
qn = qobject_to_qnum(ent->value);
|
||||
g_assert_cmpint(qnum_get_int(qn), ==, num);
|
||||
|
||||
// destroy doesn't exit yet
|
||||
QDECREF(qi);
|
||||
g_free(ent->key);
|
||||
g_free(ent);
|
||||
g_free(qdict);
|
||||
QDECREF(qdict);
|
||||
}
|
||||
|
||||
static void qdict_destroy_simple_test(void)
|
||||
@@ -74,7 +68,7 @@ static void qdict_destroy_simple_test(void)
|
||||
|
||||
static void qdict_get_test(void)
|
||||
{
|
||||
QInt *qi;
|
||||
QNum *qn;
|
||||
QObject *obj;
|
||||
const int value = -42;
|
||||
const char *key = "test";
|
||||
@@ -85,8 +79,8 @@ static void qdict_get_test(void)
|
||||
obj = qdict_get(tests_dict, key);
|
||||
g_assert(obj != NULL);
|
||||
|
||||
qi = qobject_to_qint(obj);
|
||||
g_assert(qint_get_int(qi) == value);
|
||||
qn = qobject_to_qnum(obj);
|
||||
g_assert_cmpint(qnum_get_int(qn), ==, value);
|
||||
|
||||
QDECREF(tests_dict);
|
||||
}
|
||||
@@ -114,10 +108,17 @@ static void qdict_get_try_int_test(void)
|
||||
QDict *tests_dict = qdict_new();
|
||||
|
||||
qdict_put_int(tests_dict, key, value);
|
||||
qdict_put_str(tests_dict, "string", "test");
|
||||
|
||||
ret = qdict_get_try_int(tests_dict, key, 0);
|
||||
g_assert(ret == value);
|
||||
|
||||
ret = qdict_get_try_int(tests_dict, "missing", -42);
|
||||
g_assert_cmpuint(ret, ==, -42);
|
||||
|
||||
ret = qdict_get_try_int(tests_dict, "string", -42);
|
||||
g_assert_cmpuint(ret, ==, -42);
|
||||
|
||||
QDECREF(tests_dict);
|
||||
}
|
||||
|
||||
@@ -329,7 +330,7 @@ static void qdict_array_split_test(void)
|
||||
{
|
||||
QDict *test_dict = qdict_new();
|
||||
QDict *dict1, *dict2;
|
||||
QInt *int1;
|
||||
QNum *int1;
|
||||
QList *test_list;
|
||||
|
||||
/*
|
||||
@@ -380,7 +381,7 @@ static void qdict_array_split_test(void)
|
||||
|
||||
dict1 = qobject_to_qdict(qlist_pop(test_list));
|
||||
dict2 = qobject_to_qdict(qlist_pop(test_list));
|
||||
int1 = qobject_to_qint(qlist_pop(test_list));
|
||||
int1 = qobject_to_qnum(qlist_pop(test_list));
|
||||
|
||||
g_assert(dict1);
|
||||
g_assert(dict2);
|
||||
@@ -402,7 +403,7 @@ static void qdict_array_split_test(void)
|
||||
|
||||
QDECREF(dict2);
|
||||
|
||||
g_assert(qint_get_int(int1) == 66);
|
||||
g_assert_cmpint(qnum_get_int(int1), ==, 66);
|
||||
|
||||
QDECREF(int1);
|
||||
|
||||
@@ -447,14 +448,14 @@ static void qdict_array_split_test(void)
|
||||
|
||||
qdict_array_split(test_dict, &test_list);
|
||||
|
||||
int1 = qobject_to_qint(qlist_pop(test_list));
|
||||
int1 = qobject_to_qnum(qlist_pop(test_list));
|
||||
|
||||
g_assert(int1);
|
||||
g_assert(qlist_empty(test_list));
|
||||
|
||||
QDECREF(test_list);
|
||||
|
||||
g_assert(qint_get_int(int1) == 42);
|
||||
g_assert_cmpint(qnum_get_int(int1), ==, 42);
|
||||
|
||||
QDECREF(int1);
|
||||
|
||||
|
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user