Commit e60f469ca80e0b39b7cf85aef0d3b1ff32a67cba

Authored by aurel32
1 parent aaedd1f9

Use C99 initializers for BlockDriver methods

Consistently use the C99 named initializer format for the BlockDriver
methods to make the method table more readable and more easily
extensible.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Aurelien Jarno <aurelien@aurel32.net>

git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6768 c046a42c-6fe2-441c-8c8c-71466251a162
block-bochs.c
@@ -242,11 +242,10 @@ static void bochs_close(BlockDriverState *bs) @@ -242,11 +242,10 @@ static void bochs_close(BlockDriverState *bs)
242 } 242 }
243 243
244 BlockDriver bdrv_bochs = { 244 BlockDriver bdrv_bochs = {
245 - "bochs",  
246 - sizeof(BDRVBochsState),  
247 - bochs_probe,  
248 - bochs_open,  
249 - bochs_read,  
250 - NULL,  
251 - bochs_close, 245 + .format_name = "bochs",
  246 + .instance_size = sizeof(BDRVBochsState),
  247 + .bdrv_probe = bochs_probe,
  248 + .bdrv_open = bochs_open,
  249 + .bdrv_read = bochs_read,
  250 + .bdrv_close = bochs_close,
252 }; 251 };
block-cloop.c
@@ -154,11 +154,10 @@ static void cloop_close(BlockDriverState *bs) @@ -154,11 +154,10 @@ static void cloop_close(BlockDriverState *bs)
154 } 154 }
155 155
156 BlockDriver bdrv_cloop = { 156 BlockDriver bdrv_cloop = {
157 - "cloop",  
158 - sizeof(BDRVCloopState),  
159 - cloop_probe,  
160 - cloop_open,  
161 - cloop_read,  
162 - NULL,  
163 - cloop_close, 157 + .format_name = "cloop",
  158 + .instance_size = sizeof(BDRVCloopState),
  159 + .bdrv_probe = cloop_probe,
  160 + .bdrv_open = cloop_open,
  161 + .bdrv_read = cloop_read,
  162 + .bdrv_close = cloop_close,
164 }; 163 };
block-cow.c
@@ -253,15 +253,15 @@ static void cow_flush(BlockDriverState *bs) @@ -253,15 +253,15 @@ static void cow_flush(BlockDriverState *bs)
253 } 253 }
254 254
255 BlockDriver bdrv_cow = { 255 BlockDriver bdrv_cow = {
256 - "cow",  
257 - sizeof(BDRVCowState),  
258 - cow_probe,  
259 - cow_open,  
260 - cow_read,  
261 - cow_write,  
262 - cow_close,  
263 - cow_create,  
264 - cow_flush,  
265 - cow_is_allocated, 256 + .format_name = "cow",
  257 + .instance_size = sizeof(BDRVCowState),
  258 + .bdrv_probe = cow_probe,
  259 + .bdrv_open = cow_open,
  260 + .bdrv_read = cow_read,
  261 + .bdrv_write = cow_write,
  262 + .bdrv_close = cow_close,
  263 + .bdrv_create = cow_create,
  264 + .bdrv_flush = cow_flush,
  265 + .bdrv_is_allocated = cow_is_allocated,
266 }; 266 };
267 #endif 267 #endif
block-dmg.c
@@ -284,11 +284,10 @@ static void dmg_close(BlockDriverState *bs) @@ -284,11 +284,10 @@ static void dmg_close(BlockDriverState *bs)
284 } 284 }
285 285
286 BlockDriver bdrv_dmg = { 286 BlockDriver bdrv_dmg = {
287 - "dmg",  
288 - sizeof(BDRVDMGState),  
289 - dmg_probe,  
290 - dmg_open,  
291 - dmg_read,  
292 - NULL,  
293 - dmg_close, 287 + .format_name = "dmg",
  288 + .instance_size = sizeof(BDRVDMGState),
  289 + .bdrv_probe = dmg_probe,
  290 + .bdrv_open = dmg_open,
  291 + .bdrv_read = dmg_read,
  292 + .bdrv_close = dmg_close,
294 }; 293 };
block-nbd.c
@@ -177,13 +177,12 @@ static int64_t nbd_getlength(BlockDriverState *bs) @@ -177,13 +177,12 @@ static int64_t nbd_getlength(BlockDriverState *bs)
177 } 177 }
178 178
179 BlockDriver bdrv_nbd = { 179 BlockDriver bdrv_nbd = {
180 - "nbd",  
181 - sizeof(BDRVNBDState),  
182 - NULL, /* no probe for protocols */  
183 - nbd_open,  
184 - nbd_read,  
185 - nbd_write,  
186 - nbd_close,  
187 - .bdrv_getlength = nbd_getlength,  
188 - .protocol_name = "nbd", 180 + .format_name = "nbd",
  181 + .instance_size = sizeof(BDRVNBDState),
  182 + .bdrv_open = nbd_open,
  183 + .bdrv_read = nbd_read,
  184 + .bdrv_write = nbd_write,
  185 + .bdrv_close = nbd_close,
  186 + .bdrv_getlength = nbd_getlength,
  187 + .protocol_name = "nbd",
189 }; 188 };
block-parallels.c
@@ -164,11 +164,10 @@ static void parallels_close(BlockDriverState *bs) @@ -164,11 +164,10 @@ static void parallels_close(BlockDriverState *bs)
164 } 164 }
165 165
166 BlockDriver bdrv_parallels = { 166 BlockDriver bdrv_parallels = {
167 - "parallels",  
168 - sizeof(BDRVParallelsState),  
169 - parallels_probe,  
170 - parallels_open,  
171 - parallels_read,  
172 - NULL,  
173 - parallels_close, 167 + .format_name = "parallels",
  168 + .instance_size = sizeof(BDRVParallelsState),
  169 + .bdrv_probe = parallels_probe,
  170 + .bdrv_open = parallels_open,
  171 + .bdrv_read = parallels_read,
  172 + .bdrv_close = parallels_close,
174 }; 173 };
block-qcow.c
@@ -887,23 +887,20 @@ static int qcow_get_info(BlockDriverState *bs, BlockDriverInfo *bdi) @@ -887,23 +887,20 @@ static int qcow_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
887 } 887 }
888 888
889 BlockDriver bdrv_qcow = { 889 BlockDriver bdrv_qcow = {
890 - "qcow",  
891 - sizeof(BDRVQcowState),  
892 - qcow_probe,  
893 - qcow_open,  
894 - NULL,  
895 - NULL,  
896 - qcow_close,  
897 - qcow_create,  
898 - qcow_flush,  
899 - qcow_is_allocated,  
900 - qcow_set_key,  
901 - qcow_make_empty,  
902 -  
903 - .bdrv_aio_read = qcow_aio_read,  
904 - .bdrv_aio_write = qcow_aio_write,  
905 - .bdrv_aio_cancel = qcow_aio_cancel,  
906 - .aiocb_size = sizeof(QCowAIOCB), 890 + .format_name = "qcow",
  891 + .instance_size = sizeof(BDRVQcowState),
  892 + .bdrv_probe = qcow_probe,
  893 + .bdrv_open = qcow_open,
  894 + .bdrv_close = qcow_close,
  895 + .bdrv_create = qcow_create,
  896 + .bdrv_flush = qcow_flush,
  897 + .bdrv_is_allocated = qcow_is_allocated,
  898 + .bdrv_set_key = qcow_set_key,
  899 + .bdrv_make_empty = qcow_make_empty,
  900 + .bdrv_aio_read = qcow_aio_read,
  901 + .bdrv_aio_write = qcow_aio_write,
  902 + .bdrv_aio_cancel = qcow_aio_cancel,
  903 + .aiocb_size = sizeof(QCowAIOCB),
907 .bdrv_write_compressed = qcow_write_compressed, 904 .bdrv_write_compressed = qcow_write_compressed,
908 - .bdrv_get_info = qcow_get_info, 905 + .bdrv_get_info = qcow_get_info,
909 }; 906 };
block-qcow2.c
@@ -2646,28 +2646,26 @@ static void dump_refcounts(BlockDriverState *bs) @@ -2646,28 +2646,26 @@ static void dump_refcounts(BlockDriverState *bs)
2646 #endif 2646 #endif
2647 2647
2648 BlockDriver bdrv_qcow2 = { 2648 BlockDriver bdrv_qcow2 = {
2649 - "qcow2",  
2650 - sizeof(BDRVQcowState),  
2651 - qcow_probe,  
2652 - qcow_open,  
2653 - NULL,  
2654 - NULL,  
2655 - qcow_close,  
2656 - qcow_create,  
2657 - qcow_flush,  
2658 - qcow_is_allocated,  
2659 - qcow_set_key,  
2660 - qcow_make_empty,  
2661 -  
2662 - .bdrv_aio_read = qcow_aio_read,  
2663 - .bdrv_aio_write = qcow_aio_write,  
2664 - .bdrv_aio_cancel = qcow_aio_cancel,  
2665 - .aiocb_size = sizeof(QCowAIOCB), 2649 + .format_name = "qcow2",
  2650 + .instance_size = sizeof(BDRVQcowState),
  2651 + .bdrv_probe = qcow_probe,
  2652 + .bdrv_open = qcow_open,
  2653 + .bdrv_close = qcow_close,
  2654 + .bdrv_create = qcow_create,
  2655 + .bdrv_flush = qcow_flush,
  2656 + .bdrv_is_allocated = qcow_is_allocated,
  2657 + .bdrv_set_key = qcow_set_key,
  2658 + .bdrv_make_empty = qcow_make_empty,
  2659 +
  2660 + .bdrv_aio_read = qcow_aio_read,
  2661 + .bdrv_aio_write = qcow_aio_write,
  2662 + .bdrv_aio_cancel = qcow_aio_cancel,
  2663 + .aiocb_size = sizeof(QCowAIOCB),
2666 .bdrv_write_compressed = qcow_write_compressed, 2664 .bdrv_write_compressed = qcow_write_compressed,
2667 2665
2668 .bdrv_snapshot_create = qcow_snapshot_create, 2666 .bdrv_snapshot_create = qcow_snapshot_create,
2669 - .bdrv_snapshot_goto = qcow_snapshot_goto, 2667 + .bdrv_snapshot_goto = qcow_snapshot_goto,
2670 .bdrv_snapshot_delete = qcow_snapshot_delete, 2668 .bdrv_snapshot_delete = qcow_snapshot_delete,
2671 - .bdrv_snapshot_list = qcow_snapshot_list,  
2672 - .bdrv_get_info = qcow_get_info, 2669 + .bdrv_snapshot_list = qcow_snapshot_list,
  2670 + .bdrv_get_info = qcow_get_info,
2673 }; 2671 };
block-raw-posix.c
@@ -1180,32 +1180,28 @@ static int raw_ioctl(BlockDriverState *bs, unsigned long int req, void *buf) @@ -1180,32 +1180,28 @@ static int raw_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
1180 #endif /* !linux */ 1180 #endif /* !linux */
1181 1181
1182 BlockDriver bdrv_host_device = { 1182 BlockDriver bdrv_host_device = {
1183 - "host_device",  
1184 - sizeof(BDRVRawState),  
1185 - NULL, /* no probe for protocols */  
1186 - hdev_open,  
1187 - NULL,  
1188 - NULL,  
1189 - raw_close,  
1190 - NULL,  
1191 - raw_flush, 1183 + .format_name = "host_device",
  1184 + .instance_size = sizeof(BDRVRawState),
  1185 + .bdrv_open = hdev_open,
  1186 + .bdrv_close = raw_close,
  1187 + .bdrv_flush = raw_flush,
1192 1188
1193 #ifdef CONFIG_AIO 1189 #ifdef CONFIG_AIO
1194 - .bdrv_aio_read = raw_aio_read,  
1195 - .bdrv_aio_write = raw_aio_write,  
1196 - .bdrv_aio_cancel = raw_aio_cancel,  
1197 - .aiocb_size = sizeof(RawAIOCB), 1190 + .bdrv_aio_read = raw_aio_read,
  1191 + .bdrv_aio_write = raw_aio_write,
  1192 + .bdrv_aio_cancel = raw_aio_cancel,
  1193 + .aiocb_size = sizeof(RawAIOCB),
1198 #endif 1194 #endif
1199 1195
1200 - .bdrv_pread = raw_pread,  
1201 - .bdrv_pwrite = raw_pwrite,  
1202 - .bdrv_getlength = raw_getlength, 1196 + .bdrv_pread = raw_pread,
  1197 + .bdrv_pwrite = raw_pwrite,
  1198 + .bdrv_getlength = raw_getlength,
1203 1199
1204 /* removable device support */ 1200 /* removable device support */
1205 - .bdrv_is_inserted = raw_is_inserted,  
1206 - .bdrv_media_changed = raw_media_changed,  
1207 - .bdrv_eject = raw_eject,  
1208 - .bdrv_set_locked = raw_set_locked, 1201 + .bdrv_is_inserted = raw_is_inserted,
  1202 + .bdrv_media_changed = raw_media_changed,
  1203 + .bdrv_eject = raw_eject,
  1204 + .bdrv_set_locked = raw_set_locked,
1209 /* generic scsi device */ 1205 /* generic scsi device */
1210 - .bdrv_ioctl = raw_ioctl, 1206 + .bdrv_ioctl = raw_ioctl,
1211 }; 1207 };
block-raw-win32.c
@@ -495,23 +495,19 @@ static int raw_set_locked(BlockDriverState *bs, int locked) @@ -495,23 +495,19 @@ static int raw_set_locked(BlockDriverState *bs, int locked)
495 #endif 495 #endif
496 496
497 BlockDriver bdrv_host_device = { 497 BlockDriver bdrv_host_device = {
498 - "host_device",  
499 - sizeof(BDRVRawState),  
500 - NULL, /* no probe for protocols */  
501 - hdev_open,  
502 - NULL,  
503 - NULL,  
504 - raw_close,  
505 - NULL,  
506 - raw_flush, 498 + .format_name = "host_device",
  499 + .instance_size = sizeof(BDRVRawState),
  500 + .bdrv_open = hdev_open,
  501 + .bdrv_close = raw_close,
  502 + .bdrv_flush = raw_flush,
507 503
508 #ifdef WIN32_AIO 504 #ifdef WIN32_AIO
509 - .bdrv_aio_read = raw_aio_read,  
510 - .bdrv_aio_write = raw_aio_write,  
511 - .bdrv_aio_cancel = raw_aio_cancel,  
512 - .aiocb_size = sizeof(RawAIOCB); 505 + .bdrv_aio_read = raw_aio_read,
  506 + .bdrv_aio_write = raw_aio_write,
  507 + .bdrv_aio_cancel = raw_aio_cancel,
  508 + .aiocb_size = sizeof(RawAIOCB);
513 #endif 509 #endif
514 - .bdrv_pread = raw_pread,  
515 - .bdrv_pwrite = raw_pwrite,  
516 - .bdrv_getlength = raw_getlength, 510 + .bdrv_pread = raw_pread,
  511 + .bdrv_pwrite = raw_pwrite,
  512 + .bdrv_getlength = raw_getlength,
517 }; 513 };
block-vmdk.c
@@ -812,14 +812,14 @@ static void vmdk_flush(BlockDriverState *bs) @@ -812,14 +812,14 @@ static void vmdk_flush(BlockDriverState *bs)
812 } 812 }
813 813
814 BlockDriver bdrv_vmdk = { 814 BlockDriver bdrv_vmdk = {
815 - "vmdk",  
816 - sizeof(BDRVVmdkState),  
817 - vmdk_probe,  
818 - vmdk_open,  
819 - vmdk_read,  
820 - vmdk_write,  
821 - vmdk_close,  
822 - vmdk_create,  
823 - vmdk_flush,  
824 - vmdk_is_allocated, 815 + .format_name = "vmdk",
  816 + .instance_size = sizeof(BDRVVmdkState),
  817 + .bdrv_probe = vmdk_probe,
  818 + .bdrv_open = vmdk_open,
  819 + .bdrv_read = vmdk_read,
  820 + .bdrv_write = vmdk_write,
  821 + .bdrv_close = vmdk_close,
  822 + .bdrv_create = vmdk_create,
  823 + .bdrv_flush = vmdk_flush,
  824 + .bdrv_is_allocated = vmdk_is_allocated,
825 }; 825 };
block-vpc.c
@@ -582,12 +582,12 @@ static void vpc_close(BlockDriverState *bs) @@ -582,12 +582,12 @@ static void vpc_close(BlockDriverState *bs)
582 } 582 }
583 583
584 BlockDriver bdrv_vpc = { 584 BlockDriver bdrv_vpc = {
585 - "vpc",  
586 - sizeof(BDRVVPCState),  
587 - vpc_probe,  
588 - vpc_open,  
589 - vpc_read,  
590 - vpc_write,  
591 - vpc_close,  
592 - vpc_create, 585 + .format_name = "vpc",
  586 + .instance_size = sizeof(BDRVVPCState),
  587 + .bdrv_probe = vpc_probe,
  588 + .bdrv_open = vpc_open,
  589 + .bdrv_read = vpc_read,
  590 + .bdrv_write = vpc_write,
  591 + .bdrv_close = vpc_close,
  592 + .bdrv_create = vpc_create,
593 }; 593 };
block-vvfat.c
@@ -2805,17 +2805,14 @@ static void vvfat_close(BlockDriverState *bs) @@ -2805,17 +2805,14 @@ static void vvfat_close(BlockDriverState *bs)
2805 } 2805 }
2806 2806
2807 BlockDriver bdrv_vvfat = { 2807 BlockDriver bdrv_vvfat = {
2808 - "vvfat",  
2809 - sizeof(BDRVVVFATState),  
2810 - NULL, /* no probe for protocols */  
2811 - vvfat_open,  
2812 - vvfat_read,  
2813 - vvfat_write,  
2814 - vvfat_close,  
2815 - NULL, /* ??? Not sure if we can do any meaningful flushing. */  
2816 - NULL,  
2817 - vvfat_is_allocated,  
2818 - .protocol_name = "fat", 2808 + .format_name = "vvfat",
  2809 + .instance_size = sizeof(BDRVVVFATState),
  2810 + .bdrv_open = vvfat_open,
  2811 + .bdrv_read = vvfat_read,
  2812 + .bdrv_write = vvfat_write,
  2813 + .bdrv_close = vvfat_close,
  2814 + .bdrv_is_allocated = vvfat_is_allocated,
  2815 + .protocol_name = "fat",
2819 }; 2816 };
2820 2817
2821 #ifdef DEBUG 2818 #ifdef DEBUG