static void vxhs_parse_filename(const char *filename, QDict *options, Error **errp) { if (qdict_haskey(options, "vdisk-id") || qdict_haskey(options, "server")) { error_setg(errp, "vdisk-id/server and a file name may not be specified " "at the same time"); return; } if (strstr(filename, "://")) { int ret = vxhs_parse_uri(filename, options); if (ret < 0) { error_setg(errp, "Invalid URI. URI should be of the form " " vxhs://<host_ip>:<port>/<vdisk-id>"); } } }
void do_info_migrate_print(Monitor *mon, const QObject *data) { QDict *qdict; qdict = qobject_to_qdict(data); monitor_printf(mon, "Migration status: %s\n", qdict_get_str(qdict, "status")); if (qdict_haskey(qdict, "ram")) { migrate_print_status(mon, "ram", qdict); } if (qdict_haskey(qdict, "disk")) { migrate_print_status(mon, "disk", qdict); } }
static void migrate_start_postcopy(QTestState *who) { QDict *rsp; rsp = wait_command(who, "{ 'execute': 'migrate-start-postcopy' }"); g_assert(qdict_haskey(rsp, "return")); qobject_unref(rsp); }
static void test_panic(void) { uint8_t val; QDict *response, *data; val = inb(0x505); g_assert_cmpuint(val, ==, 1); outb(0x505, 0x1); response = qmp_receive(); g_assert(qdict_haskey(response, "event")); g_assert_cmpstr(qdict_get_str(response, "event"), ==, "GUEST_PANICKED"); g_assert(qdict_haskey(response, "data")); data = qdict_get_qdict(response, "data"); g_assert(qdict_haskey(data, "action")); g_assert_cmpstr(qdict_get_str(data, "action"), ==, "pause"); }
static void read_blocktime(QTestState *who) { QDict *rsp, *rsp_return; rsp = wait_command(who, "{ 'execute': 'query-migrate' }"); rsp_return = qdict_get_qdict(rsp, "return"); g_assert(qdict_haskey(rsp_return, "postcopy-blocktime")); qobject_unref(rsp); }
/* 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 archipelago_parse_filename(const char *filename, QDict *options, Error **errp) { const char *start; char *volume = NULL, *segment_name = NULL; xport mport = NoPort, vport = NoPort; if (qdict_haskey(options, ARCHIPELAGO_OPT_VOLUME) || qdict_haskey(options, ARCHIPELAGO_OPT_SEGMENT) || qdict_haskey(options, ARCHIPELAGO_OPT_MPORT) || qdict_haskey(options, ARCHIPELAGO_OPT_VPORT)) { error_setg(errp, "volume/mport/vport/segment and a file name may not" " be specified at the same time"); return; } if (!strstart(filename, "archipelago:", &start)) { error_setg(errp, "File name must start with 'archipelago:'"); return; } if (!strlen(start) || strstart(start, "/", NULL)) { error_setg(errp, "volume name must be specified"); return; } parse_filename_opts(filename, errp, &volume, &segment_name, &mport, &vport); if (volume) { qdict_put(options, ARCHIPELAGO_OPT_VOLUME, qstring_from_str(volume)); g_free(volume); } if (segment_name) { qdict_put(options, ARCHIPELAGO_OPT_SEGMENT, qstring_from_str(segment_name)); g_free(segment_name); } if (mport != NoPort) { qdict_put(options, ARCHIPELAGO_OPT_MPORT, qint_from_int(mport)); } if (vport != NoPort) { qdict_put(options, ARCHIPELAGO_OPT_VPORT, qint_from_int(vport)); } }
static void qdict_haskey_test(void) { const char *key = "test"; QDict *tests_dict = qdict_new(); qdict_put(tests_dict, key, qint_from_int(0)); g_assert(qdict_haskey(tests_dict, key) == 1); QDECREF(tests_dict); }
static void test_qga_get_vcpus(gconstpointer fix) { const TestFixture *fixture = fix; QDict *ret; QList *list; const QListEntry *entry; ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-vcpus'}"); g_assert_nonnull(ret); qmp_assert_no_error(ret); /* check there is at least a cpu */ list = qdict_get_qlist(ret, "return"); entry = qlist_first(list); g_assert(qdict_haskey(qobject_to_qdict(entry->value), "online")); g_assert(qdict_haskey(qobject_to_qdict(entry->value), "logical-id")); QDECREF(ret); }
void do_instruction_trace(Monitor* monitor, const QDict* qdict) { if (target_cr3 != 0) { return; } DECAF_printf("do_instruction_trace\n"); if ((qdict != NULL) && (qdict_haskey(qdict, DICT_KEY_PROCNAME))) { strncpy(target_name, qdict_get_str(qdict, DICT_KEY_PROCNAME), TARGET_NAME_BUF_SIZE); target_name_len = strlen(target_name); } target_name[TARGET_NAME_BUF_SIZE - 1] = '\0'; }
static void test_qga_get_fsinfo(gconstpointer fix) { const TestFixture *fixture = fix; QDict *ret; QList *list; const QListEntry *entry; ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-fsinfo'}"); g_assert_nonnull(ret); qmp_assert_no_error(ret); /* check there is at least a fs */ list = qdict_get_qlist(ret, "return"); entry = qlist_first(list); g_assert(qdict_haskey(qobject_to_qdict(entry->value), "name")); g_assert(qdict_haskey(qobject_to_qdict(entry->value), "mountpoint")); g_assert(qdict_haskey(qobject_to_qdict(entry->value), "type")); g_assert(qdict_haskey(qobject_to_qdict(entry->value), "disk")); QDECREF(ret); }
void monitor_print_balloon(Monitor *mon, const QObject *data) { QDict *qdict; qdict = qobject_to_qdict(data); if (!qdict_haskey(qdict, "actual")) { return; } monitor_printf(mon, "balloon: actual=%" PRId64, qdict_get_int(qdict, "actual") >> 20); qdict_iter(qdict, print_balloon_stat, mon); monitor_printf(mon, "\n"); }
static void deprecated_set_speed(QTestState *who, const char *value) { QDict *rsp; gchar *cmd; cmd = g_strdup_printf("{ 'execute': 'migrate_set_speed'," "'arguments': { 'value': %s } }", value); rsp = qtest_qmp(who, cmd); g_free(cmd); g_assert(qdict_haskey(rsp, "return")); qobject_unref(rsp); migrate_check_parameter(who, "max-bandwidth", value); }
static void migrate(QTestState *who, const char *uri) { QDict *rsp; gchar *cmd; cmd = g_strdup_printf("{ 'execute': 'migrate'," "'arguments': { 'uri': '%s' } }", uri); rsp = qtest_qmp(who, cmd); g_free(cmd); g_assert(qdict_haskey(rsp, "return")); qobject_unref(rsp); }
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; }
/* test commands with no input and no return value */ static void test_dispatch_cmd(void) { QDict *req = qdict_new(); QDict *resp; 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 QList *device_type_list(bool abstract) { QDict *resp; QList *ret; resp = qmp("{'execute': 'qom-list-types'," " 'arguments': {'implements': 'device', 'abstract': %i}}", abstract); g_assert(qdict_haskey(resp, "return")); ret = qdict_get_qlist(resp, "return"); QINCREF(ret); QDECREF(resp); return ret; }
void qpci_unplug_acpi_device_test(QTestState *qts, const char *id, uint8_t slot) { QDict *response; response = qtest_qmp(qts, "{'execute': 'device_del'," " 'arguments': {'id': %s}}", id); g_assert(response); g_assert(!qdict_haskey(response, "error")); qobject_unref(response); qtest_outb(qts, ACPI_PCIHP_ADDR + PCI_EJ_BASE, 1 << slot); qtest_qmp_eventwait(qts, "DEVICE_DELETED"); }
void do_taint_sendkey(Monitor *mon, const QDict *qdict) { // Set the origin and offset for the callback if(qdict_haskey(qdict, "key") && qdict_haskey(qdict, "taint_origin") && qdict_haskey(qdict, "offset")) { //register keystroke callback taint_key_enabled=1; if (!keystroke_cb_handle) { keystroke_cb_handle = DECAF_register_callback(DECAF_KEYSTROKE_CB, tracing_send_keystroke, &taint_key_enabled); } taint_sendkey_origin = qdict_get_int(qdict, "taint_origin"); taint_sendkey_offset = qdict_get_int(qdict, "offset"); // Send the key do_send_key(qdict_get_str(qdict, "key")); } else monitor_printf(mon, "taint_sendkey command is malformed\n"); }
static void test_qga_get_fsinfo(gconstpointer fix) { const TestFixture *fixture = fix; QDict *ret; QList *list; const QListEntry *entry; ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-fsinfo'}"); g_assert_nonnull(ret); qmp_assert_no_error(ret); /* sanity-check the response if there are any filesystems */ list = qdict_get_qlist(ret, "return"); entry = qlist_first(list); if (entry) { g_assert(qdict_haskey(qobject_to(QDict, entry->value), "name")); g_assert(qdict_haskey(qobject_to(QDict, entry->value), "mountpoint")); g_assert(qdict_haskey(qobject_to(QDict, entry->value), "type")); g_assert(qdict_haskey(qobject_to(QDict, entry->value), "disk")); } qobject_unref(ret); }
/* 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); }
static QObject *do_qmp_dispatch(QObject *request, Error **errp) { Error *local_err = NULL; const char *command; QDict *args, *dict; QmpCommand *cmd; QObject *ret = NULL; dict = qmp_dispatch_check_obj(request, errp); if (!dict) { return NULL; } command = qdict_get_str(dict, "execute"); cmd = qmp_find_command(command); if (cmd == NULL) { error_set(errp, ERROR_CLASS_COMMAND_NOT_FOUND, "The command %s has not been found", command); return NULL; } if (!cmd->enabled) { error_setg(errp, "The command %s has been disabled for this instance", command); return NULL; } if (!qdict_haskey(dict, "arguments")) { args = qdict_new(); } else { args = qdict_get_qdict(dict, "arguments"); QINCREF(args); } switch (cmd->type) { case QCT_NORMAL: cmd->fn(args, &ret, &local_err); if (local_err) { error_propagate(errp, local_err); } else if (cmd->options & QCO_NO_SUCCESS_RESP) { g_assert(!ret); } else if (!ret) { ret = QOBJECT(qdict_new()); } break; } QDECREF(args); return ret; }
static void test_usb_uas_hotplug(void) { QDict *response; response = qmp("{'execute': 'device_add'," " 'arguments': {" " 'driver': 'usb-uas'," " 'id': 'uas'" "}}"); g_assert(response); g_assert(!qdict_haskey(response, "error")); QDECREF(response); response = qmp("{'execute': 'device_add'," " 'arguments': {" " 'driver': 'scsi-hd'," " 'drive': 'drive0'," " 'id': 'scsi-hd'" "}}"); g_assert(response); g_assert(!qdict_haskey(response, "error")); QDECREF(response); /* TODO: UAS HBA driver in libqos, to check that added disk is visible after BUS rescan */ response = qmp("{'execute': 'device_del'," " 'arguments': {" " 'id': 'scsi-hd'" "}}"); g_assert(response); g_assert(!qdict_haskey(response, "error")); QDECREF(response); response = qmp(""); g_assert(qdict_haskey(response, "event")); g_assert(!strcmp(qdict_get_str(response, "event"), "DEVICE_DELETED")); QDECREF(response); response = qmp("{'execute': 'device_del'," " 'arguments': {" " 'id': 'uas'" "}}"); g_assert(response); g_assert(!qdict_haskey(response, "error")); QDECREF(response); response = qmp(""); g_assert(response); g_assert(qdict_haskey(response, "event")); g_assert(!strcmp(qdict_get_str(response, "event"), "DEVICE_DELETED")); QDECREF(response); }
/* add a netfilter to a netdev and then remove the netdev */ static void remove_netdev_with_one_netfilter(void) { QDict *response; response = qmp("{'execute': 'object-add'," " 'arguments': {" " 'qom-type': 'filter-buffer'," " 'id': 'qtest-f0'," " 'props': {" " 'netdev': 'qtest-bn0'," " 'queue': 'rx'," " 'interval': 1000" "}}}"); g_assert(response); g_assert(!qdict_haskey(response, "error")); qobject_unref(response); response = qmp("{'execute': 'netdev_del'," " 'arguments': {" " 'id': 'qtest-bn0'" "}}"); g_assert(response); g_assert(!qdict_haskey(response, "error")); qobject_unref(response); /* add back the netdev */ response = qmp("{'execute': 'netdev_add'," " 'arguments': {" " 'type': 'user'," " 'id': 'qtest-bn0'" "}}"); g_assert(response); g_assert(!qdict_haskey(response, "error")); qobject_unref(response); }
static void migrate_set_parameter(QTestState *who, const char *parameter, const char *value) { QDict *rsp; gchar *cmd; cmd = g_strdup_printf("{ 'execute': 'migrate-set-parameters'," "'arguments': { '%s': %s } }", parameter, value); rsp = qtest_qmp(who, cmd); g_free(cmd); g_assert(qdict_haskey(rsp, "return")); qobject_unref(rsp); migrate_check_parameter(who, parameter, value); }
/* * Events can get in the way of responses we are actually waiting for. */ static QDict *return_or_event(QDict *response) { const char *event_string; if (!qdict_haskey(response, "event")) { return response; } /* OK, it was an event */ event_string = qdict_get_str(response, "event"); if (!strcmp(event_string, "STOP")) { got_stop = true; } QDECREF(response); return return_or_event(qtest_qmp_receive(global_qtest)); }
static void qdict_del_test(void) { const char *key = "key test"; QDict *tests_dict = qdict_new(); qdict_put(tests_dict, key, qstring_from_str("foo")); g_assert(qdict_size(tests_dict) == 1); qdict_del(tests_dict, key); g_assert(qdict_size(tests_dict) == 0); g_assert(qdict_haskey(tests_dict, key) == 0); QDECREF(tests_dict); }
/* 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 hmp_dump_guest_memory(Monitor *mon, const QDict *qdict) { Error *errp = NULL; int paging = qdict_get_try_bool(qdict, "paging", 0); const char *file = qdict_get_str(qdict, "filename"); bool has_begin = qdict_haskey(qdict, "begin"); bool has_length = qdict_haskey(qdict, "length"); int64_t begin = 0; int64_t length = 0; char *prot; if (has_begin) { begin = qdict_get_int(qdict, "begin"); } if (has_length) { length = qdict_get_int(qdict, "length"); } prot = g_strconcat("file:", file, NULL); qmp_dump_guest_memory(paging, prot, has_begin, begin, has_length, length, &errp); hmp_handle_error(mon, &errp); g_free(prot); }
static void test_qga_get_memory_block_info(gconstpointer fix) { const TestFixture *fixture = fix; QDict *ret, *val; int64_t size; ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-memory-block-info'}"); g_assert_nonnull(ret); /* some systems might not expose memory block info in sysfs */ if (!qdict_haskey(ret, "error")) { /* check there is at least some memory */ val = qdict_get_qdict(ret, "return"); size = qdict_get_int(val, "size"); g_assert_cmpint(size, >, 0); }