Commit 0e7e1989f7fced8e39f140e1958f0557b60d4532

Authored by Kevin Wolf
Committed by Anthony Liguori
1 parent d3f24367

Convert all block drivers to new bdrv_create

Now we can make use of the newly introduced option structures. Instead of
having bdrv_create carry more and more parameters (which are format specific in
most cases), just pass a option structure as defined by the driver itself.

bdrv_create2() contains an emulation of the old interface to simplify the
transition.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
@@ -189,22 +189,44 @@ int bdrv_create2(BlockDriver *drv, @@ -189,22 +189,44 @@ int bdrv_create2(BlockDriver *drv,
189 const char *backing_file, const char *backing_format, 189 const char *backing_file, const char *backing_format,
190 int flags) 190 int flags)
191 { 191 {
192 - if (drv->bdrv_create2)  
193 - return drv->bdrv_create2(filename, size_in_sectors, backing_file,  
194 - backing_format, flags);  
195 - if (drv->bdrv_create)  
196 - return drv->bdrv_create(filename, size_in_sectors, backing_file,  
197 - flags);  
198 - return -ENOTSUP; 192 + QEMUOptionParameter *options;
  193 +
  194 + options = parse_option_parameters("", drv->create_options, NULL);
  195 +
  196 + // Process flags
  197 + if (flags & ~(BLOCK_FLAG_ENCRYPT | BLOCK_FLAG_COMPAT6 | BLOCK_FLAG_COMPRESS)) {
  198 + return -ENOTSUP;
  199 + }
  200 +
  201 + if (flags & BLOCK_FLAG_ENCRYPT) {
  202 + set_option_parameter_int(options, BLOCK_OPT_ENCRYPT, 1);
  203 + }
  204 + if (flags & BLOCK_FLAG_COMPAT6) {
  205 + set_option_parameter_int(options, BLOCK_OPT_COMPAT6, 1);
  206 + }
  207 +
  208 + // Add size to options
  209 + set_option_parameter_int(options, BLOCK_OPT_SIZE, size_in_sectors * 512);
  210 +
  211 + // Backing files
  212 + if ((backing_file != NULL && set_option_parameter(options,
  213 + BLOCK_OPT_BACKING_FILE, backing_file))
  214 + || (backing_format != NULL && set_option_parameter(options,
  215 + BLOCK_OPT_BACKING_FMT, backing_format)))
  216 + {
  217 + return -ENOTSUP;
  218 + }
  219 +
  220 + return bdrv_create(drv, filename, options);
199 } 221 }
200 222
201 -int bdrv_create(BlockDriver *drv,  
202 - const char *filename, int64_t size_in_sectors,  
203 - const char *backing_file, int flags) 223 +int bdrv_create(BlockDriver *drv, const char* filename,
  224 + QEMUOptionParameter *options)
204 { 225 {
205 if (!drv->bdrv_create) 226 if (!drv->bdrv_create)
206 return -ENOTSUP; 227 return -ENOTSUP;
207 - return drv->bdrv_create(filename, size_in_sectors, backing_file, flags); 228 +
  229 + return drv->bdrv_create(filename, options);
208 } 230 }
209 231
210 #ifdef _WIN32 232 #ifdef _WIN32
@@ -3,6 +3,7 @@ @@ -3,6 +3,7 @@
3 3
4 #include "qemu-aio.h" 4 #include "qemu-aio.h"
5 #include "qemu-common.h" 5 #include "qemu-common.h"
  6 +#include "qemu-option.h"
6 7
7 /* block.c */ 8 /* block.c */
8 typedef struct BlockDriver BlockDriver; 9 typedef struct BlockDriver BlockDriver;
@@ -45,9 +46,8 @@ void bdrv_info_stats(Monitor *mon); @@ -45,9 +46,8 @@ void bdrv_info_stats(Monitor *mon);
45 46
46 void bdrv_init(void); 47 void bdrv_init(void);
47 BlockDriver *bdrv_find_format(const char *format_name); 48 BlockDriver *bdrv_find_format(const char *format_name);
48 -int bdrv_create(BlockDriver *drv,  
49 - const char *filename, int64_t size_in_sectors,  
50 - const char *backing_file, int flags); 49 +int bdrv_create(BlockDriver *drv, const char* filename,
  50 + QEMUOptionParameter *options);
