ShuriZma
/
xemu
mirror of https://github.com/xemu-project/xemu.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge remote branch 'kwolf/for-anthony' into staging

This commit is contained in:
Anthony Liguori 2010-12-17 08:23:53 -06:00
parent fef395782d 5eeaad5a57
commit 4a493c6fac
9 changed files with 1344 additions and 107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Makefile.objs
View File

@ -24,6 +24,7 @@ block-nested-y += parallels.o nbd.o blkdebug.o sheepdog.o blkverify.o
block-nested-$(CONFIG_WIN32) += raw-win32.o
block-nested-$(CONFIG_POSIX) += raw-posix.o
block-nested-$(CONFIG_CURL) += curl.o
block-nested-$(CONFIG_RBD) += rbd.o
block-obj-y += $(addprefix block/, $(block-nested-y))

2
block.c
View File

@ -215,7 +215,7 @@ int bdrv_create_file(const char* filename, QEMUOptionParameter *options)
drv = bdrv_find_protocol(filename);
if (drv == NULL) {
drv = bdrv_find_format("file");
return -ENOENT;
}
return bdrv_create(drv, filename, options);

1059
block/rbd.c Normal file
View File

File diff suppressed because it is too large Load Diff

71
block/rbd_types.h Normal file
View File

@ -0,0 +1,71 @@
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2004-2010 Sage Weil <sage@newdream.net>
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.LIB.
*
*/
#ifndef CEPH_RBD_TYPES_H
#define CEPH_RBD_TYPES_H
/*
* rbd image 'foo' consists of objects
* foo.rbd - image metadata
* foo.00000000
* foo.00000001
* ... - data
*/
#define RBD_SUFFIX ".rbd"
#define RBD_DIRECTORY "rbd_directory"
#define RBD_INFO "rbd_info"
#define RBD_DEFAULT_OBJ_ORDER 22 /* 4MB */
#define RBD_MAX_OBJ_NAME_SIZE 96
#define RBD_MAX_BLOCK_NAME_SIZE 24
#define RBD_MAX_SEG_NAME_SIZE 128
#define RBD_COMP_NONE 0
#define RBD_CRYPT_NONE 0
#define RBD_HEADER_TEXT "<<< Rados Block Device Image >>>\n"
#define RBD_HEADER_SIGNATURE "RBD"
#define RBD_HEADER_VERSION "001.005"
struct rbd_info {
uint64_t max_id;
} __attribute__ ((packed));
struct rbd_obj_snap_ondisk {
uint64_t id;
uint64_t image_size;
} __attribute__((packed));
struct rbd_obj_header_ondisk {
char text[40];
char block_name[RBD_MAX_BLOCK_NAME_SIZE];
char signature[4];
char version[8];
struct {
uint8_t order;
uint8_t crypt_type;
uint8_t comp_type;
uint8_t unused;
} __attribute__((packed)) options;
uint64_t image_size;
uint64_t snap_seq;
uint32_t snap_count;
uint32_t reserved;
uint64_t snap_names_len;
struct rbd_obj_snap_ondisk snaps[0];
} __attribute__((packed));
#endif

1
block_int.h
View File

@ -29,7 +29,6 @@
#include "qemu-queue.h"
#define BLOCK_FLAG_ENCRYPT 1
#define BLOCK_FLAG_COMPRESS 2
#define BLOCK_FLAG_COMPAT6 4
#define BLOCK_OPT_SIZE "size"

52
configure vendored
View File

