/ - Diff - qemu - Greek Research and Technology Network's projects

         return cow_update_bitmap(bs, sector_num, nb_sectors);
+    }
     static coroutine_fn int cow_co_write(BlockDriverState *bs, int64_t sector_num,
                                          const uint8_t *buf, int nb_sectors)
+    {
         int ret;
         BDRVCowState *s = bs->opaque;
         qemu_co_mutex_lock(&s->lock);
         ret = cow_write(bs, sector_num, buf, nb_sectors);
         qemu_co_mutex_unlock(&s->lock);
         return ret;
+    }
     static void cow_close(BlockDriverState *bs)
+    {
+    }
-...
         .bdrv_probe		= cow_probe,
         .bdrv_open		= cow_open,
         .bdrv_read          = cow_co_read,
         .bdrv_write		= cow_write,
         .bdrv_write         = cow_co_write,
         .bdrv_close		= cow_close,
         .bdrv_create	= cow_create,
         .bdrv_flush		= cow_flush,

         return ret;
+    }
     static coroutine_fn int nbd_co_write(BlockDriverState *bs, int64_t sector_num,
                                          const uint8_t *buf, int nb_sectors)
+    {
         int ret;
         BDRVNBDState *s = bs->opaque;
         qemu_co_mutex_lock(&s->lock);
         ret = nbd_write(bs, sector_num, buf, nb_sectors);
         qemu_co_mutex_unlock(&s->lock);
         return ret;
+    }
     static void nbd_close(BlockDriverState *bs)
+    {
         BDRVNBDState *s = bs->opaque;
-...
         .instance_size	= sizeof(BDRVNBDState),
         .bdrv_file_open	= nbd_open,
         .bdrv_read          = nbd_co_read,
         .bdrv_write		= nbd_write,
         .bdrv_write         = nbd_co_write,
         .bdrv_close		= nbd_close,
         .bdrv_getlength	= nbd_getlength,
         .protocol_name	= "nbd",

         return 0;
+    }
     static coroutine_fn int vmdk_co_write(BlockDriverState *bs, int64_t sector_num,
                                           const uint8_t *buf, int nb_sectors)
+    {
         int ret;
         BDRVVmdkState *s = bs->opaque;
         qemu_co_mutex_lock(&s->lock);
         ret = vmdk_write(bs, sector_num, buf, nb_sectors);
         qemu_co_mutex_unlock(&s->lock);
         return ret;
+    }
     static int vmdk_create_extent(const char *filename, int64_t filesize,
                                   bool flat, bool compress)
-...
         .bdrv_probe     = vmdk_probe,
         .bdrv_open      = vmdk_open,
         .bdrv_read      = vmdk_co_read,
         .bdrv_write     = vmdk_write,
         .bdrv_write     = vmdk_co_write,
         .bdrv_close     = vmdk_close,
         .bdrv_create    = vmdk_create,
         .bdrv_flush     = vmdk_flush,

         return 0;
+    }
     static coroutine_fn int vpc_co_write(BlockDriverState *bs, int64_t sector_num,
                                          const uint8_t *buf, int nb_sectors)
+    {
         int ret;
         BDRVVPCState *s = bs->opaque;
         qemu_co_mutex_lock(&s->lock);
         ret = vpc_write(bs, sector_num, buf, nb_sectors);
         qemu_co_mutex_unlock(&s->lock);
         return ret;
+    }
     static int vpc_flush(BlockDriverState *bs)
+    {
         return bdrv_flush(bs->file);
-...
         .bdrv_probe     = vpc_probe,
         .bdrv_open      = vpc_open,
         .bdrv_read      = vpc_co_read,
         .bdrv_write     = vpc_write,
         .bdrv_write     = vpc_co_write,
         .bdrv_flush     = vpc_flush,
         .bdrv_close     = vpc_close,
         .bdrv_create    = vpc_create,

         return 0;
+    }
     static coroutine_fn int vvfat_co_write(BlockDriverState *bs, int64_t sector_num,
                                            const uint8_t *buf, int nb_sectors)
+    {
         int ret;
         BDRVVVFATState *s = bs->opaque;
         qemu_co_mutex_lock(&s->lock);
         ret = vvfat_write(bs, sector_num, buf, nb_sectors);
         qemu_co_mutex_unlock(&s->lock);
         return ret;
+    }
     static int vvfat_is_allocated(BlockDriverState *bs,
     	int64_t sector_num, int nb_sectors, int* n)
+    {
-...
         .instance_size	= sizeof(BDRVVVFATState),
         .bdrv_file_open	= vvfat_open,
         .bdrv_read          = vvfat_co_read,
         .bdrv_write		= vvfat_write,
         .bdrv_write         = vvfat_co_write,
         .bdrv_close		= vvfat_close,
         .bdrv_is_allocated	= vvfat_is_allocated,
         .protocol_name	= "fat",

Archipelago » qemu