static void char_ringbuf_test(void) { QemuOpts *opts; Chardev *chr; CharBackend be; char *data; int ret; opts = qemu_opts_create(qemu_find_opts("chardev"), "ringbuf-label", 1, &error_abort); qemu_opt_set(opts, "backend", "ringbuf", &error_abort); qemu_opt_set(opts, "size", "5", &error_abort); chr = qemu_chr_new_from_opts(opts, NULL); g_assert_null(chr); qemu_opts_del(opts); opts = qemu_opts_create(qemu_find_opts("chardev"), "ringbuf-label", 1, &error_abort); qemu_opt_set(opts, "backend", "ringbuf", &error_abort); qemu_opt_set(opts, "size", "2", &error_abort); chr = qemu_chr_new_from_opts(opts, &error_abort); g_assert_nonnull(chr); qemu_opts_del(opts); qemu_chr_fe_init(&be, chr, &error_abort); ret = qemu_chr_fe_write(&be, (void *)"buff", 4); g_assert_cmpint(ret, ==, 4); data = qmp_ringbuf_read("ringbuf-label", 4, false, 0, &error_abort); g_assert_cmpstr(data, ==, "ff"); g_free(data); data = qmp_ringbuf_read("ringbuf-label", 4, false, 0, &error_abort); g_assert_cmpstr(data, ==, ""); g_free(data); qemu_chr_fe_deinit(&be, true); /* check alias */ opts = qemu_opts_create(qemu_find_opts("chardev"), "memory-label", 1, &error_abort); qemu_opt_set(opts, "backend", "memory", &error_abort); qemu_opt_set(opts, "size", "2", &error_abort); chr = qemu_chr_new_from_opts(opts, NULL); g_assert_nonnull(chr); object_unparent(OBJECT(chr)); qemu_opts_del(opts); }
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); }
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 PCIDevice *qemu_pci_hot_add_nic(Monitor *mon, const char *devaddr, const char *opts_str) { QemuOpts *opts; PCIBus *bus; int ret, devfn; bus = pci_get_bus_devfn(&devfn, devaddr); if (!bus) { monitor_printf(mon, "Invalid PCI device address %s\n", devaddr); return NULL; } if (!((BusState*)bus)->allow_hotplug) { monitor_printf(mon, "PCI bus doesn't support hotplug\n"); return NULL; } opts = qemu_opts_parse(qemu_find_opts("net"), opts_str ? opts_str : "", 0); if (!opts) { return NULL; } qemu_opt_set(opts, "type", "nic"); ret = net_client_init(mon, opts, 0); if (ret < 0) return NULL; if (nd_table[ret].devaddr) { monitor_printf(mon, "Parameter addr not supported\n"); return NULL; } return pci_nic_init(&nd_table[ret], "rtl8139", devaddr); }
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 qemu_set_option(const char *str) { char group[64], id[64], arg[64]; QemuOptsList *list; QemuOpts *opts; int rc, offset; rc = sscanf(str, "%63[^.].%63[^.].%63[^=]%n", group, id, arg, &offset); if (rc < 3 || str[offset] != '=') { error_report("can't parse: \"%s\"", str); return -1; } list = qemu_find_opts(group); if (list == NULL) { return -1; } opts = qemu_opts_find(list, id); if (!opts) { error_report("there is no %s \"%s\" defined", list->name, id); return -1; } if (qemu_opt_set(opts, arg, str+offset+1) == -1) { return -1; } return 0; }
int net_init_vhost_user(const NetClientOptions *opts, const char *name, NetClientState *peer, Error **errp) { int queues; const NetdevVhostUserOptions *vhost_user_opts; CharDriverState *chr; assert(opts->type == NET_CLIENT_OPTIONS_KIND_VHOST_USER); vhost_user_opts = opts->u.vhost_user.data; chr = net_vhost_parse_chardev(vhost_user_opts, errp); if (!chr) { return -1; } /* verify net frontend */ if (qemu_opts_foreach(qemu_find_opts("device"), net_vhost_check_net, (char *)name, errp)) { return -1; } queues = vhost_user_opts->has_queues ? vhost_user_opts->queues : 1; if (queues < 1 || queues > MAX_QUEUE_NUM) { error_setg(errp, "vhost-user number of queues must be in range [1, %d]", MAX_QUEUE_NUM); return -1; } return net_vhost_user_init(peer, "vhost_user", name, chr, queues); }
int net_init_vhost_user(const NetClientOptions *opts, const char *name, NetClientState *peer) { int queues; const NetdevVhostUserOptions *vhost_user_opts; CharDriverState *chr; assert(opts->kind == NET_CLIENT_OPTIONS_KIND_VHOST_USER); vhost_user_opts = opts->vhost_user; chr = net_vhost_parse_chardev(vhost_user_opts); if (!chr) { error_report("No suitable chardev found"); return -1; } /* verify net frontend */ if (qemu_opts_foreach(qemu_find_opts("device"), net_vhost_check_net, (char *)name, true) == -1) { return -1; } queues = vhost_user_opts->has_queues ? vhost_user_opts->queues : 1; return net_vhost_user_init(peer, "vhost_user", name, chr, queues); }
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); }
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 void test_qemu_opts_create(void) { QemuOptsList *list; QemuOpts *opts; 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)); /* now we've create the opts, must find it */ opts = qemu_opts_find(list, NULL); g_assert(opts != NULL); qemu_opts_del(opts); /* should not find anything at this point */ opts = qemu_opts_find(list, NULL); g_assert(opts == NULL); }
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 void test_qemu_find_opts(void) { QemuOptsList *list; /* we have an "opts_list_01" option, should return it */ list = qemu_find_opts("opts_list_01"); g_assert(list != NULL); g_assert_cmpstr(list->name, ==, "opts_list_01"); }
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 void test_qemu_opt_get_size(void) { QemuOptsList *list; QemuOpts *opts; uint64_t opt; QDict *dict; list = qemu_find_opts("opts_list_02"); g_assert(list != NULL); g_assert(QTAILQ_EMPTY(&list->head)); g_assert_cmpstr(list->name, ==, "opts_list_02"); /* 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 size1 yet, so defval should be returned */ opt = qemu_opt_get_size(opts, "size1", 5); g_assert(opt == 5); dict = qdict_new(); g_assert(dict != NULL); qdict_put(dict, "size1", qstring_from_str("10")); qemu_opts_absorb_qdict(opts, dict, &error_abort); g_assert(error_abort == NULL); /* now we have set size1, should know about it */ opt = qemu_opt_get_size(opts, "size1", 5); g_assert(opt == 10); /* reset value */ qdict_put(dict, "size1", qstring_from_str("15")); qemu_opts_absorb_qdict(opts, dict, &error_abort); g_assert(error_abort == NULL); /* test the reset value */ opt = qemu_opt_get_size(opts, "size1", 5); g_assert(opt == 15); qdict_del(dict, "size1"); g_free(dict); qemu_opts_del(opts); /* should not find anything at this point */ opts = qemu_opts_find(list, NULL); g_assert(opts == NULL); }
QemuOpts *qemu_find_opts_singleton(const char *group) { QemuOptsList *list; QemuOpts *opts; list = qemu_find_opts(group); assert(list); opts = qemu_opts_find(list, NULL); if (!opts) { opts = qemu_opts_create(list, NULL, 0, &error_abort); } return opts; }
void qemu_devtree_dumpdtb(void *fdt, int size) { QemuOpts *machine_opts; machine_opts = qemu_opts_find(qemu_find_opts("machine"), 0); if (machine_opts) { const char *dumpdtb = qemu_opt_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); } } }
static void char_console_test_subprocess(void) { QemuOpts *opts; Chardev *chr; opts = qemu_opts_create(qemu_find_opts("chardev"), "console-label", 1, &error_abort); qemu_opt_set(opts, "backend", "console", &error_abort); chr = qemu_chr_new_from_opts(opts, NULL); g_assert_nonnull(chr); qemu_chr_write_all(chr, (const uint8_t *)"CONSOLE", 7); qemu_opts_del(opts); object_unparent(OBJECT(chr)); }
static void setup_fixture(OptsVisitorFixture *f, gconstpointer test_data) { const char *opts_string = test_data; QemuOpts *opts; OptsVisitor *ov; opts = qemu_opts_parse(qemu_find_opts("userdef"), opts_string, false, NULL); g_assert(opts != NULL); ov = opts_visitor_new(opts); visit_type_UserDefOptions(opts_get_visitor(ov), NULL, &f->userdef, &f->err); opts_visitor_cleanup(ov); qemu_opts_del(opts); }
static void ccw_init(MachineState *machine) { ram_addr_t my_ram_size = machine->ram_size; MemoryRegion *sysmem = get_system_memory(); MemoryRegion *ram = g_new(MemoryRegion, 1); sclpMemoryHotplugDev *mhd = init_sclp_memory_hotplug_dev(); uint8_t *storage_keys; int ret; VirtualCssBus *css_bus; DeviceState *dev; QemuOpts *opts = qemu_opts_find(qemu_find_opts("memory"), NULL); ram_addr_t pad_size = 0; ram_addr_t maxmem = qemu_opt_get_size(opts, "maxmem", my_ram_size); ram_addr_t standby_mem_size = maxmem - my_ram_size; uint64_t kvm_limit; /* The storage increment size is a multiple of 1M and is a power of 2. * The number of storage increments must be MAX_STORAGE_INCREMENTS or fewer. * The variable 'mhd->increment_size' is an exponent of 2 that can be * used to calculate the size (in bytes) of an increment. */ mhd->increment_size = 20; while ((my_ram_size >> mhd->increment_size) > MAX_STORAGE_INCREMENTS) { mhd->increment_size++; } while ((standby_mem_size >> mhd->increment_size) > MAX_STORAGE_INCREMENTS) { mhd->increment_size++; } /* The core and standby memory areas need to be aligned with * the increment size. In effect, this can cause the * user-specified memory size to be rounded down to align * with the nearest increment boundary. */ standby_mem_size = standby_mem_size >> mhd->increment_size << mhd->increment_size; my_ram_size = my_ram_size >> mhd->increment_size << mhd->increment_size; /* let's propagate the changed ram size into the global variable. */ ram_size = my_ram_size; machine->maxram_size = my_ram_size + standby_mem_size; ret = s390_set_memory_limit(machine->maxram_size, &kvm_limit); if (ret == -E2BIG) { hw_error("qemu: host supports a maximum of %" PRIu64 " GB", kvm_limit >> 30); } else if (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; }
static void test_qemu_opt_get_number(void) { QemuOptsList *list; QemuOpts *opts; uint64_t opt; int ret; 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 number1 yet, so defval should be returned */ opt = qemu_opt_get_number(opts, "number1", 5); g_assert(opt == 5); ret = qemu_opt_set_number(opts, "number1", 10); g_assert(ret == 0); /* now we have set number1, should know about it */ opt = qemu_opt_get_number(opts, "number1", 5); g_assert(opt == 10); /* having reset it, the returned should be the reset one not defval */ ret = qemu_opt_set_number(opts, "number1", 15); g_assert(ret == 0); opt = qemu_opt_get_number(opts, "number1", 5); g_assert(opt == 15); qemu_opts_del(opts); /* should not find anything at this point */ opts = qemu_opts_find(list, NULL); g_assert(opts == NULL); }
static PCIDevice *qemu_pci_hot_add_nic(Monitor *mon, const char *devaddr, const char *opts_str) { Error *local_err = NULL; QemuOpts *opts; PCIBus *root = pci_find_primary_bus(); PCIBus *bus; int ret, devfn; if (!root) { monitor_printf(mon, "no primary PCI bus (if there are multiple" " PCI roots, you must use device_add instead)"); return NULL; } bus = pci_get_bus_devfn(&devfn, root, devaddr); if (!bus) { monitor_printf(mon, "Invalid PCI device address %s\n", devaddr); return NULL; } if (!((BusState*)bus)->allow_hotplug) { monitor_printf(mon, "PCI bus doesn't support hotplug\n"); return NULL; } opts = qemu_opts_parse(qemu_find_opts("net"), opts_str ? opts_str : "", 0); if (!opts) { return NULL; } qemu_opt_set(opts, "type", "nic"); ret = net_client_init(opts, 0, &local_err); if (error_is_set(&local_err)) { qerror_report_err(local_err); error_free(local_err); return NULL; } if (nd_table[ret].devaddr) { monitor_printf(mon, "Parameter addr not supported\n"); return NULL; } return pci_nic_init(&nd_table[ret], root, "rtl8139", devaddr); }
static void test_qemu_opt_get_bool(void) { QemuOptsList *list; QemuOpts *opts; bool opt; int ret; list = qemu_find_opts("opts_list_02"); g_assert(list != NULL); g_assert(QTAILQ_EMPTY(&list->head)); g_assert_cmpstr(list->name, ==, "opts_list_02"); /* 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 bool1 yet, so defval should be returned */ opt = qemu_opt_get_bool(opts, "bool1", false); g_assert(opt == false); ret = qemu_opt_set_bool(opts, "bool1", true); g_assert(ret == 0); /* now we have set bool1, should know about it */ opt = qemu_opt_get_bool(opts, "bool1", false); g_assert(opt == true); /* having reset the value, opt should be the reset one not defval */ ret = qemu_opt_set_bool(opts, "bool1", false); g_assert(ret == 0); opt = qemu_opt_get_bool(opts, "bool1", true); g_assert(opt == false); qemu_opts_del(opts); /* should not find anything at this point */ opts = qemu_opts_find(list, NULL); g_assert(opts == NULL); }
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 void qmp_change_vnc_listen(const char *target, Error **errp) { QemuOptsList *olist = qemu_find_opts("vnc"); QemuOpts *opts; if (strstr(target, "id=")) { error_setg(errp, "id not supported"); return; } opts = qemu_opts_find(olist, "default"); if (opts) { qemu_opts_del(opts); } opts = vnc_parse(target, errp); if (!opts) { return; } vnc_display_open("default", errp); }
static void fw_cfg_reboot(FWCfgState *s) { const char *reboot_timeout = NULL; int64_t rt_val = -1; /* get user configuration */ QemuOptsList *plist = qemu_find_opts("boot-opts"); QemuOpts *opts = QTAILQ_FIRST(&plist->head); reboot_timeout = qemu_opt_get(opts, "reboot-timeout"); if (reboot_timeout) { rt_val = qemu_opt_get_number(opts, "reboot-timeout", -1); /* validate the input */ if (rt_val < 0 || rt_val > 0xffff) { error_report("reboot timeout is invalid," "it should be a value between 0 and 65535"); exit(1); } } fw_cfg_add_file(s, "etc/boot-fail-wait", g_memdup(&rt_val, 4), 4); }
static int parse_chap(struct iscsi_context *iscsi, const char *target) { QemuOptsList *list; QemuOpts *opts; const char *user = NULL; const char *password = NULL; list = qemu_find_opts("iscsi"); if (!list) { return 0; } opts = qemu_opts_find(list, target); if (opts == NULL) { opts = QTAILQ_FIRST(&list->head); if (!opts) { return 0; } } user = qemu_opt_get(opts, "user"); if (!user) { return 0; } password = qemu_opt_get(opts, "password"); if (!password) { error_report("CHAP username specified but no password was given"); return -1; } if (iscsi_set_initiator_username_pwd(iscsi, user, password)) { error_report("Failed to set initiator username and password"); return -1; } return 0; }
int net_init_vhost_user(const NetClientOptions *opts, const char *name, NetClientState *peer, Error **errp) { const NetdevVhostUserOptions *vhost_user_opts; CharDriverState *chr; assert(opts->kind == NET_CLIENT_OPTIONS_KIND_VHOST_USER); vhost_user_opts = opts->vhost_user; chr = net_vhost_parse_chardev(vhost_user_opts, errp); if (!chr) { return -1; } /* verify net frontend */ if (qemu_opts_foreach(qemu_find_opts("device"), net_vhost_check_net, (char *)name, errp)) { return -1; } return net_vhost_user_init(peer, "vhost_user", name, chr); }
static void fw_cfg_reboot(FWCfgState *s) { int reboot_timeout = -1; char *p; const char *temp; /* get user configuration */ QemuOptsList *plist = qemu_find_opts("boot-opts"); QemuOpts *opts = QTAILQ_FIRST(&plist->head); if (opts != NULL) { temp = qemu_opt_get(opts, "reboot-timeout"); if (temp != NULL) { p = (char *)temp; reboot_timeout = strtol(p, (char **)&p, 10); } } /* validate the input */ if (reboot_timeout > 0xffff) { error_report("reboot timeout is larger than 65535, force it to 65535."); reboot_timeout = 0xffff; } fw_cfg_add_file(s, "etc/boot-fail-wait", g_memdup(&reboot_timeout, 4), 4); }