int inet_listen(const char *str, char *ostr, int olen, int socktype, int port_offset) { QemuOpts *opts; char *optstr; int sock = -1; opts = qemu_opts_create(&dummy_opts, NULL, 0); if (inet_parse(opts, str) == 0) { sock = inet_listen_opts(opts, port_offset); if (sock != -1 && ostr) { optstr = strchr(str, ','); if (qemu_opt_get_bool(opts, "ipv6", 0)) { snprintf(ostr, olen, "[%s]:%s%s", qemu_opt_get(opts, "host"), qemu_opt_get(opts, "port"), optstr ? optstr : ""); } else { snprintf(ostr, olen, "%s:%s%s", qemu_opt_get(opts, "host"), qemu_opt_get(opts, "port"), optstr ? optstr : ""); } } } qemu_opts_del(opts); return sock; }
int inet_listen(const char *str, char *ostr, int olen, int socktype, int port_offset, Error **errp) { QemuOpts *opts; char *optstr; int sock = -1; InetSocketAddress *addr; addr = inet_parse(str, errp); if (addr != NULL) { opts = qemu_opts_create(&socket_optslist, NULL, 0, &error_abort); inet_addr_to_opts(opts, addr); qapi_free_InetSocketAddress(addr); sock = inet_listen_opts(opts, port_offset, errp); if (sock != -1 && ostr) { optstr = strchr(str, ','); if (qemu_opt_get_bool(opts, "ipv6", 0)) { snprintf(ostr, olen, "[%s]:%s%s", qemu_opt_get(opts, "host"), qemu_opt_get(opts, "port"), optstr ? optstr : ""); } else { snprintf(ostr, olen, "%s:%s%s", qemu_opt_get(opts, "host"), qemu_opt_get(opts, "port"), optstr ? optstr : ""); } } qemu_opts_del(opts); } return sock; }
static void test_qemu_opt_unset(void) { QemuOpts *opts; const char *value; int ret; /* dynamically initialized (parsed) opts */ opts = qemu_opts_parse(&opts_list_03, "key=value", 0); g_assert(opts != NULL); /* check default/parsed value */ value = qemu_opt_get(opts, "key"); g_assert_cmpstr(value, ==, "value"); /* reset it to value2 */ qemu_opt_set(opts, "key", "value2"); value = qemu_opt_get(opts, "key"); g_assert_cmpstr(value, ==, "value2"); /* unset, valid only for "accept any" */ ret = qemu_opt_unset(opts, "key"); g_assert(ret == 0); /* after reset the value should be the parsed/default one */ value = qemu_opt_get(opts, "key"); g_assert_cmpstr(value, ==, "value"); qemu_opts_del(opts); }
static int net_tap_init(QemuOpts *opts, int *vnet_hdr) { int fd, vnet_hdr_required; char ifname[128] = {0,}; const char *setup_script; if (qemu_opt_get(opts, "ifname")) { pstrcpy(ifname, sizeof(ifname), qemu_opt_get(opts, "ifname")); } *vnet_hdr = qemu_opt_get_bool(opts, "vnet_hdr", 1); if (qemu_opt_get(opts, "vnet_hdr")) { vnet_hdr_required = *vnet_hdr; } else { vnet_hdr_required = 0; } TFR(fd = tap_open(ifname, sizeof(ifname), vnet_hdr, vnet_hdr_required)); if (fd < 0) { return -1; } setup_script = qemu_opt_get(opts, "script"); if (setup_script && setup_script[0] != '\0' && strcmp(setup_script, "no") != 0 && launch_script(setup_script, ifname, fd)) { close(fd); return -1; } qemu_opt_set(opts, "ifname", ifname); return fd; }
void replay_configure(QemuOpts *opts) { const char *fname; const char *rr; ReplayMode mode = REPLAY_MODE_NONE; rr = qemu_opt_get(opts, "rr"); if (!rr) { /* Just enabling icount */ return; } else if (!strcmp(rr, "record")) { mode = REPLAY_MODE_RECORD; } else if (!strcmp(rr, "replay")) { mode = REPLAY_MODE_PLAY; } else { error_report("Invalid icount rr option: %s", rr); exit(1); } fname = qemu_opt_get(opts, "rrfile"); if (!fname) { error_report("File name not specified for replay"); exit(1); } replay_enable(fname, mode); }
/* Scan for remote-port links to be setup. */ void rp_device_add(QemuOpts *opts, DeviceState *dev, Error **errp) { Error *err = NULL; Object *adaptor; bool ambiguous; const char *path; char *name; int i; /* * Find the adaptor this remote-port device is connected to. * At the moment, we only support one adaptor per device. */ name = g_strdup_printf("rp-adaptor%d", 0); path = qemu_opt_get(opts, name); g_free(name); if (!path) { /* This is not a remote-port device. */ return; } adaptor = object_resolve_path(path, &ambiguous); if (!adaptor) { error_setg(errp, "Did not find rp adaptor %s!\n", path); return; } /* * Loop through the channels this device provides and attach * them to the adaptor. */ for (i = 0; i < INT_MAX; i++) { unsigned long dev_nr; const char *dev_nr_str; name = g_strdup_printf("rp-chan%d", i); dev_nr_str = qemu_opt_get(opts, name); g_free(name); if (!dev_nr_str) { if (i == 0) { /* At least one channel must be provided. */ error_setg(errp, "Did not find rp-chan%d!\n", i); } return; } if (qemu_strtoul(dev_nr_str, NULL, 0, &dev_nr)) { error_setg(errp, "Invalid rp-chan%d!\n", i); return; } /* Now, attach the device to the adaptor. */ rp_device_attach(adaptor, OBJECT(dev), 0, dev_nr, &err); if (err != NULL) { error_propagate(errp, err); return; } } }
static void fw_cfg_bootsplash(FWCfgState *s) { const char *boot_splash_filename = NULL; const char *boot_splash_time = NULL; char *filename, *file_data; gsize file_size; int file_type; /* get user configuration */ QemuOptsList *plist = qemu_find_opts("boot-opts"); QemuOpts *opts = QTAILQ_FIRST(&plist->head); boot_splash_filename = qemu_opt_get(opts, "splash"); boot_splash_time = qemu_opt_get(opts, "splash-time"); /* insert splash time if user configurated */ if (boot_splash_time) { int64_t bst_val = qemu_opt_get_number(opts, "splash-time", -1); uint16_t bst_le16; /* validate the input */ if (bst_val < 0 || bst_val > 0xffff) { error_report("splash-time is invalid," "it should be a value between 0 and 65535"); exit(1); } /* use little endian format */ bst_le16 = cpu_to_le16(bst_val); fw_cfg_add_file(s, "etc/boot-menu-wait", g_memdup(&bst_le16, sizeof bst_le16), sizeof bst_le16); } /* insert splash file if user configurated */ if (boot_splash_filename) { filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, boot_splash_filename); if (filename == NULL) { error_report("failed to find file '%s'", boot_splash_filename); return; } /* loading file data */ file_data = read_splashfile(filename, &file_size, &file_type); if (file_data == NULL) { g_free(filename); return; } g_free(boot_splash_filedata); boot_splash_filedata = (uint8_t *)file_data; /* insert data */ if (file_type == JPG_FILE) { fw_cfg_add_file(s, "bootsplash.jpg", boot_splash_filedata, file_size); } else { fw_cfg_add_file(s, "bootsplash.bmp", boot_splash_filedata, file_size); } g_free(filename); } }
static int qemu_archipelago_open(BlockDriverState *bs, QDict *options, int bdrv_flags, Error **errp) { int ret = 0; const char *volume, *segment_name; QemuOpts *opts; Error *local_err = NULL; BDRVArchipelagoState *s = bs->opaque; opts = qemu_opts_create(&archipelago_runtime_opts, NULL, 0, &error_abort); qemu_opts_absorb_qdict(opts, options, &local_err); if (local_err) { error_propagate(errp, local_err); ret = -EINVAL; goto err_exit; } s->mportno = qemu_opt_get_number(opts, ARCHIPELAGO_OPT_MPORT, ARCHIPELAGO_DFL_MPORT); s->vportno = qemu_opt_get_number(opts, ARCHIPELAGO_OPT_VPORT, ARCHIPELAGO_DFL_VPORT); segment_name = qemu_opt_get(opts, ARCHIPELAGO_OPT_SEGMENT); if (segment_name == NULL) { s->segment_name = g_strdup("archipelago"); } else { s->segment_name = g_strdup(segment_name); } volume = qemu_opt_get(opts, ARCHIPELAGO_OPT_VOLUME); if (volume == NULL) { error_setg(errp, "archipelago block driver requires the 'volume'" " option"); ret = -EINVAL; goto err_exit; } s->volname = g_strdup(volume); /* Initialize XSEG, join shared memory segment */ ret = qemu_archipelago_init(s); if (ret < 0) { error_setg(errp, "cannot initialize XSEG and join shared " "memory segment"); goto err_exit; } qemu_opts_del(opts); return 0; err_exit: g_free(s->volname); g_free(s->segment_name); qemu_opts_del(opts); return ret; }
static void s390_ipl_set_boot_menu(S390IPLState *ipl) { QemuOptsList *plist = qemu_find_opts("boot-opts"); QemuOpts *opts = QTAILQ_FIRST(&plist->head); uint8_t *flags = &ipl->qipl.qipl_flags; uint32_t *timeout = &ipl->qipl.boot_menu_timeout; const char *tmp; unsigned long splash_time = 0; if (!get_boot_device(0)) { if (boot_menu) { error_report("boot menu requires a bootindex to be specified for " "the IPL device"); } return; } switch (ipl->iplb.pbt) { case S390_IPL_TYPE_CCW: /* In the absence of -boot menu, use zipl parameters */ if (!qemu_opt_get(opts, "menu")) { *flags |= QIPL_FLAG_BM_OPTS_ZIPL; return; } break; case S390_IPL_TYPE_QEMU_SCSI: break; default: if (boot_menu) { error_report("boot menu is not supported for this device type"); } return; } if (!boot_menu) { return; } *flags |= QIPL_FLAG_BM_OPTS_CMD; tmp = qemu_opt_get(opts, "splash-time"); if (tmp && qemu_strtoul(tmp, NULL, 10, &splash_time)) { error_report("splash-time is invalid, forcing it to 0"); *timeout = 0; return; } if (splash_time > 0xffffffff) { error_report("splash-time is too large, forcing it to max value"); *timeout = 0xffffffff; return; } *timeout = cpu_to_be32(splash_time); }
static int qemu_add_one_global(QemuOpts *opts, void *opaque) { GlobalProperty *g; g = qemu_mallocz(sizeof(*g)); g->driver = qemu_opt_get(opts, "driver"); g->property = qemu_opt_get(opts, "property"); g->value = qemu_opt_get(opts, "value"); qdev_prop_register_global(g); return 0; }
static int qdev_add_one_global(void *opaque, QemuOpts *opts, Error **errp) { GlobalProperty *g; g = g_malloc0(sizeof(*g)); g->driver = qemu_opt_get(opts, "driver"); g->property = qemu_opt_get(opts, "property"); g->value = qemu_opt_get(opts, "value"); g->user_provided = true; qdev_prop_register_global(g); return 0; }
static int blkverify_open(BlockDriverState *bs, QDict *options, int flags) { BDRVBlkverifyState *s = bs->opaque; QemuOpts *opts; Error *local_err = NULL; const char *filename, *raw; int ret; opts = qemu_opts_create_nofail(&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; } /* Parse the raw image filename */ raw = qemu_opt_get(opts, "x-raw"); if (raw == NULL) { ret = -EINVAL; goto fail; } ret = bdrv_file_open(&bs->file, raw, NULL, flags); if (ret < 0) { goto fail; } /* Open the test file */ filename = qemu_opt_get(opts, "x-image"); if (filename == NULL) { ret = -EINVAL; goto fail; } s->test_file = bdrv_new(""); ret = bdrv_open(s->test_file, filename, NULL, flags, NULL); if (ret < 0) { bdrv_unref(s->test_file); s->test_file = NULL; goto fail; } ret = 0; fail: return ret; }
static void test_qemu_opts_set(void) { QemuOptsList *list; QemuOpts *opts; int ret; const char *opt; list = qemu_find_opts("opts_list_01"); g_assert(list != NULL); g_assert(QTAILQ_EMPTY(&list->head)); g_assert_cmpstr(list->name, ==, "opts_list_01"); /* should not find anything at this point */ opts = qemu_opts_find(list, NULL); g_assert(opts == NULL); /* implicitly create opts and set str3 value */ ret = qemu_opts_set(list, NULL, "str3", "value"); g_assert(ret == 0); g_assert(!QTAILQ_EMPTY(&list->head)); /* get the just created opts */ opts = qemu_opts_find(list, NULL); g_assert(opts != NULL); /* check the str3 value */ opt = qemu_opt_get(opts, "str3"); g_assert_cmpstr(opt, ==, "value"); qemu_opts_del(opts); /* should not find anything at this point */ opts = qemu_opts_find(list, NULL); g_assert(opts == NULL); }
int xen_config_dev_blk(DriveInfo *disk) { char fe[256], be[256], device_name[32]; int vdev = 202 * 256 + 16 * disk->unit; int cdrom = disk->media_cd; const char *devtype = cdrom ? "cdrom" : "disk"; const char *mode = cdrom ? "r" : "w"; const char *filename = qemu_opt_get(disk->opts, "file"); snprintf(device_name, sizeof(device_name), "xvd%c", 'a' + disk->unit); xen_be_printf(NULL, 1, "config disk %d [%s]: %s\n", disk->unit, device_name, filename); xen_config_dev_dirs("vbd", "qdisk", vdev, fe, be, sizeof(fe)); /* frontend */ xenstore_write_int(fe, "virtual-device", vdev); xenstore_write_str(fe, "device-type", devtype); /* backend */ xenstore_write_str(be, "dev", device_name); xenstore_write_str(be, "type", "file"); xenstore_write_str(be, "params", filename); xenstore_write_str(be, "mode", mode); /* common stuff */ return xen_config_dev_all(fe, be); }
int unix_connect_opts(QemuOpts *opts) { SockAddress un; const char *path = qemu_opt_get(opts, "path"); int ret, sock; sock = socket_create_unix(SOCKET_STREAM); if (sock < 0) { perror("socket(unix)"); return -1; } sock_address_init_unix(&un, path); ret = socket_connect(sock, &un); sock_address_done(&un); if (ret < 0) { fprintf(stderr, "connect(unix:%s): %s\n", path, errno_str); return -1; } if (sockets_debug) fprintf(stderr, "connect(unix:%s): OK\n", path); return sock; }
uint32_t qemu_devtree_alloc_phandle(void *fdt) { static int phandle = 0x0; /* * We need to find out if the user gave us special instruction at * which phandle id to start allocting phandles. */ if (!phandle) { QemuOpts *machine_opts; machine_opts = qemu_opts_find(qemu_find_opts("machine"), 0); if (machine_opts) { const char *phandle_start; phandle_start = qemu_opt_get(machine_opts, "phandle_start"); if (phandle_start) { phandle = strtoul(phandle_start, NULL, 0); } } } if (!phandle) { /* * None or invalid phandle given on the command line, so fall back to * default starting point. */ phandle = 0x8000; } return phandle++; }
static int coroutine_fn qemu_rbd_co_create_opts(const char *filename, QemuOpts *opts, Error **errp) { BlockdevCreateOptions *create_options; BlockdevCreateOptionsRbd *rbd_opts; BlockdevOptionsRbd *loc; Error *local_err = NULL; const char *keypairs, *password_secret; QDict *options = NULL; int ret = 0; create_options = g_new0(BlockdevCreateOptions, 1); create_options->driver = BLOCKDEV_DRIVER_RBD; rbd_opts = &create_options->u.rbd; rbd_opts->location = g_new0(BlockdevOptionsRbd, 1); password_secret = qemu_opt_get(opts, "password-secret"); /* Read out options */ rbd_opts->size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0), BDRV_SECTOR_SIZE); rbd_opts->cluster_size = qemu_opt_get_size_del(opts, BLOCK_OPT_CLUSTER_SIZE, 0); rbd_opts->has_cluster_size = (rbd_opts->cluster_size != 0); options = qdict_new(); qemu_rbd_parse_filename(filename, options, &local_err); if (local_err) { ret = -EINVAL; error_propagate(errp, local_err); goto exit; } /* * Caution: while qdict_get_try_str() is fine, getting non-string * types would require more care. When @options come from -blockdev * or blockdev_add, its members are typed according to the QAPI * schema, but when they come from -drive, they're all QString. */ loc = rbd_opts->location; loc->pool = g_strdup(qdict_get_try_str(options, "pool")); loc->conf = g_strdup(qdict_get_try_str(options, "conf")); loc->has_conf = !!loc->conf; loc->user = g_strdup(qdict_get_try_str(options, "user")); loc->has_user = !!loc->user; loc->image = g_strdup(qdict_get_try_str(options, "image")); keypairs = qdict_get_try_str(options, "=keyvalue-pairs"); ret = qemu_rbd_do_create(create_options, keypairs, password_secret, errp); if (ret < 0) { goto exit; } exit: qobject_unref(options); qapi_free_BlockdevCreateOptions(create_options); return ret; }
static void *get_device_tree(int *fdt_size) { char *path; void *fdt; const char *dtb_arg; QemuOpts *machine_opts; machine_opts = qemu_opts_find(qemu_find_opts("machine"), 0); if (!machine_opts) { dtb_arg = BINARY_DEVICE_TREE_FILE; } else { dtb_arg = qemu_opt_get(machine_opts, "dtb"); if (!dtb_arg) { dtb_arg = BINARY_DEVICE_TREE_FILE; } } fdt = load_device_tree(dtb_arg, fdt_size); if (!fdt) { path = qemu_find_file(QEMU_FILE_TYPE_BIOS, BINARY_DEVICE_TREE_FILE); if (path) { fdt = load_device_tree(path, fdt_size); g_free(path); } } return fdt; }
int unix_connect_opts(QemuOpts *opts) { struct sockaddr_un un; const char *path = qemu_opt_get(opts, "path"); int sock; if (NULL == path) { fprintf(stderr, "unix connect: no path specified\n"); return -1; } sock = qemu_socket(PF_UNIX, SOCK_STREAM, 0); if (sock < 0) { perror("socket(unix)"); return -1; } memset(&un, 0, sizeof(un)); un.sun_family = AF_UNIX; snprintf(un.sun_path, sizeof(un.sun_path), "%s", path); if (connect(sock, (struct sockaddr*) &un, sizeof(un)) < 0) { fprintf(stderr, "connect(unix:%s): %s\n", path, strerror(errno)); return -1; } if (sockets_debug) fprintf(stderr, "connect(unix:%s): OK\n", path); return sock; }
/* compatibility wrapper */ int unix_listen(const char *str, char *ostr, int olen) { QemuOpts *opts; char *path, *optstr; int sock, len; opts = qemu_opts_create(&dummy_opts, NULL, 0); optstr = strchr(str, ','); if (optstr) { len = optstr - str; if (len) { path = qemu_malloc(len+1); snprintf(path, len+1, "%.*s", len, str); qemu_opt_set(opts, "path", path); qemu_free(path); } } else { qemu_opt_set(opts, "path", str); } sock = unix_listen_opts(opts); if (sock != -1 && ostr) snprintf(ostr, olen, "%s%s", qemu_opt_get(opts, "path"), optstr ? optstr : ""); qemu_opts_del(opts); return sock; }
static char *parse_initiator_name(const char *target) { QemuOptsList *list; QemuOpts *opts; const char *name = NULL; const char *iscsi_name = qemu_get_vm_name(); list = qemu_find_opts("iscsi"); if (list) { opts = qemu_opts_find(list, target); if (!opts) { opts = QTAILQ_FIRST(&list->head); } if (opts) { name = qemu_opt_get(opts, "initiator-name"); } } if (name) { return g_strdup(name); } else { return g_strdup_printf("iqn.2008-11.org.linux-kvm%s%s", iscsi_name ? ":" : "", iscsi_name ? iscsi_name : ""); } }
static char *parse_initiator_name(const char *target) { QemuOptsList *list; QemuOpts *opts; const char *name = NULL; list = qemu_find_opts("iscsi"); if (!list) { return g_strdup("iqn.2008-11.org.linux-kvm"); } opts = qemu_opts_find(list, target); if (opts == NULL) { opts = QTAILQ_FIRST(&list->head); if (!opts) { return g_strdup("iqn.2008-11.org.linux-kvm"); } } name = qemu_opt_get(opts, "initiator-name"); if (!name) { return g_strdup("iqn.2008-11.org.linux-kvm"); } return g_strdup(name); }
static int tpm_passthrough_handle_device_opts(QemuOpts *opts, TPMBackend *tb) { TPMPassthruState *tpm_pt = TPM_PASSTHROUGH(tb); const char *value; value = qemu_opt_get(opts, "cancel-path"); if (value) { tb->cancel_path = g_strdup(value); } value = qemu_opt_get(opts, "path"); if (!value) { value = TPM_PASSTHROUGH_DEFAULT_DEVICE; } tpm_pt->tpm_dev = g_strdup(value); tb->path = g_strdup(tpm_pt->tpm_dev); tpm_pt->tpm_fd = qemu_open(tpm_pt->tpm_dev, O_RDWR); if (tpm_pt->tpm_fd < 0) { error_report("Cannot access TPM device using '%s': %s\n", tpm_pt->tpm_dev, strerror(errno)); goto err_free_parameters; } if (tpm_passthrough_test_tpmdev(tpm_pt->tpm_fd)) { error_report("'%s' is not a TPM device.\n", tpm_pt->tpm_dev); goto err_close_tpmdev; } return 0; err_close_tpmdev: qemu_close(tpm_pt->tpm_fd); tpm_pt->tpm_fd = -1; err_free_parameters: g_free(tb->path); tb->path = NULL; g_free(tpm_pt->tpm_dev); tpm_pt->tpm_dev = NULL; return 1; }
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; }
char *trace_opt_parse(const char *optarg) { char *trace_file; QemuOpts *opts = qemu_opts_parse_noisily(qemu_find_opts("trace"), optarg, true); if (!opts) { exit(1); } if (qemu_opt_get(opts, "enable")) { trace_enable_events(qemu_opt_get(opts, "enable")); } trace_init_events(qemu_opt_get(opts, "events")); trace_file = g_strdup(qemu_opt_get(opts, "file")); qemu_opts_del(opts); return trace_file; }
int unix_connect_opts(QemuOpts *opts, Error **errp, NonBlockingConnectHandler *callback, void *opaque) { struct sockaddr_un un; const char *path = qemu_opt_get(opts, "path"); ConnectState *connect_state = NULL; int sock, rc; if (path == NULL) { error_setg(errp, "unix connect: no path specified"); return -1; } sock = qemu_socket(PF_UNIX, SOCK_STREAM, 0); if (sock < 0) { error_setg_errno(errp, errno, "Failed to create socket"); return -1; } if (callback != NULL) { connect_state = g_malloc0(sizeof(*connect_state)); connect_state->callback = callback; connect_state->opaque = opaque; qemu_set_nonblock(sock); } memset(&un, 0, sizeof(un)); un.sun_family = AF_UNIX; snprintf(un.sun_path, sizeof(un.sun_path), "%s", path); /* connect to peer */ do { rc = 0; if (connect(sock, (struct sockaddr *) &un, sizeof(un)) < 0) { rc = -socket_error(); } } while (rc == -EINTR); if (connect_state != NULL && QEMU_SOCKET_RC_INPROGRESS(rc)) { connect_state->fd = sock; qemu_set_fd_handler2(sock, NULL, NULL, wait_for_connect, connect_state); return sock; } else if (rc >= 0) { /* non blocking socket immediate success, call callback */ if (callback != NULL) { callback(sock, NULL, opaque); } } if (rc < 0) { error_setg_errno(errp, -rc, "Failed to connect socket"); close(sock); sock = -1; } g_free(connect_state); return sock; }
void qemu_fdt_dumpdtb(void *fdt, int size) { const char *dumpdtb = qemu_opt_get(qemu_get_machine_opts(), "dumpdtb"); if (dumpdtb) { /* Dump the dtb to a file and quit */ exit(g_file_set_contents(dumpdtb, fdt, size, NULL) ? 0 : 1); } }
void qemu_chr_parse_common(QemuOpts *opts, ChardevCommon *backend) { const char *logfile = qemu_opt_get(opts, "logfile"); backend->has_logfile = logfile != NULL; backend->logfile = g_strdup(logfile); backend->has_logappend = true; backend->logappend = qemu_opt_get_bool(opts, "logappend", false); }
static void test_qemu_opt_get(void) { QemuOptsList *list; QemuOpts *opts; const char *opt = NULL; list = qemu_find_opts("opts_list_01"); g_assert(list != NULL); g_assert(QTAILQ_EMPTY(&list->head)); g_assert_cmpstr(list->name, ==, "opts_list_01"); /* should not find anything at this point */ opts = qemu_opts_find(list, NULL); g_assert(opts == NULL); /* create the opts */ opts = qemu_opts_create(list, NULL, 0, &error_abort); g_assert(opts != NULL); g_assert(!QTAILQ_EMPTY(&list->head)); /* haven't set anything to str2 yet */ opt = qemu_opt_get(opts, "str2"); g_assert(opt == NULL); qemu_opt_set(opts, "str2", "value"); /* now we have set str2, should know about it */ opt = qemu_opt_get(opts, "str2"); g_assert_cmpstr(opt, ==, "value"); qemu_opt_set(opts, "str2", "value2"); /* having reset the value, the returned should be the reset one */ opt = qemu_opt_get(opts, "str2"); g_assert_cmpstr(opt, ==, "value2"); qemu_opts_del(opts); /* should not find anything at this point */ opts = qemu_opts_find(list, NULL); g_assert(opts == NULL); }
static bool ssh_process_legacy_socket_options(QDict *output_opts, QemuOpts *legacy_opts, Error **errp) { const char *host = qemu_opt_get(legacy_opts, "host"); const char *port = qemu_opt_get(legacy_opts, "port"); if (!host && port) { error_setg(errp, "port may not be used without host"); return false; } if (host) { qdict_put(output_opts, "server.host", qstring_from_str(host)); qdict_put(output_opts, "server.port", qstring_from_str(port ?: stringify(22))); } return true; }