@ -332,6 +332,7 @@ zero_malloc=""
trace_backend="nop"
trace_file="trace"
spice=""
rbd=""
# OS specific
if check_define __linux__ ; then
@ -741,6 +742,10 @@ for opt do
;;
--*dir)
;;
--disable-rbd) rbd="no"
;;
--enable-rbd) rbd="yes"
;;
*) echo "ERROR: unknown option $opt"; show_help="yes"
;;
esac
@ -934,6 +939,7 @@ echo " --trace-file=NAME Full PATH,NAME of file to store traces"
echo " Default:trace-<pid>"
echo " --disable-spice disable spice"
echo " --enable-spice enable spice"
echo " --enable-rbd enable building the rados block device (rbd)"
echo ""
echo "NOTE: The object files are built at the place where configure is launched"
exit 1
@ -1745,6 +1751,48 @@ if test "$mingw32" != yes -a "$pthread" = no; then
exit 1
fi
##########################################
# rbd probe
if test "$rbd" != "no" ; then
cat > $TMPC <<EOF
#include <stdio.h>
#include <rados/librados.h>
int main(void) { rados_initialize(0, NULL); return 0; }
EOF
rbd_libs="-lrados -lcrypto"
if compile_prog "" "$rbd_libs" ; then
librados_too_old=no
cat > $TMPC <<EOF
#include <stdio.h>
#include <rados/librados.h>
#ifndef CEPH_OSD_TMAP_SET
#error missing CEPH_OSD_TMAP_SET
#endif
int main(void) {
int (*func)(const rados_pool_t pool, uint64_t *snapid) = rados_selfmanaged_snap_create;
rados_initialize(0, NULL);
return 0;
}
EOF
if compile_prog "" "$rbd_libs" ; then
rbd=yes
libs_tools="$rbd_libs $libs_tools"
libs_softmmu="$rbd_libs $libs_softmmu"
else
rbd=no
librados_too_old=yes
fi
else
if test "$rbd" = "yes" ; then
feature_not_found "rados block device"
fi
rbd=no
fi
if test "$librados_too_old" = "yes" ; then
echo "-> Your librados version is too old - upgrade needed to have rbd support"
fi
fi
##########################################
# linux-aio probe
@ -2354,6 +2402,7 @@ echo "vhost-net support $vhost_net"
echo "Trace backend $trace_backend"
echo "Trace output file $trace_file-<pid>"
echo "spice support $spice"
echo "rbd support $rbd"
if test $sdl_too_old = "yes"; then
echo "-> Your SDL version is too old - please upgrade to have SDL support"
@ -2627,6 +2676,9 @@ echo "CONFIG_UNAME_RELEASE=\"$uname_release\"" >> $config_host_mak
if test "$zero_malloc" = "yes" ; then
echo "CONFIG_ZERO_MALLOC=y" >> $config_host_mak
fi
if test "$rbd" = "yes" ; then
echo "CONFIG_RBD=y" >> $config_host_mak
fi
# USB host support
case "$usb" in

247
qemu-img.c
View File