51 int bdrv_create2(BlockDriver *drv, 51 int bdrv_create2(BlockDriver *drv,
52 const char *filename, int64_t size_in_sectors, 52 const char *filename, int64_t size_in_sectors,
53 const char *backing_file, const char *backing_format, 53 const char *backing_file, const char *backing_format,
block/cow.c
@@ -202,15 +202,23 @@ static void cow_close(BlockDriverState *bs) @@ -202,15 +202,23 @@ static void cow_close(BlockDriverState *bs)
202 close(s->fd); 202 close(s->fd);
203 } 203 }
204 204
205 -static int cow_create(const char *filename, int64_t image_sectors,  
206 - const char *image_filename, int flags) 205 +static int cow_create(const char *filename, QEMUOptionParameter *options)
207 { 206 {
208 int fd, cow_fd; 207 int fd, cow_fd;
209 struct cow_header_v2 cow_header; 208 struct cow_header_v2 cow_header;
210 struct stat st; 209 struct stat st;
211 -  
212 - if (flags)  
213 - return -ENOTSUP; 210 + int64_t image_sectors = 0;
  211 + const char *image_filename = NULL;
  212 +
  213 + /* Read out options */
  214 + while (options && options->name) {
  215 + if (!strcmp(options->name, BLOCK_OPT_SIZE)) {
  216 + image_sectors = options->value.n / 512;
  217 + } else if (!strcmp(options->name, BLOCK_OPT_BACKING_FILE)) {
  218 + image_filename = options->value.s;
  219 + }
  220 + options++;
  221 + }
214 222
215 cow_fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 223 cow_fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY,
216 0644); 224 0644);
@@ -253,6 +261,12 @@ static void cow_flush(BlockDriverState *bs) @@ -253,6 +261,12 @@ static void cow_flush(BlockDriverState *bs)
253 fsync(s->fd); 261 fsync(s->fd);
254 } 262 }
255 263
  264 +static QEMUOptionParameter cow_create_options[] = {
  265 + { BLOCK_OPT_SIZE, OPT_SIZE },
  266 + { BLOCK_OPT_BACKING_FILE, OPT_STRING },
  267 + { NULL }
  268 +};
  269 +
256 static BlockDriver bdrv_cow = { 270 static BlockDriver bdrv_cow = {
257 .format_name = "cow", 271 .format_name = "cow",
258 .instance_size = sizeof(BDRVCowState), 272 .instance_size = sizeof(BDRVCowState),
@@ -264,6 +278,8 @@ static BlockDriver bdrv_cow = { @@ -264,6 +278,8 @@ static BlockDriver bdrv_cow = {
264 .bdrv_create = cow_create, 278 .bdrv_create = cow_create,
265 .bdrv_flush = cow_flush, 279 .bdrv_flush = cow_flush,
266 .bdrv_is_allocated = cow_is_allocated, 280 .bdrv_is_allocated = cow_is_allocated,
  281 +
  282 + .create_options = cow_create_options,
267 }; 283 };
268 284
269 static void bdrv_cow_init(void) 285 static void bdrv_cow_init(void)
block/qcow.c
@@ -767,12 +767,26 @@ static void qcow_close(BlockDriverState *bs) @@ -767,12 +767,26 @@ static void qcow_close(BlockDriverState *bs)
767 bdrv_delete(s->hd); 767 bdrv_delete(s->hd);
768 } 768 }
769 769
770 -static int qcow_create(const char *filename, int64_t total_size,  
771 - const char *backing_file, int flags) 770 +static int qcow_create(const char *filename, QEMUOptionParameter *options)
772 { 771 {
773 int fd, header_size, backing_filename_len, l1_size, i, shift; 772 int fd, header_size, backing_filename_len, l1_size, i, shift;
774 QCowHeader header; 773 QCowHeader header;
775 uint64_t tmp; 774 uint64_t tmp;
  775 + int64_t total_size = 0;
  776 + const char *backing_file = NULL;
  777 + int flags = 0;
  778 +
  779 + /* Read out options */
  780 + while (options && options->name) {
  781 + if (!strcmp(options->name, BLOCK_OPT_SIZE)) {
  782 + total_size = options->value.n / 512;
  783 + } else if (!strcmp(options->name, BLOCK_OPT_BACKING_FILE)) {
  784 + backing_file = options->value.s;
  785 + } else if (!strcmp(options->name, BLOCK_OPT_ENCRYPT)) {
  786 + flags |= options->value.n ? BLOCK_FLAG_ENCRYPT : 0;
  787 + }
  788 + options++;
  789 + }
776 790
777 fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0644); 791 fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0644);
778 if (fd < 0) 792 if (fd < 0)
@@ -918,6 +932,14 @@ static int qcow_get_info(BlockDriverState *bs, BlockDriverInfo *bdi) @@ -918,6 +932,14 @@ static int qcow_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
918 return 0; 932 return 0;
919 } 933 }
920 934
  935 +
  936 +static QEMUOptionParameter qcow_create_options[] = {
  937 + { BLOCK_OPT_SIZE, OPT_SIZE },
  938 + { BLOCK_OPT_BACKING_FILE, OPT_STRING },
  939 + { BLOCK_OPT_ENCRYPT, OPT_FLAG },
  940 + { NULL }
  941 +};
  942 +
