int qmp_marshal_input_query_version(Monitor *mon, const QDict *qdict, QObject **ret) { Error *local_err = NULL; Error **errp = &local_err; QDict *args = (QDict *)qdict; VersionInfo * retval = NULL; (void)args; if (error_is_set(errp)) { goto out; } retval = qmp_query_version(errp); if (!error_is_set(errp)) { qmp_marshal_output_query_version(retval, ret, errp); } out: if (local_err) { qerror_report_err(local_err); error_free(local_err); return -1; } return 0; }
void visit_start_struct(Visitor *v, void **obj, const char *kind, const char *name, size_t size, Error **errp) { if (!error_is_set(errp)) { v->start_struct(v, obj, kind, name, size, errp); } }
static void hmp_handle_error(Monitor *mon, Error **errp) { if (error_is_set(errp)) { monitor_printf(mon, "%s\n", error_get_pretty(*errp)); error_free(*errp); } }
void visit_start_handle(Visitor *v, void **obj, const char *kind, const char *name, Error **errp) { if (!error_is_set(errp) && v->start_handle) { v->start_handle(v, obj, kind, name, errp); } }
void visit_start_optional(Visitor *v, bool *present, const char *name, Error **errp) { if (!error_is_set(errp) && v->start_optional) { v->start_optional(v, present, name, errp); } }
void qmp_guest_shutdown(bool has_mode, const char *mode, Error **err) { UINT shutdown_flag = EWX_FORCE; slog("guest-shutdown called, mode: %s", mode); if (!has_mode || strcmp(mode, "powerdown") == 0) { shutdown_flag |= EWX_POWEROFF; } else if (strcmp(mode, "halt") == 0) { shutdown_flag |= EWX_SHUTDOWN; } else if (strcmp(mode, "reboot") == 0) { shutdown_flag |= EWX_REBOOT; } else { error_set(err, QERR_INVALID_PARAMETER_VALUE, "mode", "halt|powerdown|reboot"); return; } /* Request a shutdown privilege, but try to shut down the system anyway. */ acquire_privilege(SE_SHUTDOWN_NAME, err); if (error_is_set(err)) { return; } if (!ExitWindowsEx(shutdown_flag, SHTDN_REASON_FLAG_PLANNED)) { slog("guest-shutdown failed: %d", GetLastError()); error_set(err, QERR_UNDEFINED_ERROR); } }
void *block_job_create(const BlockJobType *job_type, BlockDriverState *bs, int64_t speed, BlockDriverCompletionFunc *cb, void *opaque, Error **errp) { BlockJob *job; if (bs->job || bdrv_in_use(bs)) { error_set(errp, QERR_DEVICE_IN_USE, bdrv_get_device_name(bs)); return NULL; } bdrv_set_in_use(bs, 1); job = g_malloc0(job_type->instance_size); job->job_type = job_type; job->bs = bs; job->cb = cb; job->opaque = opaque; job->busy = true; bs->job = job; /* Only set speed when necessary to avoid NotSupported error */ if (speed != 0) { Error *local_err = NULL; block_job_set_speed(job, speed, &local_err); if (error_is_set(&local_err)) { bs->job = NULL; g_free(job); bdrv_set_in_use(bs, 0); error_propagate(errp, local_err); return NULL; } } return job; }
static int pci_device_hot_remove(Monitor *mon, const char *pci_addr) { PCIBus *root = pci_find_primary_bus(); PCIDevice *d; int bus; unsigned slot; Error *local_err = NULL; if (!root) { monitor_printf(mon, "no primary PCI bus (if there are multiple" " PCI roots, you must use device_del instead)"); return -1; } if (pci_read_devaddr(mon, pci_addr, &bus, &slot)) { return -1; } d = pci_find_device(root, bus, PCI_DEVFN(slot, 0)); if (!d) { monitor_printf(mon, "slot %d empty\n", slot); return -1; } qdev_unplug(&d->qdev, &local_err); if (error_is_set(&local_err)) { monitor_printf(mon, "%s\n", error_get_pretty(local_err)); error_free(local_err); return -1; } return 0; }
static int pci_device_hot_remove(Monitor *mon, const char *pci_addr) { PCIDevice *d; int dom, bus; unsigned slot; Error *local_err = NULL; if (pci_read_devaddr(mon, pci_addr, &dom, &bus, &slot)) { return -1; } d = pci_find_device(pci_find_root_bus(dom), bus, PCI_DEVFN(slot, 0)); if (!d) { monitor_printf(mon, "slot %d empty\n", slot); return -1; } qdev_unplug(&d->qdev, &local_err); if (error_is_set(&local_err)) { monitor_printf(mon, "%s\n", error_get_pretty(local_err)); error_free(local_err); return -1; } return 0; }
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 qmp_input_type_enum(Visitor *v, int *obj, const char *strings[], const char *kind, const char *name, Error **errp) { int64_t value = 0; char *enum_str; assert(strings); qmp_input_type_str(v, &enum_str, name, errp); if (error_is_set(errp)) { return; } while (strings[value] != NULL) { if (strcmp(strings[value], enum_str) == 0) { break; } value++; } if (strings[value] == NULL) { error_set(errp, QERR_INVALID_PARAMETER, name ? name : "null"); return; } *obj = value; }
void visit_type_enum(Visitor *v, int *obj, const char *strings[], const char *kind, const char *name, Error **errp) { if (!error_is_set(errp)) { v->type_enum(v, obj, strings, kind, name, errp); } }
static int raw_open_common(BlockDriverState *bs, QDict *options, int bdrv_flags, int open_flags) { BDRVRawState *s = bs->opaque; QemuOpts *opts; Error *local_err = NULL; const char *filename; int fd, ret; opts = qemu_opts_create_nofail(&raw_runtime_opts); qemu_opts_absorb_qdict(opts, options, &local_err); if (error_is_set(&local_err)) { qerror_report_err(local_err); error_free(local_err); ret = -EINVAL; goto fail; } filename = qemu_opt_get(opts, "filename"); ret = raw_normalize_devicepath(&filename); if (ret != 0) { goto fail; } s->open_flags = open_flags; raw_parse_flags(bdrv_flags, &s->open_flags); s->fd = -1; fd = qemu_open(filename, s->open_flags, 0644); if (fd < 0) { ret = -errno; if (ret == -EROFS) { ret = -EACCES; } goto fail; } s->fd = fd; #ifdef CONFIG_LINUX_AIO if (raw_set_aio(&s->aio_ctx, &s->use_aio, bdrv_flags)) { qemu_close(fd); ret = -errno; goto fail; } #endif s->has_discard = 1; #ifdef CONFIG_XFS if (platform_test_xfs_fd(s->fd)) { s->is_xfs = 1; } #endif ret = 0; fail: qemu_opts_del(opts); return ret; }
void commit_active_start(BlockDriverState *bs, BlockDriverState *base, int64_t speed, BlockdevOnError on_error, BlockDriverCompletionFunc *cb, void *opaque, Error **errp) { int64_t length, base_length; int orig_base_flags; int ret; Error *local_err = NULL; orig_base_flags = bdrv_get_flags(base); if (bdrv_reopen(base, bs->open_flags, errp)) { return; } length = bdrv_getlength(bs); if (length < 0) { error_setg_errno(errp, -length, "Unable to determine length of %s", bs->filename); goto error_restore_flags; } base_length = bdrv_getlength(base); if (base_length < 0) { error_setg_errno(errp, -base_length, "Unable to determine length of %s", base->filename); goto error_restore_flags; } if (length > base_length) { ret = bdrv_truncate(base, length); if (ret < 0) { error_setg_errno(errp, -ret, "Top image %s is larger than base image %s, and " "resize of base image failed", bs->filename, base->filename); goto error_restore_flags; } } bdrv_ref(base); mirror_start_job(bs, base, speed, 0, 0, on_error, on_error, cb, opaque, &local_err, &commit_active_job_driver, false, base); if (error_is_set(&local_err)) { error_propagate(errp, local_err); goto error_restore_flags; } return; error_restore_flags: /* ignore error and errp for bdrv_reopen, because we want to propagate * the original error */ bdrv_reopen(base, orig_base_flags, NULL); return; }
GenericList *visit_next_list(Visitor *v, GenericList **list, Error **errp) { if (!error_is_set(errp)) { return v->next_list(v, list, errp); } return 0; }
static QObject *do_qmp_dispatch(QObject *request, Error **errp) { const char *command; QDict *args, *dict; QmpCommand *cmd; QObject *ret = NULL; dict = qmp_dispatch_check_obj(request, errp); if (!dict || error_is_set(errp)) { return NULL; } command = qdict_get_str(dict, "execute"); cmd = qmp_find_command(command); if (cmd == NULL) { error_set(errp, QERR_COMMAND_NOT_FOUND, command); return NULL; } if (!cmd->enabled) { error_set(errp, QERR_COMMAND_DISABLED, 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, errp); if (!error_is_set(errp) && ret == NULL) { ret = QOBJECT(qdict_new()); } break; } QDECREF(args); return ret; }
void visit_type_int64(Visitor *v, int64_t *obj, const char *name, Error **errp) { if (!error_is_set(errp)) { if (v->type_int64) { v->type_int64(v, obj, name, errp); } else { v->type_int(v, obj, name, errp); } } }
void qmp_guest_shutdown(bool has_mode, const char *mode, Error **err) { const char *shutdown_flag; Error *local_err = NULL; pid_t pid; int status; slog("guest-shutdown called, mode: %s", mode); if (!has_mode || strcmp(mode, "powerdown") == 0) { shutdown_flag = "-P"; } else if (strcmp(mode, "halt") == 0) { shutdown_flag = "-H"; } else if (strcmp(mode, "reboot") == 0) { shutdown_flag = "-r"; } else { error_setg(err, "mode is invalid (valid values are: halt|powerdown|reboot"); return; } pid = fork(); if (pid == 0) { /* child, start the shutdown */ setsid(); reopen_fd_to_null(0); reopen_fd_to_null(1); reopen_fd_to_null(2); execle("/sbin/shutdown", "shutdown", shutdown_flag, "+0", "hypervisor initiated shutdown", (char*)NULL, environ); _exit(EXIT_FAILURE); } else if (pid < 0) { error_setg_errno(err, errno, "failed to create child process"); return; } ga_wait_child(pid, &status, &local_err); if (error_is_set(&local_err)) { error_propagate(err, local_err); return; } if (!WIFEXITED(status)) { error_setg(err, "child process has terminated abnormally"); return; } if (WEXITSTATUS(status)) { error_setg(err, "child process has failed to shutdown"); return; } /* succeded */ }
void qmp_guest_set_time(int64_t time_ns, Error **errp) { int ret; int status; pid_t pid; Error *local_err = NULL; struct timeval tv; /* year-2038 will overflow in case time_t is 32bit */ if (time_ns / 1000000000 != (time_t)(time_ns / 1000000000)) { error_setg(errp, "Time %" PRId64 " is too large", time_ns); return; } tv.tv_sec = time_ns / 1000000000; tv.tv_usec = (time_ns % 1000000000) / 1000; ret = settimeofday(&tv, NULL); if (ret < 0) { error_setg_errno(errp, errno, "Failed to set time to guest"); return; } /* Set the Hardware Clock to the current System Time. */ pid = fork(); if (pid == 0) { setsid(); reopen_fd_to_null(0); reopen_fd_to_null(1); reopen_fd_to_null(2); execle("/sbin/hwclock", "hwclock", "-w", NULL, environ); _exit(EXIT_FAILURE); } else if (pid < 0) { error_setg_errno(errp, errno, "failed to create child process"); return; } ga_wait_child(pid, &status, &local_err); if (error_is_set(&local_err)) { error_propagate(errp, local_err); return; } if (!WIFEXITED(status)) { error_setg(errp, "child process has terminated abnormally"); return; } if (WEXITSTATUS(status)) { error_setg(errp, "hwclock failed to set hardware clock to system time"); return; } }
static int raw_create(const char *filename, QEMUOptionParameter *options, Error **errp) { Error *local_err = NULL; int ret; ret = bdrv_create_file(filename, options, &local_err); if (error_is_set(&local_err)) { error_propagate(errp, local_err); } return ret; }
QemuOptsList *qemu_find_opts(const char *group) { QemuOptsList *ret; Error *local_err = NULL; ret = find_list(vm_config_groups, group, &local_err); if (error_is_set(&local_err)) { error_report("%s\n", error_get_pretty(local_err)); error_free(local_err); } return ret; }
static void test_visitor_out_enum_errors(TestOutputVisitorData *data, const void *unused) { EnumOne i, bad_values[] = { ENUM_ONE_MAX, -1 }; Error *errp; for (i = 0; i < ARRAY_SIZE(bad_values) ; i++) { errp = NULL; visit_type_EnumOne(data->ov, &bad_values[i], "unused", &errp); g_assert(error_is_set(&errp) == true); error_free(errp); } }
static int raw_create(const char *filename, QEMUOptionParameter *options, Error **errp) { Error *local_err = NULL; int ret; ret = bdrv_create_file(filename, options, &local_err); if (error_is_set(&local_err)) { qerror_report_err(local_err); error_free(local_err); } return ret; }
void qmp_guest_suspend_ram(Error **err) { GuestSuspendMode *mode = g_malloc(sizeof(GuestSuspendMode)); *mode = GUEST_SUSPEND_MODE_RAM; check_suspend_mode(*mode, err); acquire_privilege(SE_SHUTDOWN_NAME, err); execute_async(do_suspend, mode, err); if (error_is_set(err)) { g_free(mode); } }
void visit_type_uint64(Visitor *v, uint64_t *obj, const char *name, Error **errp) { int64_t value; if (!error_is_set(errp)) { if (v->type_uint64) { v->type_uint64(v, obj, name, errp); } else { value = *obj; v->type_int(v, &value, name, errp); *obj = value; } } }
static void test_visitor_in_number(TestInputVisitorData *data, const void *unused) { double res = 0, value = 3.14; Error *errp = NULL; Visitor *v; v = visitor_input_test_init(data, "%f", value); visit_type_number(v, &res, NULL, &errp); g_assert(!error_is_set(&errp)); g_assert_cmpfloat(res, ==, value); }
static void test_visitor_in_bool(TestInputVisitorData *data, const void *unused) { Error *errp = NULL; bool res = false; Visitor *v; v = visitor_input_test_init(data, "true"); visit_type_bool(v, &res, NULL, &errp); g_assert(!error_is_set(&errp)); g_assert_cmpint(res, ==, true); }
static void test_visitor_in_int(TestInputVisitorData *data, const void *unused) { int64_t res = 0, value = -42; Error *errp = NULL; Visitor *v; v = visitor_input_test_init(data, "%d", value); visit_type_int(v, &res, NULL, &errp); g_assert(!error_is_set(&errp)); g_assert_cmpint(res, ==, value); }
static void execute_async(DWORD WINAPI (*func)(LPVOID), LPVOID opaque, Error **err) { Error *local_err = NULL; if (error_is_set(err)) { return; } HANDLE thread = CreateThread(NULL, 0, func, opaque, 0, NULL); if (!thread) { error_set(&local_err, QERR_QGA_COMMAND_FAILED, "failed to dispatch asynchronous command"); error_propagate(err, local_err); } }
static void test_visitor_in_string(TestInputVisitorData *data, const void *unused) { char *res = NULL, *value = (char *) "Q E M U"; Error *errp = NULL; Visitor *v; v = visitor_input_test_init(data, "%s", value); visit_type_str(v, &res, NULL, &errp); g_assert(!error_is_set(&errp)); g_assert_cmpstr(res, ==, value); g_free(res); }