/* test commands that return an error due to invalid parameters */ static void test_dispatch_cmd_failure(void) { QDict *req = qdict_new(); QDict *args = qdict_new(); QObject *resp; qdict_put_obj(req, "execute", QOBJECT(qstring_from_str("user_def_cmd2"))); resp = qmp_dispatch(&qmp_commands, QOBJECT(req)); assert(resp != NULL); assert(qdict_haskey(qobject_to_qdict(resp), "error")); qobject_decref(resp); QDECREF(req); /* check that with extra arguments it throws an error */ req = qdict_new(); qdict_put(args, "a", qint_from_int(66)); qdict_put(req, "arguments", args); qdict_put_obj(req, "execute", QOBJECT(qstring_from_str("user_def_cmd"))); resp = qmp_dispatch(&qmp_commands, QOBJECT(req)); assert(resp != NULL); assert(qdict_haskey(qobject_to_qdict(resp), "error")); qobject_decref(resp); QDECREF(req); }
static void qnull_visit_test(void) { QObject *obj; Visitor *v; QNull *null; /* * Most tests of interactions between QObject and visitors are in * test-qmp-*-visitor; but these tests live here because they * depend on layering violations to check qnull_ refcnt. */ g_assert(qnull_.base.refcnt == 1); obj = QOBJECT(qnull()); v = qobject_input_visitor_new(obj); qobject_decref(obj); visit_type_null(v, NULL, &null, &error_abort); g_assert(obj == QOBJECT(&qnull_)); QDECREF(null); visit_free(v); null = NULL; v = qobject_output_visitor_new(&obj); visit_type_null(v, NULL, &null, &error_abort); visit_complete(v, &obj); g_assert(obj == QOBJECT(&qnull_)); QDECREF(null); qobject_decref(obj); visit_free(v); g_assert(qnull_.base.refcnt == 1); }
static void qnull_visit_test(void) { QObject *obj; QmpOutputVisitor *qov; QmpInputVisitor *qiv; /* * Most tests of interactions between QObject and visitors are in * test-qmp-*-visitor; but these tests live here because they * depend on layering violations to check qnull_ refcnt. */ g_assert(qnull_.refcnt == 1); obj = qnull(); qiv = qmp_input_visitor_new(obj, true); qobject_decref(obj); visit_type_null(qmp_input_get_visitor(qiv), NULL, &error_abort); qmp_input_visitor_cleanup(qiv); qov = qmp_output_visitor_new(); visit_type_null(qmp_output_get_visitor(qov), NULL, &error_abort); obj = qmp_output_get_qobject(qov); g_assert(obj == &qnull_); qobject_decref(obj); qmp_output_visitor_cleanup(qov); g_assert(qnull_.refcnt == 1); }
/* test commands that involve both input parameters and return values */ static void test_dispatch_cmd_io(void) { QDict *req = qdict_new(); QDict *args = qdict_new(); QDict *ud1a = qdict_new(); QDict *ud1b = qdict_new(); QObject *resp; qdict_put_obj(ud1a, "integer", QOBJECT(qint_from_int(42))); qdict_put_obj(ud1a, "string", QOBJECT(qstring_from_str("hello"))); qdict_put_obj(ud1b, "integer", QOBJECT(qint_from_int(422))); qdict_put_obj(ud1b, "string", QOBJECT(qstring_from_str("hello2"))); qdict_put_obj(args, "ud1a", QOBJECT(ud1a)); qdict_put_obj(args, "ud1b", QOBJECT(ud1b)); qdict_put_obj(req, "arguments", QOBJECT(args)); qdict_put_obj(req, "execute", QOBJECT(qstring_from_str("user_def_cmd2"))); /* TODO: put in full payload and check for errors */ resp = qmp_dispatch(QOBJECT(req)); assert(resp != NULL); assert(!qdict_haskey(qobject_to_qdict(resp), "error")); g_print("\nresp: %s\n", qstring_get_str(qobject_to_json_pretty(resp))); qobject_decref(resp); QDECREF(req); }
static void qapi_dealloc_type_anything(Visitor *v, QObject **obj, const char *name, Error **errp) { if (obj) { qobject_decref(*obj); } }
static int process_jit_info(QemuHttpConnection *conn) { int i; TranslationBlock *tb; QList *res = qlist_new(); for (i = 0; i < nb_tbs; i++) { tb = &tbs[i]; QList *item = qlist_new(); qlist_append(item, qint_from_int(tb->pc)); qlist_append(item, qint_from_int(tb->size)); qlist_append(item, qint_from_int(tb->flags)); qlist_append(item, qint_from_int(tb->page_addr[1] != -1 ? 1 : 0)); qlist_append(item, qint_from_int(tb->tb_next_offset[0])); qlist_append(item, qint_from_int(tb->tb_next_offset[1])); qlist_append(res, item); } int st = 0; st = respond_with_json(conn, QOBJECT(res)); qobject_decref(QOBJECT(res)); return st; }
void qapi_copy_SocketAddress(SocketAddress **p_dest, SocketAddress *src) { QmpOutputVisitor *qov; QmpInputVisitor *qiv; Visitor *ov, *iv; QObject *obj; *p_dest = NULL; qov = qmp_output_visitor_new(); ov = qmp_output_get_visitor(qov); visit_type_SocketAddress(ov, NULL, &src, &error_abort); obj = qmp_output_get_qobject(qov); qmp_output_visitor_cleanup(qov); if (!obj) { return; } qiv = qmp_input_visitor_new(obj); iv = qmp_input_get_visitor(qiv); visit_type_SocketAddress(iv, NULL, p_dest, &error_abort); qmp_input_visitor_cleanup(qiv); qobject_decref(obj); }
static void qjson_finalizefn(Object *obj) { QJSON *json = (QJSON *)object_dynamic_cast(obj, TYPE_QJSON); assert(json); qobject_decref(QOBJECT(json->str)); }
static InetSocketAddress *ssh_config(BDRVSSHState *s, QDict *options, Error **errp) { InetSocketAddress *inet = NULL; QDict *addr = NULL; QObject *crumpled_addr = NULL; Visitor *iv = NULL; Error *local_error = NULL; qdict_extract_subqdict(options, &addr, "server."); if (!qdict_size(addr)) { error_setg(errp, "SSH server address missing"); goto out; } crumpled_addr = qdict_crumple(addr, errp); if (!crumpled_addr) { goto out; } iv = qobject_input_visitor_new(crumpled_addr, true); visit_type_InetSocketAddress(iv, NULL, &inet, &local_error); if (local_error) { error_propagate(errp, local_error); goto out; } out: QDECREF(addr); qobject_decref(crumpled_addr); visit_free(iv); return inet; }
static void panicked_mon_event(const char *action) { QObject *data; data = qobject_from_jsonf("{ 'action': %s }", action); monitor_protocol_event(QEVENT_GUEST_PANICKED, data); qobject_decref(data); }
static void visitor_output_teardown(TestOutputVisitorData *data, const void *unused) { visit_free(data->ov); data->ov = NULL; qobject_decref(data->obj); data->obj = NULL; }
static int process_cpu_info(QemuHttpConnection *conn) { CPUState *env; QList *cpu_list; int i; cpu_list = qlist_new(); for (env = first_cpu; env != NULL; env = env->next_cpu) { QDict *cpu; QObject *obj; obj = qobject_from_jsonf("{ 'CPU': %d }", env->cpu_index); cpu = qobject_to_qdict(obj); qdict_put(cpu, "eip", qint_from_int(env->eip + env->segs[R_CS].base)); qdict_put(cpu, "eax", qint_from_int(EAX)); qdict_put(cpu, "ebx", qint_from_int(EBX)); qdict_put(cpu, "ecx", qint_from_int(ECX)); qdict_put(cpu, "edx", qint_from_int(EDX)); qdict_put(cpu, "esp", qint_from_int(ESP)); qdict_put(cpu, "ebp", qint_from_int(EBP)); qdict_put(cpu, "esi", qint_from_int(ESI)); qdict_put(cpu, "edi", qint_from_int(EDI)); qdict_put(cpu, "dt", qint_from_int(dev_time)); qdict_put(cpu, "qt", qint_from_int(qemu_time)); #ifdef CONFIG_PROFILER qdict_put(cpu, "tb_count", qint_from_int(tcg_ctx.tb_count)); qdict_put(cpu, "tb_count1", qint_from_int(tcg_ctx.tb_count1)); qdict_put(cpu, "op_count", qint_from_int(tcg_ctx.op_count)); qdict_put(cpu, "op_count_max", qint_from_int(tcg_ctx.op_count_max)); qdict_put(cpu, "temp_count", qint_from_int(tcg_ctx.temp_count)); qdict_put(cpu, "temp_count_max", qint_from_int(tcg_ctx.temp_count_max)); qdict_put(cpu, "del_op_count", qint_from_int(tcg_ctx.del_op_count)); qdict_put(cpu, "code_in_len", qint_from_int(tcg_ctx.code_in_len)); qdict_put(cpu, "code_out_len", qint_from_int(tcg_ctx.code_out_len)); qdict_put(cpu, "interm_time", qint_from_int(tcg_ctx.interm_time)); qdict_put(cpu, "code_time", qint_from_int(tcg_ctx.code_time)); qdict_put(cpu, "la_time", qint_from_int(tcg_ctx.la_time)); qdict_put(cpu, "restore_count", qint_from_int(tcg_ctx.restore_count)); qdict_put(cpu, "restore_time", qint_from_int(tcg_ctx.restore_time)); for (i = INDEX_op_end; i < NB_OPS; i++) { qdict_put(cpu, tcg_op_defs[i].name, qint_from_int(tcg_table_op_count[i])); } #endif qlist_append(cpu_list, cpu); } int st = 0; st = respond_with_json(conn, QOBJECT(cpu_list)); qobject_decref(QOBJECT(cpu_list)); return st; }
static void qentry_destroy(QDictEntry *e) { assert(e != NULL); assert(e->key != NULL); assert(e->value != NULL); qobject_decref(e->value); qemu_free(e->key); qemu_free(e); }
static void do_free_all(int _, ...) { va_list ap; QObject *obj; va_start(ap, _); while ((obj = va_arg(ap, QObject *)) != NULL) { qobject_decref(obj); } va_end(ap); }
static void validate_teardown(TestInputVisitorData *data, const void *unused) { qobject_decref(data->obj); data->obj = NULL; if (data->qiv) { visit_free(data->qiv); data->qiv = NULL; } }
static void visitor_input_teardown(TestInputVisitorData *data, const void *unused) { qobject_decref(data->obj); data->obj = NULL; if (data->qiv) { qmp_input_visitor_cleanup(data->qiv); data->qiv = NULL; } }
static int process_memory_info(QemuHttpConnection *conn) { int l1, l2; int st; uint32_t pgd, pde, pte; int buf_size; char buf[128]; CPUState *env = first_cpu; QList *res = qlist_new(); if (!(env->cr[0] & CR0_PG_MASK)) goto out; if (env->cr[4] & CR4_PAE_MASK) goto out; pgd = env->cr[3] & ~0xfff; for (l1 = 0; l1 < 1024; ++l1) { cpu_physical_memory_read(pgd + l1 * 4, &pde, 4); pde = le32_to_cpu(pde); if (pde & PG_PRESENT_MASK) { /* 4kb pages */ if (!(pde & PG_PSE_MASK) || !(env->cr[4] & CR4_PSE_MASK)) { for (l2 = 0; l2 < 1024; ++l2) { cpu_physical_memory_read((pde & ~0xfff) + l2 * 4, &pte, 4); pte = le32_to_cpu(pte); if (pte & PG_PRESENT_MASK) { buf_size = snprintf(buf, sizeof(buf), "%02X (%02X) (%c%c%c%c%c%c%c%c%c)", (l1 << 22) + (l2 << 12), (pde & ~0xfff) + l2 * 4, pte & PG_NX_MASK ? 'X' : '-', pte & PG_GLOBAL_MASK ? 'G' : '-', pte & PG_PSE_MASK ? 'P' : '-', pte & PG_DIRTY_MASK ? 'D' : '-', pte & PG_ACCESSED_MASK ? 'A' : '-', pte & PG_PCD_MASK ? 'C' : '-', pte & PG_PWT_MASK ? 'T' : '-', pte & PG_USER_MASK ? 'U' : '-', pte & PG_RW_MASK ? 'W' : '-'); buf[buf_size] = 0; qlist_append(res, qstring_from_str(buf)); } } } } } out: st = respond_with_json(conn, QOBJECT(res)); qobject_decref(QOBJECT(res)); return st; }
static void complete_stats_request(VirtIOBalloon *vb) { QObject *stats; if (!vb->stats_opaque_callback_data) return; stats = get_stats_qobject(vb); vb->stats_callback(vb->stats_opaque_callback_data, stats); qobject_decref(stats); vb->stats_opaque_callback_data = NULL; vb->stats_callback = NULL; }
static void qnull_ref_test(void) { QObject *obj; g_assert(qnull_.base.refcnt == 1); obj = QOBJECT(qnull()); g_assert(obj); g_assert(obj == QOBJECT(&qnull_)); g_assert(qnull_.base.refcnt == 2); g_assert(qobject_type(obj) == QTYPE_QNULL); qobject_decref(obj); g_assert(qnull_.base.refcnt == 1); }
static void test_visitor_in_any(TestInputVisitorData *data, const void *unused) { QObject *res = NULL; Visitor *v; QInt *qint; QBool *qbool; QString *qstring; QDict *qdict; QObject *qobj; v = visitor_input_test_init(data, "-42"); visit_type_any(v, &res, NULL, &error_abort); qint = qobject_to_qint(res); g_assert(qint); g_assert_cmpint(qint_get_int(qint), ==, -42); qobject_decref(res); v = visitor_input_test_init(data, "{ 'integer': -42, 'boolean': true, 'string': 'foo' }"); visit_type_any(v, &res, NULL, &error_abort); qdict = qobject_to_qdict(res); g_assert(qdict && qdict_size(qdict) == 3); qobj = qdict_get(qdict, "integer"); g_assert(qobj); qint = qobject_to_qint(qobj); g_assert(qint); g_assert_cmpint(qint_get_int(qint), ==, -42); qobj = qdict_get(qdict, "boolean"); g_assert(qobj); qbool = qobject_to_qbool(qobj); g_assert(qbool); g_assert(qbool_get_bool(qbool) == true); qobj = qdict_get(qdict, "string"); g_assert(qobj); qstring = qobject_to_qstring(qobj); g_assert(qstring); g_assert_cmpstr(qstring_get_str(qstring), ==, "foo"); qobject_decref(res); }
static void qobject_output_free(Visitor *v) { QObjectOutputVisitor *qov = to_qov(v); QStackEntry *e; while (!QSLIST_EMPTY(&qov->stack)) { e = QSLIST_FIRST(&qov->stack); QSLIST_REMOVE_HEAD(&qov->stack, node); g_free(e); } qobject_decref(qov->root); g_free(qov); }
/* test commands with no input and no return value */ static void test_dispatch_cmd(void) { QDict *req = qdict_new(); QObject *resp; qdict_put_obj(req, "execute", QOBJECT(qstring_from_str("user_def_cmd"))); resp = qmp_dispatch(&qmp_commands, QOBJECT(req)); assert(resp != NULL); assert(!qdict_haskey(qobject_to_qdict(resp), "error")); qobject_decref(resp); QDECREF(req); }
/* handle requests/control events coming in over the channel */ static void process_event(JSONMessageParser *parser, QList *tokens) { GAState *s = container_of(parser, GAState, parser); QObject *obj; QDict *qdict; Error *err = NULL; int ret; g_assert(s && parser); g_debug("process_event: called"); obj = json_parser_parse_err(tokens, NULL, &err); if (err || !obj || qobject_type(obj) != QTYPE_QDICT) { qobject_decref(obj); qdict = qdict_new(); if (!err) { g_warning("failed to parse event: unknown error"); error_set(&err, QERR_JSON_PARSING); } else { g_warning("failed to parse event: %s", error_get_pretty(err)); } qdict_put_obj(qdict, "error", error_get_qobject(err)); error_free(err); } else { qdict = qobject_to_qdict(obj); } g_assert(qdict); /* handle host->guest commands */ if (qdict_haskey(qdict, "execute")) { process_command(s, qdict); } else { if (!qdict_haskey(qdict, "error")) { QDECREF(qdict); qdict = qdict_new(); g_warning("unrecognized payload format"); error_set(&err, QERR_UNSUPPORTED); qdict_put_obj(qdict, "error", error_get_qobject(err)); error_free(err); } ret = conn_channel_send_payload(s->conn_channel, QOBJECT(qdict)); if (ret) { g_warning("error sending payload: %s", strerror(ret)); } } QDECREF(qdict); }
/* test enum values nested in schema-defined structs */ static void test_nested_enums(void) { QmpOutputVisitor *mo; QmpInputVisitor *mi; Visitor *v; NestedEnumsOne *nested_enums, *nested_enums_cpy = NULL; Error *err = NULL; QObject *obj; QString *str; nested_enums = qemu_mallocz(sizeof(NestedEnumsOne)); nested_enums->enum1 = ENUM_ONE_VALUE1; nested_enums->enum2 = ENUM_ONE_VALUE2; nested_enums->enum3 = ENUM_ONE_VALUE3; nested_enums->enum4 = ENUM_ONE_VALUE3; nested_enums->has_enum2 = false; nested_enums->has_enum4 = true; /* C type -> QObject */ mo = qmp_output_visitor_new(); v = qmp_output_get_visitor(mo); visit_type_NestedEnumsOne(v, &nested_enums, NULL, &err); if (err) { g_error("%s", error_get_pretty(err)); } obj = qmp_output_get_qobject(mo); g_assert(obj); str = qobject_to_json_pretty(obj); g_print("%s\n", qstring_get_str(str)); QDECREF(str); /* QObject -> C type */ mi = qmp_input_visitor_new(obj); v = qmp_input_get_visitor(mi); visit_type_NestedEnumsOne(v, &nested_enums_cpy, NULL, &err); if (err) { g_error("%s", error_get_pretty(err)); } g_assert(nested_enums_cpy); g_assert(nested_enums_cpy->enum1 == nested_enums->enum1); g_assert(nested_enums_cpy->enum3 == nested_enums->enum3); g_assert(nested_enums_cpy->enum4 == nested_enums->enum4); g_assert(nested_enums_cpy->has_enum2 == false); g_assert(nested_enums_cpy->has_enum4 == true); qobject_decref(obj); qapi_free_NestedEnumsOne(nested_enums); qapi_free_NestedEnumsOne(nested_enums_cpy); }
static void test_visitor_out_string(TestOutputVisitorData *data, const void *unused) { char *string = (char *) "Q E M U"; QObject *obj; visit_type_str(data->ov, &string, NULL, &error_abort); obj = qmp_output_get_qobject(data->qov); g_assert(obj != NULL); g_assert(qobject_type(obj) == QTYPE_QSTRING); g_assert_cmpstr(qstring_get_str(qobject_to_qstring(obj)), ==, string); qobject_decref(obj); }
static void test_visitor_out_number(TestOutputVisitorData *data, const void *unused) { double value = 3.14; QObject *obj; visit_type_number(data->ov, &value, NULL, &error_abort); obj = qmp_output_get_qobject(data->qov); g_assert(obj != NULL); g_assert(qobject_type(obj) == QTYPE_QFLOAT); g_assert(qfloat_get_double(qobject_to_qfloat(obj)) == value); qobject_decref(obj); }
static void test_visitor_out_bool(TestOutputVisitorData *data, const void *unused) { bool value = true; QObject *obj; visit_type_bool(data->ov, &value, NULL, &error_abort); obj = qmp_output_get_qobject(data->qov); g_assert(obj != NULL); g_assert(qobject_type(obj) == QTYPE_QBOOL); g_assert(qbool_get_bool(qobject_to_qbool(obj)) == value); qobject_decref(obj); }
static void test_visitor_out_int(TestOutputVisitorData *data, const void *unused) { int64_t value = -42; QObject *obj; visit_type_int(data->ov, &value, NULL, &error_abort); obj = qmp_output_get_qobject(data->qov); g_assert(obj != NULL); g_assert(qobject_type(obj) == QTYPE_QINT); g_assert_cmpint(qint_get_int(qobject_to_qint(obj)), ==, value); qobject_decref(obj); }
/* test commands that return an error due to invalid parameters */ static void test_dispatch_cmd_error(void) { QDict *req = qdict_new(); QObject *resp; qdict_put_obj(req, "execute", QOBJECT(qstring_from_str("user_def_cmd2"))); resp = qmp_dispatch(QOBJECT(req)); assert(resp != NULL); assert(qdict_haskey(qobject_to_qdict(resp), "error")); g_print("\nresp: %s\n", qstring_get_str(qobject_to_json_pretty(resp))); qobject_decref(resp); QDECREF(req); }
static void process_command(GAState *s, QDict *req) { QObject *rsp = NULL; int ret; g_assert(req); g_debug("processing command"); rsp = qmp_dispatch(&ga_commands, QOBJECT(req)); if (rsp) { ret = send_response(s, rsp); if (ret < 0) { g_warning("error sending response: %s", strerror(-ret)); } qobject_decref(rsp); } }