921 static BlockDriver bdrv_qcow = { 943 static BlockDriver bdrv_qcow = {
922 .format_name = "qcow", 944 .format_name = "qcow",
923 .instance_size = sizeof(BDRVQcowState), 945 .instance_size = sizeof(BDRVQcowState),
@@ -935,6 +957,8 @@ static BlockDriver bdrv_qcow = { @@ -935,6 +957,8 @@ static BlockDriver bdrv_qcow = {
935 .aiocb_size = sizeof(QCowAIOCB), 957 .aiocb_size = sizeof(QCowAIOCB),
936 .bdrv_write_compressed = qcow_write_compressed, 958 .bdrv_write_compressed = qcow_write_compressed,
937 .bdrv_get_info = qcow_get_info, 959 .bdrv_get_info = qcow_get_info,
  960 +
  961 + .create_options = qcow_create_options,
938 }; 962 };
939 963
940 static void bdrv_qcow_init(void) 964 static void bdrv_qcow_init(void)
block/qcow2.c
@@ -1696,10 +1696,28 @@ static int qcow_create2(const char *filename, int64_t total_size, @@ -1696,10 +1696,28 @@ static int qcow_create2(const char *filename, int64_t total_size,
1696 return 0; 1696 return 0;
1697 } 1697 }
1698 1698
1699 -static int qcow_create(const char *filename, int64_t total_size,  
1700 - const char *backing_file, int flags)  
1701 -{  
1702 - return qcow_create2(filename, total_size, backing_file, NULL, flags); 1699 +static int qcow_create(const char *filename, QEMUOptionParameter *options)
  1700 +{
  1701 + const char *backing_file = NULL;
  1702 + const char *backing_fmt = NULL;
  1703 + uint64_t sectors = 0;
  1704 + int flags = 0;
  1705 +
  1706 + /* Read out options */
  1707 + while (options && options->name) {
  1708 + if (!strcmp(options->name, BLOCK_OPT_SIZE)) {
  1709 + sectors = options->value.n / 512;
  1710 + } else if (!strcmp(options->name, BLOCK_OPT_BACKING_FILE)) {
  1711 + backing_file = options->value.s;
  1712 + } else if (!strcmp(options->name, BLOCK_OPT_BACKING_FMT)) {
  1713 + backing_fmt = options->value.s;
  1714 + } else if (!strcmp(options->name, BLOCK_OPT_ENCRYPT)) {
  1715 + flags |= options->value.n ? BLOCK_FLAG_ENCRYPT : 0;
  1716 + }
  1717 + options++;
  1718 + }
  1719 +
  1720 + return qcow_create2(filename, sectors, backing_file, backing_fmt, flags);
1703 } 1721 }
1704 1722
1705 static int qcow_make_empty(BlockDriverState *bs) 1723 static int qcow_make_empty(BlockDriverState *bs)
@@ -2897,6 +2915,14 @@ static int qcow_get_buffer(BlockDriverState *bs, uint8_t *buf, @@ -2897,6 +2915,14 @@ static int qcow_get_buffer(BlockDriverState *bs, uint8_t *buf,
2897 return ret; 2915 return ret;
2898 } 2916 }
2899 2917
  2918 +static QEMUOptionParameter qcow_create_options[] = {
  2919 + { BLOCK_OPT_SIZE, OPT_SIZE },
  2920 + { BLOCK_OPT_BACKING_FILE, OPT_STRING },
  2921 + { BLOCK_OPT_BACKING_FMT, OPT_STRING },
  2922 + { BLOCK_OPT_ENCRYPT, OPT_FLAG },
  2923 + { NULL }
  2924 +};
  2925 +
2900 static BlockDriver bdrv_qcow2 = { 2926 static BlockDriver bdrv_qcow2 = {
2901 .format_name = "qcow2", 2927 .format_name = "qcow2",
2902 .instance_size = sizeof(BDRVQcowState), 2928 .instance_size = sizeof(BDRVQcowState),
@@ -2924,7 +2950,7 @@ static BlockDriver bdrv_qcow2 = { @@ -2924,7 +2950,7 @@ static BlockDriver bdrv_qcow2 = {
2924 .bdrv_put_buffer = qcow_put_buffer, 2950 .bdrv_put_buffer = qcow_put_buffer,
2925 .bdrv_get_buffer = qcow_get_buffer, 2951 .bdrv_get_buffer = qcow_get_buffer,
2926 2952
2927 - .bdrv_create2 = qcow_create2, 2953 + .create_options = qcow_create_options,
2928 .bdrv_check = qcow_check, 2954 .bdrv_check = qcow_check,
2929 }; 2955 };
2930 2956
block/raw-posix.c
@@ -823,13 +823,18 @@ again: @@ -823,13 +823,18 @@ again:
823 } 823 }
824 #endif 824 #endif
825 825
826 -static int raw_create(const char *filename, int64_t total_size,  
827 - const char *backing_file, int flags) 826 +static int raw_create(const char *filename, QEMUOptionParameter *options)
828 { 827 {
829 int fd; 828 int fd;
  829 + int64_t total_size = 0;
830 830
831 - if (flags || backing_file)  
832 - return -ENOTSUP; 831 + /* Read out options */
  832 + while (options && options->name) {
  833 + if (!strcmp(options->name, BLOCK_OPT_SIZE)) {
  834 + total_size = options->value.n / 512;
  835 + }
  836 + options++;
  837 + }
833 838
834 fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 839 fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY,
835 0644); 840 0644);
@@ -846,6 +851,12 @@ static void raw_flush(BlockDriverState *bs) @@ -846,6 +851,12 @@ static void raw_flush(BlockDriverState *bs)
846 fsync(s->fd); 851 fsync(s->fd);
847 } 852 }
848 853
  854 +
  855 +static QEMUOptionParameter raw_create_options[] = {
  856 + { BLOCK_OPT_SIZE, OPT_SIZE },
  857 + { NULL }
  858 +};
  859 +
