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 blkverify_refresh_filename(BlockDriverState *bs) { BDRVBlkverifyState *s = bs->opaque; /* bs->file has already been refreshed */ bdrv_refresh_filename(s->test_file); if (bs->file->full_open_options && s->test_file->full_open_options) { QDict *opts = qdict_new(); qdict_put_obj(opts, "driver", QOBJECT(qstring_from_str("blkverify"))); QINCREF(bs->file->full_open_options); qdict_put_obj(opts, "raw", QOBJECT(bs->file->full_open_options)); QINCREF(s->test_file->full_open_options); qdict_put_obj(opts, "test", QOBJECT(s->test_file->full_open_options)); bs->full_open_options = opts; } if (bs->file->exact_filename[0] && s->test_file->exact_filename[0]) { snprintf(bs->exact_filename, sizeof(bs->exact_filename), "blkverify:%s:%s", bs->file->exact_filename, s->test_file->exact_filename); } }
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; }
/* test generated deallocation on an object whose construction was prematurely * terminated due to an error */ static void test_dealloc_partial(void) { static const char text[] = "don't leak me"; UserDefTwo *ud2 = NULL; Error *err = NULL; /* create partial object */ { QDict *ud2_dict; Visitor *v; ud2_dict = qdict_new(); qdict_put_obj(ud2_dict, "string0", QOBJECT(qstring_from_str(text))); v = qobject_input_visitor_new(QOBJECT(ud2_dict)); visit_type_UserDefTwo(v, NULL, &ud2, &err); visit_free(v); QDECREF(ud2_dict); } /* verify that visit_type_XXX() cleans up properly on error */ error_free_or_abort(&err); assert(!ud2); /* Manually create a partial object, leaving ud2->dict1 at NULL */ ud2 = g_new0(UserDefTwo, 1); ud2->string0 = g_strdup(text); /* tear down partial object */ qapi_free_UserDefTwo(ud2); }
/* test generated deallocation on an object whose construction was prematurely * terminated due to an error */ static void test_dealloc_partial(void) { static const char text[] = "don't leak me"; UserDefTwo *ud2 = NULL; Error *err = NULL; /* create partial object */ { QDict *ud2_dict; QmpInputVisitor *qiv; ud2_dict = qdict_new(); qdict_put_obj(ud2_dict, "string0", QOBJECT(qstring_from_str(text))); qiv = qmp_input_visitor_new(QOBJECT(ud2_dict)); visit_type_UserDefTwo(qmp_input_get_visitor(qiv), &ud2, NULL, &err); qmp_input_visitor_cleanup(qiv); QDECREF(ud2_dict); } /* verify partial success */ assert(ud2 != NULL); assert(ud2->string0 != NULL); assert(strcmp(ud2->string0, text) == 0); assert(ud2->dict1 == NULL); /* confirm & release construction error */ assert(err != NULL); error_free(err); /* tear down partial object */ qapi_free_UserDefTwo(ud2); }
/* 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 qobject_is_equal_num_test(void) { QNum *u0, *i0, *d0, *dnan, *um42, *im42, *dm42; u0 = qnum_from_uint(0u); i0 = qnum_from_int(0); d0 = qnum_from_double(0.0); dnan = qnum_from_double(NAN); um42 = qnum_from_uint((uint64_t)-42); im42 = qnum_from_int(-42); dm42 = qnum_from_double(-42.0); /* Integers representing a mathematically equal number should * compare equal */ check_equal(u0, i0); /* Doubles, however, are always unequal to integers */ check_unequal(u0, d0); check_unequal(i0, d0); /* Do not assume any object is equal to itself -- note however * that NaN cannot occur in a JSON object anyway. */ g_assert(qobject_is_equal(QOBJECT(dnan), QOBJECT(dnan)) == false); /* No unsigned overflow */ check_unequal(um42, im42); check_unequal(um42, dm42); check_unequal(im42, dm42); free_all(u0, i0, d0, dnan, um42, im42, dm42); }
/* 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(); QDict *resp; qdict_put_str(req, "execute", "user_def_cmd2"); resp = qmp_dispatch(&qmp_commands, QOBJECT(req), false); assert(resp != NULL); assert(qdict_haskey(resp, "error")); qobject_unref(resp); qobject_unref(req); /* check that with extra arguments it throws an error */ req = qdict_new(); qdict_put_int(args, "a", 66); qdict_put(req, "arguments", args); qdict_put_str(req, "execute", "user_def_cmd"); resp = qmp_dispatch(&qmp_commands, QOBJECT(req), false); assert(resp != NULL); assert(qdict_haskey(resp, "error")); qobject_unref(resp); qobject_unref(req); }
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 qdict_destroy_simple_test(void) { QDict *qdict; qdict = qdict_new(); qdict_put_obj(qdict, "num", QOBJECT(qint_from_int(0))); qdict_put_obj(qdict, "str", QOBJECT(qstring_from_str("foo"))); QDECREF(qdict); }
/* 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 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 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); }
/* 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); }
/* 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); }
void do_info_cyclecount(Monitor *mon, QObject **ret_data) { QDict *qdict; QObject *obj; qdict = qdict_new(); obj = qobject_from_jsonf(" { 'instruction_class_idx' : 1 , " "'cycle_count': %" PRId64 " }" , total_data_proc_cycle_count); qdict_put_obj(qdict, "1", obj); obj = qobject_from_jsonf(" { 'instruction_class_idx' : 2 , " "'cycle_count': %" PRId64 " }" , total_branch_cycle_count); qdict_put_obj(qdict, "2", obj); obj = qobject_from_jsonf(" { 'instruction_class_idx' : 3 , " "'cycle_count': %" PRId64 " }" , total_multiply_cycle_count); qdict_put_obj(qdict, "3", obj); obj = qobject_from_jsonf(" { 'instruction_class_idx' : 4 , " "'cycle_count': %" PRId64 " }" , total_ldst_cycle_count); qdict_put_obj(qdict, "4", obj); obj = qobject_from_jsonf(" { 'instruction_class_idx' : 5 , " "'cycle_count': %" PRId64 " }" , total_misc_cycle_count); qdict_put_obj(qdict, "5", obj); *ret_data = QOBJECT(qdict); }
static int send_response(GAState *s, QDict *payload) { const char *buf; QString *payload_qstr, *response_qstr; GIOStatus status; g_assert(payload && s->channel); payload_qstr = qobject_to_json(QOBJECT(payload)); if (!payload_qstr) { return -EINVAL; } if (s->delimit_response) { s->delimit_response = false; response_qstr = qstring_new(); qstring_append_chr(response_qstr, QGA_SENTINEL_BYTE); qstring_append(response_qstr, qstring_get_str(payload_qstr)); qobject_unref(payload_qstr); } else { response_qstr = payload_qstr; } qstring_append_chr(response_qstr, '\n'); buf = qstring_get_str(response_qstr); status = ga_channel_write_all(s->channel, buf, strlen(buf)); qobject_unref(response_qstr); if (status != G_IO_STATUS_NORMAL) { return -EIO; } return 0; }
static void qjson_finalizefn(Object *obj) { QJSON *json = (QJSON *)object_dynamic_cast(obj, TYPE_QJSON); assert(json); qobject_decref(QOBJECT(json->str)); }
static int process_disas_info(QemuHttpConnection *conn) { TranslationBlock *tb; DisasBuffer disas_buf = { {0}, 0 }; QList *res = qlist_new(); tb = &tbs[0]; disassemble_to_buffer(tb, &disas_buf); qlist_append(res, qstring_from_str(disas_buf.buffer)); int st = 0; st = respond_with_json(conn, QOBJECT(res)); qobject_decref(QOBJECT(res)); return st; }
void do_info_migrate(Monitor *mon, QObject **ret_data) { QDict *qdict; MigrationState *s = current_migration; if (s) { switch (s->get_status(s)) { case MIG_STATE_ACTIVE: qdict = qdict_new(); qdict_put(qdict, "status", qstring_from_str("active")); migrate_put_status(qdict, "ram", ram_bytes_transferred(), ram_bytes_remaining(), ram_bytes_total()); if (blk_mig_active()) { migrate_put_status(qdict, "disk", blk_mig_bytes_transferred(), blk_mig_bytes_remaining(), blk_mig_bytes_total()); } *ret_data = QOBJECT(qdict); break; case MIG_STATE_COMPLETED: *ret_data = qobject_from_jsonf("{ 'status': 'completed' }"); break; case MIG_STATE_ERROR: *ret_data = qobject_from_jsonf("{ 'status': 'failed' }"); break; case MIG_STATE_CANCELLED: *ret_data = qobject_from_jsonf("{ 'status': 'cancelled' }"); break; } } }
static int process_irq_info(QemuHttpConnection *conn) { int i; int64_t count; QList *res = qlist_new(); for (i = 0; i < 16; ++i) { count = irq_count[i]; qlist_append(res, qint_from_int(count)); } int st = 0; st = respond_with_json(conn, QOBJECT(res)); qobject_decref(QOBJECT(res)); return st; }
static void qobject_to_qdict_test(void) { QDict *tests_dict = qdict_new(); g_assert(qobject_to_qdict(QOBJECT(tests_dict)) == tests_dict); QDECREF(tests_dict); }
int qmp_marshal_input_cpu(Monitor *mon, const QDict *qdict, QObject **ret) { Error *local_err = NULL; Error **errp = &local_err; QDict *args = (QDict *)qdict; QmpInputVisitor *mi; QapiDeallocVisitor *md; Visitor *v; int64_t index; mi = qmp_input_visitor_new(QOBJECT(args)); v = qmp_input_get_visitor(mi); visit_type_int(v, &index, "index", errp); qmp_input_visitor_cleanup(mi); if (error_is_set(errp)) { goto out; } qmp_cpu(index, errp); out: md = qapi_dealloc_visitor_new(); v = qapi_dealloc_get_visitor(md); visit_type_int(v, &index, "index", errp); qapi_dealloc_visitor_cleanup(md); if (local_err) { qerror_report_err(local_err); error_free(local_err); return -1; } return 0; }
static void qobject_is_equal_list_test(void) { QList *list_0, *list_1, *list_cloned; QList *list_reordered, *list_longer, *list_shorter; list_0 = qlist_new(); list_1 = qlist_new(); list_reordered = qlist_new(); list_longer = qlist_new(); list_shorter = qlist_new(); qlist_append_int(list_0, 1); qlist_append_int(list_0, 2); qlist_append_int(list_0, 3); qlist_append_int(list_1, 1); qlist_append_int(list_1, 2); qlist_append_int(list_1, 3); qlist_append_int(list_reordered, 1); qlist_append_int(list_reordered, 3); qlist_append_int(list_reordered, 2); qlist_append_int(list_longer, 1); qlist_append_int(list_longer, 2); qlist_append_int(list_longer, 3); qlist_append_null(list_longer); qlist_append_int(list_shorter, 1); qlist_append_int(list_shorter, 2); list_cloned = qlist_copy(list_0); check_equal(list_0, list_1, list_cloned); check_unequal(list_0, list_reordered, list_longer, list_shorter); /* With a NaN in it, the list should no longer compare equal to * itself */ qlist_append(list_0, qnum_from_double(NAN)); g_assert(qobject_is_equal(QOBJECT(list_0), QOBJECT(list_0)) == false); free_all(list_0, list_1, list_cloned, list_reordered, list_longer, list_shorter); }
/** * 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; }
static void qobject_to_qlist_test(void) { QList *qlist; qlist = qlist_new(); g_assert(qobject_to_qlist(QOBJECT(qlist)) == qlist); // destroy doesn't exist yet g_free(qlist); }
static void qlist_new_test(void) { QList *qlist; qlist = qlist_new(); g_assert(qlist != NULL); g_assert(qlist->base.refcnt == 1); g_assert(qobject_type(QOBJECT(qlist)) == QTYPE_QLIST); // destroy doesn't exist yet g_free(qlist); }
static void qdict_new_test(void) { QDict *qdict; qdict = qdict_new(); g_assert(qdict != NULL); g_assert(qdict_size(qdict) == 0); g_assert(qdict->base.refcnt == 1); g_assert(qobject_type(QOBJECT(qdict)) == QTYPE_QDICT); // destroy doesn't exit yet g_free(qdict); }
static QObject *test_qmp_dispatch(QDict *req) { QDict *resp; QObject *ret; resp = qmp_dispatch(&qmp_commands, QOBJECT(req), false); assert(resp && !qdict_haskey(resp, "error")); ret = qdict_get(resp, "return"); assert(ret); qobject_ref(ret); qobject_unref(resp); return ret; }