@ -188,6 +188,33 @@ static int read_password(char *buf, int buf_size)
}
#endif
static int print_block_option_help(const char *filename, const char *fmt)
{
BlockDriver *drv, *proto_drv;
QEMUOptionParameter *create_options = NULL;
/* Find driver and parse its options */
drv = bdrv_find_format(fmt);
if (!drv) {
error("Unknown file format '%s'", fmt);
return 1;
}
proto_drv = bdrv_find_protocol(filename);
if (!proto_drv) {
error("Unknown protocol '%s'", filename);
return 1;
}
create_options = append_option_parameters(create_options,
drv->create_options);
create_options = append_option_parameters(create_options,
proto_drv->create_options);
print_option_help(create_options);
free_option_parameters(create_options);
return 0;
}
static BlockDriverState *bdrv_new_open(const char *filename,
const char *fmt,
int flags)
@ -234,21 +261,9 @@ fail:
}
static int add_old_style_options(const char *fmt, QEMUOptionParameter *list,
int flags, const char *base_filename, const char *base_fmt)
const char *base_filename,
const char *base_fmt)
{
if (flags & BLOCK_FLAG_ENCRYPT) {
if (set_option_parameter(list, BLOCK_OPT_ENCRYPT, "on")) {
error("Encryption not supported for file format '%s'", fmt);
return -1;
}
}
if (flags & BLOCK_FLAG_COMPAT6) {
if (set_option_parameter(list, BLOCK_OPT_COMPAT6, "on")) {
error("VMDK version 6 not supported for file format '%s'", fmt);
return -1;
}
}
if (base_filename) {
if (set_option_parameter(list, BLOCK_OPT_BACKING_FILE, base_filename)) {
error("Backing file not supported for file format '%s'", fmt);
@ -266,21 +281,23 @@ static int add_old_style_options(const char *fmt, QEMUOptionParameter *list,
static int img_create(int argc, char **argv)
{
int c, ret = 0, flags;
int c, ret = 0;
const char *fmt = "raw";
const char *base_fmt = NULL;
const char *filename;
const char *base_filename = NULL;
BlockDriver *drv, *proto_drv;
QEMUOptionParameter *param = NULL, *create_options = NULL;
QEMUOptionParameter *backing_fmt = NULL;
char *options = NULL;
flags = 0;
for(;;) {
c = getopt(argc, argv, "F:b:f:he6o:");
if (c == -1)
if (c == -1) {
break;
}
switch(c) {
case '?':
case 'h':
help();
break;
@ -294,11 +311,13 @@ static int img_create(int argc, char **argv)
fmt = optarg;
break;
case 'e':
flags |= BLOCK_FLAG_ENCRYPT;
break;
error("qemu-img: option -e is deprecated, please use \'-o "
"encryption\' instead!");
return 1;
case '6':
flags |= BLOCK_FLAG_COMPAT6;
break;
error("qemu-img: option -6 is deprecated, please use \'-o "
"compat6\' instead!");
return 1;
case 'o':
options = optarg;
break;
@ -306,21 +325,29 @@ static int img_create(int argc, char **argv)
}
/* Get the filename */
if (optind >= argc)
if (optind >= argc) {
help();
}
filename = argv[optind++];
if (options && !strcmp(options, "?")) {
ret = print_block_option_help(filename, fmt);
goto out;
}
/* Find driver and parse its options */
drv = bdrv_find_format(fmt);
if (!drv) {
error("Unknown file format '%s'", fmt);
return 1;
ret = -1;
goto out;
}
proto_drv = bdrv_find_protocol(filename);
if (!proto_drv) {
error("Unknown protocol '%s'", filename);
return 1;
ret = -1;
goto out;
}
create_options = append_option_parameters(create_options,
@ -328,11 +355,6 @@ static int img_create(int argc, char **argv)
create_options = append_option_parameters(create_options,
proto_drv->create_options);
if (options && !strcmp(options, "?")) {
print_option_help(create_options);
goto out;
}
/* Create parameter list with default values */
param = parse_option_parameters("", create_options, param);
set_option_parameter_int(param, BLOCK_OPT_SIZE, -1);
@ -353,19 +375,27 @@ static int img_create(int argc, char **argv)
}
/* Add old-style options to parameters */
ret = add_old_style_options(fmt, param, flags, base_filename, base_fmt);
ret = add_old_style_options(fmt, param, base_filename, base_fmt);
if (ret < 0) {
goto out;
}
backing_fmt = get_option_parameter(param, BLOCK_OPT_BACKING_FMT);
if (backing_fmt && backing_fmt->value.s) {
if (!bdrv_find_format(backing_fmt->value.s)) {
error("Unknown backing file format '%s'",
backing_fmt->value.s);
ret = -1;
goto out;
}
}
// The size for the image must always be specified, with one exception:
// If we are using a backing file, we can obtain the size from there
if (get_option_parameter(param, BLOCK_OPT_SIZE)->value.n == -1) {
QEMUOptionParameter *backing_file =
get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
QEMUOptionParameter *backing_fmt =
get_option_parameter(param, BLOCK_OPT_BACKING_FMT);
if (backing_file && backing_file->value.s) {
BlockDriverState *bs;
@ -374,14 +404,7 @@ static int img_create(int argc, char **argv)
char buf[32];
if (backing_fmt && backing_fmt->value.s) {
if (bdrv_find_format(backing_fmt->value.s)) {
fmt = backing_fmt->value.s;
} else {
error("Unknown backing file format '%s'",
backing_fmt->value.s);
ret = -1;
goto out;
}
fmt = backing_fmt->value.s;
}
bs = bdrv_new_open(backing_file->value.s, fmt, BDRV_O_FLAGS);
@ -407,8 +430,6 @@ static int img_create(int argc, char **argv)
puts("");
ret = bdrv_create(drv, filename, param);
free_option_parameters(create_options);
free_option_parameters(param);
if (ret < 0) {
if (ret == -ENOTSUP) {
@ -420,6 +441,8 @@ static int img_create(int argc, char **argv)
}
}
out:
free_option_parameters(create_options);
free_option_parameters(param);
if (ret) {
return 1;
}
@ -444,9 +467,11 @@ static int img_check(int argc, char **argv)
fmt = NULL;
for(;;) {
c = getopt(argc, argv, "f:h");
if (c == -1)
if (c == -1) {
break;
}
switch(c) {
case '?':
case 'h':
help();
break;
@ -455,8 +480,9 @@ static int img_check(int argc, char **argv)
break;
}
}
if (optind >= argc)
if (optind >= argc) {
help();
}
filename = argv[optind++];
bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS);
@ -520,9 +546,11 @@ static int img_commit(int argc, char **argv)
fmt = NULL;
for(;;) {
c = getopt(argc, argv, "f:h");
if (c == -1)
if (c == -1) {
break;
}
switch(c) {
case '?':
case 'h':
help();
break;
@ -531,8 +559,9 @@ static int img_commit(int argc, char **argv)
break;
}
}
if (optind >= argc)
if (optind >= argc) {
help();
}
filename = argv[optind++];
bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR);
@ -636,7 +665,7 @@ static int compare_sectors(const uint8_t *buf1, const uint8_t *buf2, int n,
static int img_convert(int argc, char **argv)
{
int c, ret = 0, n, n1, bs_n, bs_i, flags, cluster_size, cluster_sectors;
int c, ret = 0, n, n1, bs_n, bs_i, compress, cluster_size, cluster_sectors;
const char *fmt, *out_fmt, *out_baseimg, *out_filename;
BlockDriver *drv, *proto_drv;
BlockDriverState **bs = NULL, *out_bs = NULL;
@ -653,12 +682,14 @@ static int img_convert(int argc, char **argv)
fmt = NULL;
out_fmt = "raw";
out_baseimg = NULL;
flags = 0;
compress = 0;
for(;;) {
c = getopt(argc, argv, "f:O:B:s:hce6o:");
if (c == -1)
if (c == -1) {
break;
}
switch(c) {
case '?':
case 'h':
help();
break;
@ -672,14 +703,16 @@ static int img_convert(int argc, char **argv)
out_baseimg = optarg;
break;
case 'c':
flags |= BLOCK_FLAG_COMPRESS;
compress = 1;
break;
case 'e':
flags |= BLOCK_FLAG_ENCRYPT;
break;
error("qemu-img: option -e is deprecated, please use \'-o "
"encryption\' instead!");
return 1;
case '6':
flags |= BLOCK_FLAG_COMPAT6;
break;
error("qemu-img: option -6 is deprecated, please use \'-o "
"compat6\' instead!");
return 1;
case 'o':
options = optarg;
break;
@ -690,20 +723,24 @@ static int img_convert(int argc, char **argv)
}
bs_n = argc - optind - 1;
if (bs_n < 1) help();
if (bs_n < 1) {
help();
}
out_filename = argv[argc - 1];
if (options && !strcmp(options, "?")) {
ret = print_block_option_help(out_filename, out_fmt);
goto out;
}
if (bs_n > 1 && out_baseimg) {
error("-B makes no sense when concatenating multiple input images");
return 1;
ret = -1;
goto out;
}
bs = calloc(bs_n, sizeof(BlockDriverState *));
if (!bs) {
error("Out of memory");
return 1;
}
bs = qemu_mallocz(bs_n * sizeof(BlockDriverState *));
total_sectors = 0;
for (bs_i = 0; bs_i < bs_n; bs_i++) {
@ -749,10 +786,6 @@ static int img_convert(int argc, char **argv)
drv->create_options);
create_options = append_option_parameters(create_options,
proto_drv->create_options);
if (options && !strcmp(options, "?")) {
print_option_help(create_options);
goto out;
}
if (options) {
param = parse_option_parameters(options, create_options, param);
@ -766,7 +799,7 @@ static int img_convert(int argc, char **argv)
}
set_option_parameter_int(param, BLOCK_OPT_SIZE, total_sectors * 512);
ret = add_old_style_options(out_fmt, param, flags, out_baseimg, NULL);
ret = add_old_style_options(out_fmt, param, out_baseimg, NULL);
if (ret < 0) {
goto out;
}
@ -778,7 +811,7 @@ static int img_convert(int argc, char **argv)
}
/* Check if compression is supported */
if (flags & BLOCK_FLAG_COMPRESS) {
if (compress) {
QEMUOptionParameter *encryption =
get_option_parameter(param, BLOCK_OPT_ENCRYPT);
@ -820,7 +853,7 @@ static int img_convert(int argc, char **argv)
bdrv_get_geometry(bs[0], &bs_sectors);
buf = qemu_malloc(IO_BUF_SIZE);
if (flags & BLOCK_FLAG_COMPRESS) {
if (compress) {
ret = bdrv_get_info(out_bs, &bdi);
if (ret < 0) {
error("could not get block driver info");
@ -880,8 +913,9 @@ static int img_convert(int argc, char **argv)
}
assert (remainder == 0);
if (n < cluster_sectors)
if (n < cluster_sectors) {
memset(buf + n * 512, 0, cluster_size - n * 512);
}
if (is_not_zero(buf, cluster_size)) {
ret = bdrv_write_compressed(out_bs, sector_num, buf,
cluster_sectors);
@ -901,12 +935,14 @@ static int img_convert(int argc, char **argv)
sector_num = 0; // total number of sectors converted so far
for(;;) {
nb_sectors = total_sectors - sector_num;
if (nb_sectors <= 0)
if (nb_sectors <= 0) {
break;
if (nb_sectors >= (IO_BUF_SIZE / 512))
}
if (nb_sectors >= (IO_BUF_SIZE / 512)) {
n = (IO_BUF_SIZE / 512);
else
} else {
n = nb_sectors;
}
while (sector_num - bs_offset >= bs_sectors) {
bs_i ++;
@ -918,8 +954,9 @@ static int img_convert(int argc, char **argv)
sector_num, bs_i, bs_offset, bs_sectors); */
}
if (n > bs_offset + bs_sectors - sector_num)
if (n > bs_offset + bs_sectors - sector_num) {
n = bs_offset + bs_sectors - sector_num;
}
if (has_zero_init) {
/* If the output image is being created as a copy on write image,
@ -978,12 +1015,14 @@ out:
if (out_bs) {
bdrv_delete(out_bs);
}
for (bs_i = 0; bs_i < bs_n; bs_i++) {
if (bs[bs_i]) {
bdrv_delete(bs[bs_i]);
if (bs) {
for (bs_i = 0; bs_i < bs_n; bs_i++) {
if (bs[bs_i]) {
bdrv_delete(bs[bs_i]);
}
}
qemu_free(bs);
}
free(bs);
if (ret) {
return 1;
}
@ -1053,9 +1092,11 @@ static int img_info(int argc, char **argv)
fmt = NULL;
for(;;) {
c = getopt(argc, argv, "f:h");
if (c == -1)
if (c == -1) {
break;
}
switch(c) {
case '?':
case 'h':
help();
break;
@ -1064,8 +1105,9 @@ static int img_info(int argc, char **argv)
break;
}
}
if (optind >= argc)
if (optind >= argc) {
help();
}
filename = argv[optind++];
bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_NO_BACKING);
@ -1076,11 +1118,12 @@ static int img_info(int argc, char **argv)
bdrv_get_geometry(bs, &total_sectors);
get_human_readable_size(size_buf, sizeof(size_buf), total_sectors * 512);
allocated_size = get_allocated_file_size(filename);
if (allocated_size < 0)
if (allocated_size < 0) {
snprintf(dsize_buf, sizeof(dsize_buf), "unavailable");
else
} else {
get_human_readable_size(dsize_buf, sizeof(dsize_buf),
allocated_size);
}
printf("image: %s\n"
"file format: %s\n"
"virtual size: %s (%" PRId64 " bytes)\n"
@ -1088,11 +1131,13 @@ static int img_info(int argc, char **argv)
filename, fmt_name, size_buf,
(total_sectors * 512),
dsize_buf);
if (bdrv_is_encrypted(bs))
if (bdrv_is_encrypted(bs)) {
printf("encrypted: yes\n");
}
if (bdrv_get_info(bs, &bdi) >= 0) {
if (bdi.cluster_size != 0)
if (bdi.cluster_size != 0) {
printf("cluster_size: %d\n", bdi.cluster_size);
}
}
bdrv_get_backing_filename(bs, backing_filename, sizeof(backing_filename));
if (backing_filename[0] != '\0') {
@ -1125,9 +1170,11 @@ static int img_snapshot(int argc, char **argv)
/* Parse commandline parameters */
for(;;) {
c = getopt(argc, argv, "la:c:d:h");
if (c == -1)
if (c == -1) {
break;
}
switch(c) {
case '?':
case 'h':
help();
return 0;
@ -1166,8 +1213,9 @@ static int img_snapshot(int argc, char **argv)
}
}
if (optind >= argc)
if (optind >= argc) {
help();
}
filename = argv[optind++];
/* Open the image */
@ -1191,23 +1239,26 @@ static int img_snapshot(int argc, char **argv)
sn.date_nsec = tv.tv_usec * 1000;
ret = bdrv_snapshot_create(bs, &sn);
if (ret)
if (ret) {
error("Could not create snapshot '%s': %d (%s)",
snapshot_name, ret, strerror(-ret));
}
break;
case SNAPSHOT_APPLY:
ret = bdrv_snapshot_goto(bs, snapshot_name);
if (ret)
if (ret) {
error("Could not apply snapshot '%s': %d (%s)",
snapshot_name, ret, strerror(-ret));
}
break;
case SNAPSHOT_DELETE:
ret = bdrv_snapshot_delete(bs, snapshot_name);
if (ret)
if (ret) {
error("Could not delete snapshot '%s': %d (%s)",
snapshot_name, ret, strerror(-ret));
}
break;
}
@ -1235,9 +1286,11 @@ static int img_rebase(int argc, char **argv)
for(;;) {
c = getopt(argc, argv, "uhf:F:b:");
if (c == -1)
if (c == -1) {
break;
}
switch(c) {
case '?':
case 'h':
help();
return 0;
@ -1256,8 +1309,9 @@ static int img_rebase(int argc, char **argv)
}
}
if ((optind >= argc) || !out_baseimg)
if ((optind >= argc) || !out_baseimg) {
help();
}
filename = argv[optind++];
/*
@ -1433,7 +1487,7 @@ static int img_resize(int argc, char **argv)
int c, ret, relative;
const char *filename, *fmt, *size;
int64_t n, total_size;
BlockDriverState *bs;
BlockDriverState *bs = NULL;
QEMUOptionParameter *param;
QEMUOptionParameter resize_options[] = {
{
@ -1451,6 +1505,7 @@ static int img_resize(int argc, char **argv)
break;
}
switch(c) {
case '?':
case 'h':
help();
break;
@ -1484,14 +1539,16 @@ static int img_resize(int argc, char **argv)
param = parse_option_parameters("", resize_options, NULL);
if (set_option_parameter(param, BLOCK_OPT_SIZE, size)) {
/* Error message already printed when size parsing fails */
exit(1);
ret = -1;
goto out;
}
n = get_option_parameter(param, BLOCK_OPT_SIZE)->value.n;
free_option_parameters(param);
bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR);
if (!bs) {
return 1;
ret = -1;
goto out;
}
if (relative) {
@ -1521,7 +1578,9 @@ static int img_resize(int argc, char **argv)
break;
}
out:
bdrv_delete(bs);
if (bs) {
bdrv_delete(bs);
}
if (ret) {
return 1;
}

5
qemu-malloc.c
View File

@ -64,10 +64,13 @@ void *qemu_realloc(void *ptr, size_t size)
void *qemu_mallocz(size_t size)
{
void *ptr;
if (!size && !allow_zero_malloc()) {
abort();
}
return qemu_oom_check(calloc(1, size ? size : 1));
ptr = qemu_oom_check(calloc(1, size ? size : 1));
trace_qemu_malloc(size, ptr);
return ptr;
}
char *qemu_strdup(const char *str)

13
qemu-option.c
View File

@ -394,8 +394,8 @@ QEMUOptionParameter *append_option_parameters(QEMUOptionParameter *dest,
/*
* Parses a parameter string (param) into an option list (dest).
*
* list is the templace is. If dest is NULL, a new copy of list is created for
* it. If list is NULL, this function fails.
* list is the template option list. If dest is NULL, a new copy of list is
* created. If list is NULL, this function fails.
*
* A parameter string consists of one or more parameters, separated by commas.
* Each parameter consists of its name and possibly of a value. In the latter
@ -416,20 +416,13 @@ QEMUOptionParameter *parse_option_parameters(const char *param,
char value[256];
char *param_delim, *value_delim;
char next_delim;
size_t num_options;
if (list == NULL) {
return NULL;
}
if (dest == NULL) {
// Count valid options
num_options = count_option_parameters(list);
// Create a copy of the option list to fill in values
dest = qemu_mallocz((num_options + 1) * sizeof(QEMUOptionParameter));
allocated = dest;
memcpy(dest, list, (num_options + 1) * sizeof(QEMUOptionParameter));
dest = allocated = append_option_parameters(NULL, list);
}
while (*param) {