849 static BlockDriver bdrv_raw = { 860 static BlockDriver bdrv_raw = {
850 .format_name = "raw", 861 .format_name = "raw",
851 .instance_size = sizeof(BDRVRawState), 862 .instance_size = sizeof(BDRVRawState),
@@ -866,6 +877,8 @@ static BlockDriver bdrv_raw = { @@ -866,6 +877,8 @@ static BlockDriver bdrv_raw = {
866 877
867 .bdrv_truncate = raw_truncate, 878 .bdrv_truncate = raw_truncate,
868 .bdrv_getlength = raw_getlength, 879 .bdrv_getlength = raw_getlength,
  880 +
  881 + .create_options = raw_create_options,
869 }; 882 };
870 883
871 /***********************************************/ 884 /***********************************************/
@@ -1364,15 +1377,20 @@ static BlockDriverAIOCB *raw_aio_ioctl(BlockDriverState *bs, @@ -1364,15 +1377,20 @@ static BlockDriverAIOCB *raw_aio_ioctl(BlockDriverState *bs,
1364 #endif /* !linux && !FreeBSD */ 1377 #endif /* !linux && !FreeBSD */
1365 1378
1366 #if defined(__linux__) || defined(__FreeBSD__) 1379 #if defined(__linux__) || defined(__FreeBSD__)
1367 -static int hdev_create(const char *filename, int64_t total_size,  
1368 - const char *backing_file, int flags) 1380 +static int hdev_create(const char *filename, QEMUOptionParameter *options)
1369 { 1381 {
1370 int fd; 1382 int fd;
1371 int ret = 0; 1383 int ret = 0;
1372 struct stat stat_buf; 1384 struct stat stat_buf;
  1385 + int64_t total_size = 0;
1373 1386
1374 - if (flags || backing_file)  
1375 - return -ENOTSUP; 1387 + /* Read out options */
  1388 + while (options && options->name) {
  1389 + if (!strcmp(options->name, "size")) {
  1390 + total_size = options->value.n / 512;
  1391 + }
  1392 + options++;
  1393 + }
1376 1394
1377 fd = open(filename, O_WRONLY | O_BINARY); 1395 fd = open(filename, O_WRONLY | O_BINARY);
1378 if (fd < 0) 1396 if (fd < 0)
@@ -1391,8 +1409,7 @@ static int hdev_create(const char *filename, int64_t total_size, @@ -1391,8 +1409,7 @@ static int hdev_create(const char *filename, int64_t total_size,
1391 1409
1392 #else /* !(linux || freebsd) */ 1410 #else /* !(linux || freebsd) */
1393 1411
1394 -static int hdev_create(const char *filename, int64_t total_size,  
1395 - const char *backing_file, int flags) 1412 +static int hdev_create(const char *filename, QEMUOptionParameter *options)
1396 { 1413 {
1397 return -ENOTSUP; 1414 return -ENOTSUP;
1398 } 1415 }
block/raw-win32.c
@@ -210,13 +210,18 @@ static int64_t raw_getlength(BlockDriverState *bs) @@ -210,13 +210,18 @@ static int64_t raw_getlength(BlockDriverState *bs)
210 return l.QuadPart; 210 return l.QuadPart;
211 } 211 }
212 212
213 -static int raw_create(const char *filename, int64_t total_size,  
214 - const char *backing_file, int flags) 213 +static int raw_create(const char *filename, QEMUOptionParameter *options)
215 { 214 {
216 int fd; 215 int fd;
  216 + int64_t total_size = 0;
217 217
218 - if (flags || backing_file)  
219 - return -ENOTSUP; 218 + /* Read out options */
  219 + while (options && options->name) {
  220 + if (!strcmp(options->name, BLOCK_OPT_SIZE)) {
  221 + total_size = options->value.n / 512;
  222 + }
  223 + options++;
  224 + }
220 225
221 fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 226 fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY,
222 0644); 227 0644);
@@ -228,6 +233,11 @@ static int raw_create(const char *filename, int64_t total_size, @@ -228,6 +233,11 @@ static int raw_create(const char *filename, int64_t total_size,
228 return 0; 233 return 0;
229 } 234 }
230 235
  236 +static QEMUOptionParameter raw_create_options[] = {
  237 + { BLOCK_OPT_SIZE, OPT_SIZE },
  238 + { NULL }
  239 +};
  240 +
231 static BlockDriver bdrv_raw = { 241 static BlockDriver bdrv_raw = {
232 .format_name = "raw", 242 .format_name = "raw",
233 .instance_size = sizeof(BDRVRawState), 243 .instance_size = sizeof(BDRVRawState),
@@ -239,6 +249,8 @@ static BlockDriver bdrv_raw = { @@ -239,6 +249,8 @@ static BlockDriver bdrv_raw = {
239 .bdrv_write = raw_write, 249 .bdrv_write = raw_write,
240 .bdrv_truncate = raw_truncate, 250 .bdrv_truncate = raw_truncate,
241 .bdrv_getlength = raw_getlength, 251 .bdrv_getlength = raw_getlength,
  252 +
  253 + .create_options = raw_create_options,
242 }; 254 };
243 255
244 /***********************************************/ 256 /***********************************************/
block/vmdk.c
@@ -687,8 +687,7 @@ static int vmdk_write(BlockDriverState *bs, int64_t sector_num, @@ -687,8 +687,7 @@ static int vmdk_write(BlockDriverState *bs, int64_t sector_num,
687 return 0; 687 return 0;
688 } 688 }
689 689
690 -static int vmdk_create(const char *filename, int64_t total_size,  
691 - const char *backing_file, int flags) 690 +static int vmdk_create(const char *filename, QEMUOptionParameter *options)
692 { 691 {
693 int fd, i; 692 int fd, i;
694 VMDK4Header header; 693 VMDK4Header header;
@@ -713,6 +712,21 @@ static int vmdk_create(const char *filename, int64_t total_size, @@ -713,6 +712,21 @@ static int vmdk_create(const char *filename, int64_t total_size,
713 "ddb.adapterType = \"ide\"\n"; 712 "ddb.adapterType = \"ide\"\n";
714 char desc[1024]; 713 char desc[1024];
715 const char *real_filename, *temp_str; 714 const char *real_filename, *temp_str;
  715 + int64_t total_size = 0;
  716 + const char *backing_file = NULL;
  717 + int flags = 0;
  718 +
  719 + // Read out options
  720 + while (options && options->name) {
  721 + if (!strcmp(options->name, BLOCK_OPT_SIZE)) {
  722 + total_size = options->value.n / 512;
  723 + } else if (!strcmp(options->name, BLOCK_OPT_BACKING_FILE)) {
  724 + backing_file = options->value.s;
  725 + } else if (!strcmp(options->name, BLOCK_OPT_COMPAT6)) {
  726 + flags |= options->value.n ? BLOCK_FLAG_COMPAT6: 0;
  727 + }
  728 + options++;
  729 + }
716 730
717 /* XXX: add support for backing file */ 731 /* XXX: add support for backing file */
718 if (backing_file) { 732 if (backing_file) {
@@ -812,6 +826,14 @@ static void vmdk_flush(BlockDriverState *bs) @@ -812,6 +826,14 @@ static void vmdk_flush(BlockDriverState *bs)
812 bdrv_flush(s->hd); 826 bdrv_flush(s->hd);
813 } 827 }
814 828
  829 +
  830 +static QEMUOptionParameter vmdk_create_options[] = {
  831 + { BLOCK_OPT_SIZE, OPT_SIZE },
  832 + { BLOCK_OPT_BACKING_FILE, OPT_STRING },
  833 + { BLOCK_OPT_COMPAT6, OPT_FLAG },
  834 + { NULL }
  835 +};
  836 +
815 static BlockDriver bdrv_vmdk = { 837 static BlockDriver bdrv_vmdk = {
816 .format_name = "vmdk", 838 .format_name = "vmdk",
817 .instance_size = sizeof(BDRVVmdkState), 839 .instance_size = sizeof(BDRVVmdkState),
@@ -823,6 +845,8 @@ static BlockDriver bdrv_vmdk = { @@ -823,6 +845,8 @@ static BlockDriver bdrv_vmdk = {
823 .bdrv_create = vmdk_create, 845 .bdrv_create = vmdk_create,
824 .bdrv_flush = vmdk_flush, 846 .bdrv_flush = vmdk_flush,
825 .bdrv_is_allocated = vmdk_is_allocated, 847 .bdrv_is_allocated = vmdk_is_allocated,
  848 +
  849 + .create_options = vmdk_create_options,
826 }; 850 };
827 851
828 static void bdrv_vmdk_init(void) 852 static void bdrv_vmdk_init(void)
block/vpc.c
@@ -477,8 +477,7 @@ static int calculate_geometry(int64_t total_sectors, uint16_t* cyls, @@ -477,8 +477,7 @@ static int calculate_geometry(int64_t total_sectors, uint16_t* cyls,
477 return 0; 477 return 0;
478 } 478 }
479 479
480 -static int vpc_create(const char *filename, int64_t total_sectors,  
481 - const char *backing_file, int flags) 480 +static int vpc_create(const char *filename, QEMUOptionParameter *options)
482 { 481 {
483 uint8_t buf[1024]; 482 uint8_t buf[1024];
484 struct vhd_footer* footer = (struct vhd_footer*) buf; 483 struct vhd_footer* footer = (struct vhd_footer*) buf;
@@ -489,10 +488,17 @@ static int vpc_create(const char *filename, int64_t total_sectors, @@ -489,10 +488,17 @@ static int vpc_create(const char *filename, int64_t total_sectors,
489 uint8_t heads; 488 uint8_t heads;
490 uint8_t secs_per_cyl; 489 uint8_t secs_per_cyl;
491 size_t block_size, num_bat_entries; 490 size_t block_size, num_bat_entries;
  491 + int64_t total_sectors = 0;
492 492
493 - if (backing_file != NULL)  
494 - return -ENOTSUP; 493 + // Read out options
  494 + while (options && options->name) {
  495 + if (!strcmp(options->name, "size")) {
  496 + total_sectors = options->value.n / 512;
  497 + }
  498 + options++;
  499 + }
495 500
  501 + // Create the file
496 fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0644); 502 fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0644);
497 if (fd < 0) 503 if (fd < 0)
498 return -EIO; 504 return -EIO;
@@ -587,6 +593,11 @@ static void vpc_close(BlockDriverState *bs) @@ -587,6 +593,11 @@ static void vpc_close(BlockDriverState *bs)
587 bdrv_delete(s->hd); 593 bdrv_delete(s->hd);
588 } 594 }
589 595
  596 +static QEMUOptionParameter vpc_create_options[] = {
  597 + { "size", OPT_SIZE },
  598 + { NULL }
  599 +};
  600 +
590 static BlockDriver bdrv_vpc = { 601 static BlockDriver bdrv_vpc = {
591 .format_name = "vpc", 602 .format_name = "vpc",
592 .instance_size = sizeof(BDRVVPCState), 603 .instance_size = sizeof(BDRVVPCState),
@@ -596,6 +607,8 @@ static BlockDriver bdrv_vpc = { @@ -596,6 +607,8 @@ static BlockDriver bdrv_vpc = {
596 .bdrv_write = vpc_write, 607 .bdrv_write = vpc_write,
597 .bdrv_close = vpc_close, 608 .bdrv_close = vpc_close,
598 .bdrv_create = vpc_create, 609 .bdrv_create = vpc_create,
  610 +
  611 + .create_options = vpc_create_options,
599 }; 612 };
600 613
601 static void bdrv_vpc_init(void) 614 static void bdrv_vpc_init(void)
block/vvfat.c
@@ -2777,8 +2777,8 @@ static int enable_write_target(BDRVVVFATState *s) @@ -2777,8 +2777,8 @@ static int enable_write_target(BDRVVVFATState *s)
2777 2777
2778 s->qcow_filename = qemu_malloc(1024); 2778 s->qcow_filename = qemu_malloc(1024);
2779 get_tmp_filename(s->qcow_filename, 1024); 2779 get_tmp_filename(s->qcow_filename, 1024);
2780 - if (bdrv_create(bdrv_find_format("qcow"),  
2781 - s->qcow_filename, s->sector_count, "fat:", 0) < 0) 2780 + if (bdrv_create2(bdrv_find_format("qcow"),
  2781 + s->qcow_filename, s->sector_count, "fat:", NULL, 0) < 0)
2782 return -1; 2782 return -1;
2783 s->qcow = bdrv_new(""); 2783 s->qcow = bdrv_new("");
2784 if (s->qcow == NULL || bdrv_open(s->qcow, s->qcow_filename, 0) < 0) 2784 if (s->qcow == NULL || bdrv_open(s->qcow, s->qcow_filename, 0) < 0)
block_int.h
@@ -25,11 +25,18 @@ @@ -25,11 +25,18 @@
25 #define BLOCK_INT_H 25 #define BLOCK_INT_H
26 26
27 #include "block.h" 27 #include "block.h"
  28 +#include "qemu-option.h"
28 29
29 #define BLOCK_FLAG_ENCRYPT 1 30 #define BLOCK_FLAG_ENCRYPT 1
30 #define BLOCK_FLAG_COMPRESS 2 31 #define BLOCK_FLAG_COMPRESS 2
31 #define BLOCK_FLAG_COMPAT6 4 32 #define BLOCK_FLAG_COMPAT6 4
32 33
  34 +#define BLOCK_OPT_SIZE "size"
  35 +#define BLOCK_OPT_ENCRYPT "encryption"
  36 +#define BLOCK_OPT_COMPAT6 "compat6"
  37 +#define BLOCK_OPT_BACKING_FILE "backing_file"
  38 +#define BLOCK_OPT_BACKING_FMT "backing_fmt"
  39 +
33 typedef struct AIOPool { 40 typedef struct AIOPool {
34 void (*cancel)(BlockDriverAIOCB *acb); 41 void (*cancel)(BlockDriverAIOCB *acb);
35 int aiocb_size; 42 int aiocb_size;
@@ -46,8 +53,7 @@ struct BlockDriver { @@ -46,8 +53,7 @@ struct BlockDriver {
46 int (*bdrv_write)(BlockDriverState *bs, int64_t sector_num, 53 int (*bdrv_write)(BlockDriverState *bs, int64_t sector_num,
47 const uint8_t *buf, int nb_sectors); 54 const uint8_t *buf, int nb_sectors);
48 void (*bdrv_close)(BlockDriverState *bs); 55 void (*bdrv_close)(BlockDriverState *bs);
49 - int (*bdrv_create)(const char *filename, int64_t total_sectors,  
50 - const char *backing_file, int flags); 56 + int (*bdrv_create)(const char *filename, QEMUOptionParameter *options);
51 void (*bdrv_flush)(BlockDriverState *bs); 57 void (*bdrv_flush)(BlockDriverState *bs);
52 int (*bdrv_is_allocated)(BlockDriverState *bs, int64_t sector_num, 58 int (*bdrv_is_allocated)(BlockDriverState *bs, int64_t sector_num,
53 int nb_sectors, int *pnum); 59 int nb_sectors, int *pnum);
@@ -97,10 +103,9 @@ struct BlockDriver { @@ -97,10 +103,9 @@ struct BlockDriver {
97 103
98 AIOPool aio_pool; 104 AIOPool aio_pool;
99 105
100 - /* new create with backing file format */  
101 - int (*bdrv_create2)(const char *filename, int64_t total_sectors,  
102 - const char *backing_file, const char *backing_format,  
103 - int flags); 106 + /* List of options for creating images, terminated by name == NULL */
  107 + QEMUOptionParameter *create_options;
  108 +
104 109
105 /* Returns number of errors in image, -errno for internal errors */ 110 /* Returns number of errors in image, -errno for internal errors */
106 int (*bdrv_check)(BlockDriverState* bs); 111 int (*bdrv_check)(BlockDriverState* bs);
qemu-img.c
@@ -551,7 +551,7 @@ static int img_convert(int argc, char **argv) @@ -551,7 +551,7 @@ static int img_convert(int argc, char **argv)
551 if (flags & BLOCK_FLAG_ENCRYPT && flags & BLOCK_FLAG_COMPRESS) 551 if (flags & BLOCK_FLAG_ENCRYPT && flags & BLOCK_FLAG_COMPRESS)
552 error("Compression and encryption not supported at the same time"); 552 error("Compression and encryption not supported at the same time");
553 553
554 - ret = bdrv_create(drv, out_filename, total_sectors, out_baseimg, flags); 554 + ret = bdrv_create2(drv, out_filename, total_sectors, out_baseimg, NULL, flags);
555 if (ret < 0) { 555 if (ret < 0) {
556 if (ret == -ENOTSUP) { 556 if (ret == -ENOTSUP) {
557 error("Formatting not supported for file format '%s'", out_fmt); 557 error("Formatting not supported for file format '%s'", out_fmt);