target-ppc: Introduce and reuse generalized init_proc_book3s_64()

[qemu.git] / block-migration.c

diff --git a/block-migration.c b/block-migration.c
index 713a8e36e17fe16c9b88dc337a75013d047dc784..25a03889f471c0a81dec66d59519137c9f7fd13d 100644 (file)
--- a/block-migration.c
+++ b/block-migration.c
@@ -58,6 +58,8 @@ typedef struct BlkMigDevState {
     /* Protected by block migration lock.  */
     unsigned long *aio_bitmap;
     int64_t completed_sectors;
     /* Protected by block migration lock.  */
     unsigned long *aio_bitmap;
     int64_t completed_sectors;

+    BdrvDirtyBitmap *dirty_bitmap;
+    Error *blocker;

 } BlkMigDevState;
 
 typedef struct BlkMigBlock {
 } BlkMigDevState;
 
 typedef struct BlkMigBlock {


@@ -309,12 +311,36 @@ static int mig_save_device_bulk(QEMUFile *f, BlkMigDevState *bmds)
 
 /* Called with iothread lock taken.  */
 
 
 /* Called with iothread lock taken.  */
 

-static void set_dirty_tracking(int enable)
+static int set_dirty_tracking(void)

 {
     BlkMigDevState *bmds;
 {
     BlkMigDevState *bmds;

+    int ret;

 
     QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) {
 
     QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) {

-        bdrv_set_dirty_tracking(bmds->bs, enable ? BLOCK_SIZE : 0);
+        bmds->dirty_bitmap = bdrv_create_dirty_bitmap(bmds->bs, BLOCK_SIZE,
+                                                      NULL);
+        if (!bmds->dirty_bitmap) {
+            ret = -errno;
+            goto fail;
+        }
+    }
+    return 0;
+
+fail:
+    QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) {
+        if (bmds->dirty_bitmap) {
+            bdrv_release_dirty_bitmap(bmds->bs, bmds->dirty_bitmap);
+        }
+    }
+    return ret;
+}
+
+static void unset_dirty_tracking(void)
+{
+    BlkMigDevState *bmds;
+
+    QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) {
+        bdrv_release_dirty_bitmap(bmds->bs, bmds->dirty_bitmap);

     }
 }
 
     }
 }
 


@@ -336,7 +362,8 @@ static void init_blk_migration_it(void *opaque, BlockDriverState *bs)
         bmds->completed_sectors = 0;
         bmds->shared_base = block_mig_state.shared_base;
         alloc_aio_bitmap(bmds);
         bmds->completed_sectors = 0;
         bmds->shared_base = block_mig_state.shared_base;
         alloc_aio_bitmap(bmds);

-        bdrv_set_in_use(bs, 1);
+        error_setg(&bmds->blocker, "block device is in use by migration");
+        bdrv_op_block_all(bs, bmds->blocker);

         bdrv_ref(bs);
 
         block_mig_state.total_sector_sum += sectors;
         bdrv_ref(bs);
 
         block_mig_state.total_sector_sum += sectors;


@@ -432,7 +459,7 @@ static int mig_save_device_dirty(QEMUFile *f, BlkMigDevState *bmds,
         } else {
             blk_mig_unlock();
         }
         } else {
             blk_mig_unlock();
         }

-        if (bdrv_get_dirty(bmds->bs, sector)) {
+        if (bdrv_get_dirty(bmds->bs, bmds->dirty_bitmap, sector)) {

 
             if (total_sectors - sector < BDRV_SECTORS_PER_DIRTY_CHUNK) {
                 nr_sectors = total_sectors - sector;
 
             if (total_sectors - sector < BDRV_SECTORS_PER_DIRTY_CHUNK) {
                 nr_sectors = total_sectors - sector;


@@ -554,7 +581,7 @@ static int64_t get_remaining_dirty(void)
     int64_t dirty = 0;
 
     QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) {
     int64_t dirty = 0;
 
     QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) {

-        dirty += bdrv_get_dirty_count(bmds->bs);
+        dirty += bdrv_get_dirty_count(bmds->bs, bmds->dirty_bitmap);

     }
 
     return dirty << BDRV_SECTOR_BITS;
     }
 
     return dirty << BDRV_SECTOR_BITS;


@@ -569,12 +596,13 @@ static void blk_mig_cleanup(void)
 
     bdrv_drain_all();
 
 
     bdrv_drain_all();
 

-    set_dirty_tracking(0);
+    unset_dirty_tracking();

 
     blk_mig_lock();
     while ((bmds = QSIMPLEQ_FIRST(&block_mig_state.bmds_list)) != NULL) {
         QSIMPLEQ_REMOVE_HEAD(&block_mig_state.bmds_list, entry);
 
     blk_mig_lock();
     while ((bmds = QSIMPLEQ_FIRST(&block_mig_state.bmds_list)) != NULL) {
         QSIMPLEQ_REMOVE_HEAD(&block_mig_state.bmds_list, entry);

-        bdrv_set_in_use(bmds->bs, 0);
+        bdrv_op_unblock_all(bmds->bs, bmds->blocker);
+        error_free(bmds->blocker);

         bdrv_unref(bmds->bs);
         g_free(bmds->aio_bitmap);
         g_free(bmds);
         bdrv_unref(bmds->bs);
         g_free(bmds->aio_bitmap);
         g_free(bmds);


@@ -604,7 +632,13 @@ static int block_save_setup(QEMUFile *f, void *opaque)
     init_blk_migration(f);
 
     /* start track dirty blocks */
     init_blk_migration(f);
 
     /* start track dirty blocks */

-    set_dirty_tracking(1);
+    ret = set_dirty_tracking();
+
+    if (ret) {
+        qemu_mutex_unlock_iothread();
+        return ret;
+    }
+

     qemu_mutex_unlock_iothread();
 
     ret = flush_blks(f);
     qemu_mutex_unlock_iothread();
 
     ret = flush_blks(f);


@@ -780,7 +814,8 @@ static int block_load(QEMUFile *f, void *opaque, int version_id)
             }
 
             if (flags & BLK_MIG_FLAG_ZERO_BLOCK) {
             }
 
             if (flags & BLK_MIG_FLAG_ZERO_BLOCK) {

-                ret = bdrv_write_zeroes(bs, addr, nr_sectors, 0);
+                ret = bdrv_write_zeroes(bs, addr, nr_sectors,
+                                        BDRV_REQ_MAY_UNMAP);

             } else {
                 buf = g_malloc(BLOCK_SIZE);
                 qemu_get_buffer(f, buf, BLOCK_SIZE);
             } else {
                 buf = g_malloc(BLOCK_SIZE);
                 qemu_get_buffer(f, buf, BLOCK_SIZE);