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); } }
/* 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); }
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); }
QDict *qmp_dispatch(QmpCommandList *cmds, QObject *request, bool allow_oob) { Error *err = NULL; QDict *dict = qobject_to(QDict, request); QObject *ret, *id = dict ? qdict_get(dict, "id") : NULL; QDict *rsp; ret = do_qmp_dispatch(cmds, request, allow_oob, &err); if (err) { rsp = qmp_error_response(err); } else if (ret) { rsp = qdict_new(); qdict_put_obj(rsp, "return", ret); } else { /* Can only happen for commands with QCO_NO_SUCCESS_RESP */ rsp = NULL; } if (rsp && id) { qdict_put_obj(rsp, "id", qobject_ref(id)); } return rsp; }
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); }
/* 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 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 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); }
/* Add @value to the current QObject being built. * If the stack is visiting a dictionary or list, @value is now owned * by that container. Otherwise, @value is now the root. */ static void qobject_output_add_obj(QObjectOutputVisitor *qov, const char *name, QObject *value) { QStackEntry *e = QSLIST_FIRST(&qov->stack); QObject *cur = e ? e->value : NULL; if (!cur) { /* Don't allow reuse of visitor on more than one root */ assert(!qov->root); qov->root = value; } else { switch (qobject_type(cur)) { case QTYPE_QDICT: assert(name); qdict_put_obj(qobject_to(QDict, cur), name, value); break; case QTYPE_QLIST: assert(!name); qlist_append_obj(qobject_to(QList, cur), value); break; default: g_assert_not_reached(); } } }
/* handle requests/control events coming in over the channel */ static void process_event(JSONMessageParser *parser, GQueue *tokens) { GAState *s = container_of(parser, GAState, parser); QDict *qdict; Error *err = NULL; int ret; g_assert(s && parser); g_debug("process_event: called"); qdict = qobject_to_qdict(json_parser_parse_err(tokens, NULL, &err)); if (err || !qdict) { QDECREF(qdict); qdict = qdict_new(); if (!err) { g_warning("failed to parse event: unknown error"); error_setg(&err, QERR_JSON_PARSING); } else { g_warning("failed to parse event: %s", error_get_pretty(err)); } qdict_put_obj(qdict, "error", qmp_build_error_object(err)); error_free(err); } /* 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_setg(&err, QERR_UNSUPPORTED); qdict_put_obj(qdict, "error", qmp_build_error_object(err)); error_free(err); } ret = send_response(s, QOBJECT(qdict)); if (ret < 0) { g_warning("error sending error response: %s", strerror(-ret)); } } QDECREF(qdict); }
static void migrate_put_status(QDict *qdict, const char *name, uint64_t trans, uint64_t rem, uint64_t total) { QObject *obj; obj = qobject_from_jsonf("{ 'transferred': %" PRId64 ", " "'remaining': %" PRId64 ", " "'total': %" PRId64 " }", trans, rem, total); qdict_put_obj(qdict, name, obj); }
void do_info_energy(Monitor *mon, QObject **ret_data) { QDict *qdict; QObject *obj; struct energy_counter s; uint64_t dynamic_energy, leakage_energy; calculate_active_energy(&s); calculate_sleep_energy(&s); dynamic_energy = s.data_proc_energy + s.branch_energy + s.multiply_energy + s.ldst_energy + s.misc_energy; leakage_energy = s.sleep_energy; qdict = qdict_new(); obj = qobject_from_jsonf(" { 'ENERGY_TYPE' : 'DYNAMIC' , " "'value': %" PRId64 " }" , dynamic_energy); qdict_put_obj(qdict, "1", obj); obj = qobject_from_jsonf(" { 'ENERGY_TYPE' : 'LEAKAGE' , " "'value': %" PRId64 " }" , leakage_energy); qdict_put_obj(qdict, "2", obj); *ret_data = QOBJECT(qdict); }
QObject *qmp_dispatch(QObject *request) { Error *err = NULL; QObject *ret; QDict *rsp; ret = do_qmp_dispatch(request, &err); rsp = qdict_new(); if (err) { qdict_put_obj(rsp, "error", error_get_qobject(err)); error_free(err); } else if (ret) { qdict_put_obj(rsp, "return", ret); } else { QDECREF(rsp); return NULL; } return QOBJECT(rsp); }
/* 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 involve both input parameters and return values */ static void test_dispatch_cmd_io(void) { QDict *req = qdict_new(); QDict *args = qdict_new(); QDict *args3 = qdict_new(); QDict *ud1a = qdict_new(); QDict *ud1b = qdict_new(); QDict *ret, *ret_dict, *ret_dict_dict, *ret_dict_dict_userdef; QDict *ret_dict_dict2, *ret_dict_dict2_userdef; QInt *ret3; 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"))); ret = qobject_to_qdict(test_qmp_dispatch(req)); assert(!strcmp(qdict_get_str(ret, "string0"), "blah1")); ret_dict = qdict_get_qdict(ret, "dict1"); assert(!strcmp(qdict_get_str(ret_dict, "string1"), "blah2")); ret_dict_dict = qdict_get_qdict(ret_dict, "dict2"); ret_dict_dict_userdef = qdict_get_qdict(ret_dict_dict, "userdef"); assert(qdict_get_int(ret_dict_dict_userdef, "integer") == 42); assert(!strcmp(qdict_get_str(ret_dict_dict_userdef, "string"), "hello")); assert(!strcmp(qdict_get_str(ret_dict_dict, "string"), "blah3")); ret_dict_dict2 = qdict_get_qdict(ret_dict, "dict3"); ret_dict_dict2_userdef = qdict_get_qdict(ret_dict_dict2, "userdef"); assert(qdict_get_int(ret_dict_dict2_userdef, "integer") == 422); assert(!strcmp(qdict_get_str(ret_dict_dict2_userdef, "string"), "hello2")); assert(!strcmp(qdict_get_str(ret_dict_dict2, "string"), "blah4")); QDECREF(ret); qdict_put(args3, "a", qint_from_int(66)); qdict_put(req, "arguments", args3); qdict_put(req, "execute", qstring_from_str("guest-get-time")); ret3 = qobject_to_qint(test_qmp_dispatch(req)); assert(qint_get_int(ret3) == 66); QDECREF(ret3); 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); }
static void qdict_put_obj_test(void) { QInt *qi; QDict *qdict; QDictEntry *ent; const int num = 42; qdict = qdict_new(); // key "" will have tdb hash 12345 qdict_put_obj(qdict, "", QOBJECT(qint_from_int(num))); 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); // destroy doesn't exit yet QDECREF(qi); g_free(ent->key); g_free(ent); g_free(qdict); }
static void qdict_flatten_test(void) { QList *list1 = qlist_new(); QList *list2 = qlist_new(); QDict *dict1 = qdict_new(); QDict *dict2 = qdict_new(); QDict *dict3 = qdict_new(); /* * Test the flattening of * * { * "e": [ * 42, * [ * 23, * 66, * { * "a": 0, * "b": 1 * } * ] * ], * "f": { * "c": 2, * "d": 3, * }, * "g": 4 * } * * to * * { * "e.0": 42, * "e.1.0": 23, * "e.1.1": 66, * "e.1.2.a": 0, * "e.1.2.b": 1, * "f.c": 2, * "f.d": 3, * "g": 4 * } */ qdict_put(dict1, "a", qint_from_int(0)); qdict_put(dict1, "b", qint_from_int(1)); qlist_append_obj(list1, QOBJECT(qint_from_int(23))); qlist_append_obj(list1, QOBJECT(qint_from_int(66))); qlist_append_obj(list1, QOBJECT(dict1)); qlist_append_obj(list2, QOBJECT(qint_from_int(42))); qlist_append_obj(list2, QOBJECT(list1)); qdict_put(dict2, "c", qint_from_int(2)); qdict_put(dict2, "d", qint_from_int(3)); qdict_put_obj(dict3, "e", QOBJECT(list2)); qdict_put_obj(dict3, "f", QOBJECT(dict2)); qdict_put(dict3, "g", qint_from_int(4)); qdict_flatten(dict3); g_assert(qdict_get_int(dict3, "e.0") == 42); g_assert(qdict_get_int(dict3, "e.1.0") == 23); g_assert(qdict_get_int(dict3, "e.1.1") == 66); g_assert(qdict_get_int(dict3, "e.1.2.a") == 0); g_assert(qdict_get_int(dict3, "e.1.2.b") == 1); g_assert(qdict_get_int(dict3, "f.c") == 2); g_assert(qdict_get_int(dict3, "f.d") == 3); g_assert(qdict_get_int(dict3, "g") == 4); g_assert(qdict_size(dict3) == 8); QDECREF(dict3); }