[03/23] block migration: Fix coding style and whitespaces

diff --git a/block-migration.c b/block-migration.c
index 09771ed..37e41ab 100644
--- a/block-migration.c
+++ b/block-migration.c
@@ -21,7 +21,7 @@ 
 #define SECTOR_SIZE (1 << SECTOR_BITS)
 #define SECTOR_MASK ~(SECTOR_SIZE - 1);
 
-#define BLOCK_SIZE (block_mig_state->sectors_per_block << SECTOR_BITS) 
+#define BLOCK_SIZE (block_mig_state->sectors_per_block << SECTOR_BITS)
 
 #define BLK_MIG_FLAG_DEVICE_BLOCK       0x01
 #define BLK_MIG_FLAG_EOS                0x02
@@ -34,13 +34,23 @@ 
 //#define DEBUG_BLK_MIGRATION
 
 #ifdef DEBUG_BLK_MIGRATION
-#define dprintf(fmt, ...)						\
+#define dprintf(fmt, ...) \
     do { printf("blk_migration: " fmt, ## __VA_ARGS__); } while (0)
 #else
-#define dprintf(fmt, ...)			\
+#define dprintf(fmt, ...) \
     do { } while (0)
 #endif
 
+typedef struct BlkMigDevState {
+    BlockDriverState *bs;
+    int bulk_completed;
+    int shared_base;
+    struct BlkMigDevState *next;
+    int64_t cur_sector;
+    int64_t total_sectors;
+    int64_t dirty;
+} BlkMigDevState;
+
 typedef struct BlkMigBlock {
     uint8_t *buf;
     BlkMigDevState *bmds;
@@ -68,87 +78,85 @@  typedef struct BlkMigState {
     int64_t print_completion;
 } BlkMigState;
 
-static BlkMigState *block_mig_state = NULL;  
+static BlkMigState *block_mig_state = NULL;
 
 static void blk_mig_read_cb(void *opaque, int ret)
 {
     BlkMigBlock *blk = opaque;
-  
+
     blk->ret = ret;
-    
+
     /* insert at the end */
-    if(block_mig_state->last_blk == NULL) {
+    if (block_mig_state->last_blk == NULL) {
         block_mig_state->first_blk = blk;
         block_mig_state->last_blk = blk;
     } else {
         block_mig_state->last_blk->next = blk;
         block_mig_state->last_blk = blk;
     }
-    
+
     block_mig_state->submitted--;
     block_mig_state->read_done++;
     assert(block_mig_state->submitted >= 0);
-    
-    return;
 }
 
 static int mig_read_device_bulk(QEMUFile *f, BlkMigDevState *bms)
-{ 
+{
     int nr_sectors;
     int64_t total_sectors, cur_sector = 0;
     BlockDriverState *bs = bms->bs;
     BlkMigBlock *blk;
-    
+
     blk = qemu_malloc(sizeof(BlkMigBlock));
     blk->buf = qemu_malloc(BLOCK_SIZE);
-    
+
     cur_sector = bms->cur_sector;
     total_sectors = bdrv_getlength(bs) >> SECTOR_BITS;
-  
-    if(bms->shared_base) {
-        while(cur_sector < bms->total_sectors && 
-              !bdrv_is_allocated(bms->bs, cur_sector, 
-                                 MAX_IS_ALLOCATED_SEARCH, &nr_sectors)) {
+
+    if (bms->shared_base) {
+        while (cur_sector < bms->total_sectors &&
+               !bdrv_is_allocated(bms->bs, cur_sector,
+                                  MAX_IS_ALLOCATED_SEARCH, &nr_sectors)) {
             cur_sector += nr_sectors;
         }
     }
-    
-    if(cur_sector >= total_sectors) {
+
+    if (cur_sector >= total_sectors) {
         bms->cur_sector = total_sectors;
         qemu_free(blk->buf);
         qemu_free(blk);
         return 1;
     }
-  
-    if(cur_sector >= block_mig_state->print_completion) {
+
+    if (cur_sector >= block_mig_state->print_completion) {
         printf("Completed %" PRId64 " %%\r", cur_sector * 100 / total_sectors);
         fflush(stdout);
-        block_mig_state->print_completion += 
+        block_mig_state->print_completion +=
             (block_mig_state->sectors_per_block * 10000);
     }
-  
+
     /* we going to transfder BLOCK_SIZE any way even if it is not allocated */
     nr_sectors = block_mig_state->sectors_per_block;
 
     cur_sector &= ~((int64_t)block_mig_state->sectors_per_block -1);
-    
-    if(total_sectors - cur_sector < block_mig_state->sectors_per_block) {
+
+    if (total_sectors - cur_sector < block_mig_state->sectors_per_block) {
         nr_sectors = (total_sectors - cur_sector);
     }
-  
+
     bms->cur_sector = cur_sector + nr_sectors;
     blk->sector = cur_sector;
     blk->bmds = bms;
     blk->next = NULL;
-  
+
     blk->iov.iov_base = blk->buf;
     blk->iov.iov_len = nr_sectors * SECTOR_SIZE;
     qemu_iovec_init_external(&blk->qiov, &blk->iov, 1);
-  
+
     blk->aiocb = bdrv_aio_readv(bs, cur_sector, &blk->qiov,
                                 nr_sectors, blk_mig_read_cb, blk);
-  
-    if(!blk->aiocb) {
+
+    if (!blk->aiocb) {
         printf("Error reading sector %" PRId64 "\n", cur_sector);
         qemu_free(blk->buf);
         qemu_free(blk);
@@ -157,91 +165,87 @@  static int mig_read_device_bulk(QEMUFile *f, BlkMigDevState *bms)
 
     bdrv_reset_dirty(bms->bs, cur_sector, nr_sectors);
     block_mig_state->submitted++;
-  
+
     return (bms->cur_sector >= total_sectors);
 }
 
 static int mig_save_device_bulk(QEMUFile *f, BlkMigDevState *bmds)
-{ 
+{
     int len, nr_sectors;
     int64_t total_sectors = bmds->total_sectors, cur_sector = 0;
     uint8_t *tmp_buf = NULL;
     BlockDriverState *bs = bmds->bs;
 
     tmp_buf = qemu_malloc(BLOCK_SIZE);
-  
+
     cur_sector = bmds->cur_sector;
-    
-    if(bmds->shared_base) {
-        while(cur_sector < bmds->total_sectors && 
-              !bdrv_is_allocated(bmds->bs, cur_sector, 
-                                 MAX_IS_ALLOCATED_SEARCH, &nr_sectors)) {
+
+    if (bmds->shared_base) {
+        while (cur_sector < bmds->total_sectors &&
+               !bdrv_is_allocated(bmds->bs, cur_sector,
+                                  MAX_IS_ALLOCATED_SEARCH, &nr_sectors)) {
             cur_sector += nr_sectors;
         }
     }
-    
-    if(cur_sector >= total_sectors) {
+
+    if (cur_sector >= total_sectors) {
         bmds->cur_sector = total_sectors;
         qemu_free(tmp_buf);
         return 1;
     }
-    
-    if(cur_sector >= block_mig_state->print_completion) {
+
+    if (cur_sector >= block_mig_state->print_completion) {
         printf("Completed %" PRId64 " %%\r", cur_sector * 100 / total_sectors);
         fflush(stdout);
-        block_mig_state->print_completion += 
+        block_mig_state->print_completion +=
             (block_mig_state->sectors_per_block * 10000);
     }
-    
+
     cur_sector &= ~((int64_t)block_mig_state->sectors_per_block -1);
-        
-    /* we going to transfer 
-       BLOCK_SIZE 
-       any way even if it is not allocated */
+
+    /* we going to transfer BLOCK_SIZE any way even if it is not allocated */
     nr_sectors = block_mig_state->sectors_per_block;
-  
-    if(total_sectors - cur_sector < block_mig_state->sectors_per_block) {
+
+    if (total_sectors - cur_sector < block_mig_state->sectors_per_block) {
         nr_sectors = (total_sectors - cur_sector);
     }
-  
-    if(bdrv_read(bs, cur_sector, tmp_buf, nr_sectors) < 0) {
+
+    if (bdrv_read(bs, cur_sector, tmp_buf, nr_sectors) < 0) {
         printf("Error reading sector %" PRId64 "\n", cur_sector);
     }
 
     bdrv_reset_dirty(bs, cur_sector, nr_sectors);
-  
-    /* Device name */
-    qemu_put_be64(f,(cur_sector << SECTOR_BITS) | BLK_MIG_FLAG_DEVICE_BLOCK);
-  
+
+    /* sector number and flags */
+    qemu_put_be64(f, (cur_sector << SECTOR_BITS) | BLK_MIG_FLAG_DEVICE_BLOCK);
+
+    /* device name */
     len = strlen(bs->device_name);
     qemu_put_byte(f, len);
     qemu_put_buffer(f, (uint8_t *)bs->device_name, len);
-  
-    qemu_put_buffer(f, tmp_buf, 
-                    BLOCK_SIZE);
-    
+
+    qemu_put_buffer(f, tmp_buf, BLOCK_SIZE);
+
     bmds->cur_sector = cur_sector + block_mig_state->sectors_per_block;
-  
+
     qemu_free(tmp_buf);
-  
+
     return (bmds->cur_sector >= total_sectors);
 }
 
 static void send_blk(QEMUFile *f, BlkMigBlock * blk)
 {
     int len;
-  
-    /* Device name */ 
-    qemu_put_be64(f,(blk->sector << SECTOR_BITS) | BLK_MIG_FLAG_DEVICE_BLOCK);
-  
+
+    /* sector number and flags */
+    qemu_put_be64(f, (blk->sector << SECTOR_BITS) | BLK_MIG_FLAG_DEVICE_BLOCK);
+
+    /* device name */
     len = strlen(blk->bmds->bs->device_name);
     qemu_put_byte(f, len);
     qemu_put_buffer(f, (uint8_t *)blk->bmds->bs->device_name, len);
-  
-    qemu_put_buffer(f, blk->buf, 
-                    BLOCK_SIZE);
-  
-    return;
+
+    qemu_put_buffer(f, blk->buf, BLOCK_SIZE);
 }
 
 static void blk_mig_save_dev_info(QEMUFile *f, BlkMigDevState *bmds)
@@ -251,47 +255,43 @@  static void blk_mig_save_dev_info(QEMUFile *f, BlkMigDevState *bmds)
 static void set_dirty_tracking(int enable)
 {
     BlkMigDevState *bmds;
-    for(bmds = block_mig_state->bmds_first; bmds != NULL; bmds = bmds->next) {
-        bdrv_set_dirty_tracking(bmds->bs,enable);
+    for (bmds = block_mig_state->bmds_first; bmds != NULL; bmds = bmds->next) {
+        bdrv_set_dirty_tracking(bmds->bs, enable);
     }
-    
-    return;
 }
 
 static void init_blk_migration(QEMUFile *f)
 {
     BlkMigDevState **pbmds, *bmds;
     BlockDriverState *bs;
-    
+
     for (bs = bdrv_first; bs != NULL; bs = bs->next) {
-        if(bs->type == BDRV_TYPE_HD) {
+        if (bs->type == BDRV_TYPE_HD) {
             bmds = qemu_mallocz(sizeof(BlkMigDevState));
             bmds->bs = bs;
             bmds->bulk_completed = 0;
             bmds->total_sectors = bdrv_getlength(bs) >> SECTOR_BITS;
             bmds->shared_base = block_mig_state->shared_base;
-	          
-            if(bmds->shared_base) {
-                printf("Start migration for %s with shared base image\n", 
+
+            if (bmds->shared_base) {
+                printf("Start migration for %s with shared base image\n",
                        bs->device_name);
             } else {
                 printf("Start full migration for %s\n", bs->device_name);
             }
-      
+
             /* insert at the end */
             pbmds = &block_mig_state->bmds_first;
-            while (*pbmds != NULL)
+            while (*pbmds != NULL) {
                 pbmds = &(*pbmds)->next;
+            }
             *pbmds = bmds;
-      
+
             blk_mig_save_dev_info(f, bmds);
-	    
         }
-    } 
-    
+    }
+
     block_mig_state->sectors_per_block = bdrv_get_sectors_per_chunk();
-    
-    return;
 }
 
 static int blk_mig_save_bulked_block(QEMUFile *f, int is_async)
@@ -299,14 +299,14 @@  static int blk_mig_save_bulked_block(QEMUFile *f, int is_async)
     BlkMigDevState *bmds;
 
     for (bmds = block_mig_state->bmds_first; bmds != NULL; bmds = bmds->next) {
-        if(bmds->bulk_completed == 0) {
-            if(is_async) {
-                if(mig_read_device_bulk(f, bmds) == 1) {
+        if (bmds->bulk_completed == 0) {
+            if (is_async) {
+                if (mig_read_device_bulk(f, bmds) == 1) {
                     /* completed bulk section for this device */
                     bmds->bulk_completed = 1;
                 }
             } else {
-                if(mig_save_device_bulk(f,bmds) == 1) {
+                if (mig_save_device_bulk(f, bmds) == 1) {
                     /* completed bulk section for this device */
                     bmds->bulk_completed = 1;
                 }
@@ -314,12 +314,11 @@  static int blk_mig_save_bulked_block(QEMUFile *f, int is_async)
             return 1;
         }
     }
-  
+
     /* we reached here means bulk is completed */
     block_mig_state->bulk_completed = 1;
-  
+
     return 0;
-    
 }
 
 #define MAX_NUM_BLOCKS 4
@@ -330,143 +329,131 @@  static void blk_mig_save_dirty_blocks(QEMUFile *f)
     uint8_t buf[BLOCK_SIZE];
     int64_t sector;
     int len;
-    
-    for(bmds = block_mig_state->bmds_first; bmds != NULL; bmds = bmds->next) {
-        for(sector = 0; sector < bmds->cur_sector;) {
-	    
-            if(bdrv_get_dirty(bmds->bs,sector)) {
-		
-                if(bdrv_read(bmds->bs, sector, buf, 
-                             block_mig_state->sectors_per_block) < 0) {
+
+    for (bmds = block_mig_state->bmds_first; bmds != NULL; bmds = bmds->next) {
+        for (sector = 0; sector < bmds->cur_sector;) {
+            if (bdrv_get_dirty(bmds->bs, sector)) {
+                if (bdrv_read(bmds->bs, sector, buf,
+                              block_mig_state->sectors_per_block) < 0) {
+                    /* FIXME: add error handling */
                 }
-		
+
+                /* sector number and flags */
+                qemu_put_be64(f, (sector << SECTOR_BITS)
+                                 | BLK_MIG_FLAG_DEVICE_BLOCK);
+
                 /* device name */
-                qemu_put_be64(f,(sector << SECTOR_BITS) 
-                              | BLK_MIG_FLAG_DEVICE_BLOCK);
-	
                 len = strlen(bmds->bs->device_name);
-	
                 qemu_put_byte(f, len);
                 qemu_put_buffer(f, (uint8_t *)bmds->bs->device_name, len);
-	
-                qemu_put_buffer(f, buf, 
-                                (block_mig_state->sectors_per_block * 
+
+                qemu_put_buffer(f, buf,
+                                (block_mig_state->sectors_per_block *
                                  SECTOR_SIZE));
-		
-                bdrv_reset_dirty(bmds->bs, sector, 
+
+                bdrv_reset_dirty(bmds->bs, sector,
                                  block_mig_state->sectors_per_block);
-	
-                sector += block_mig_state->sectors_per_block;
-            } else {
-                /* sector is clean */
-                sector += block_mig_state->sectors_per_block;
-            }  
+            }
+            sector += block_mig_state->sectors_per_block;
         }
     }
-    
-    return;
 }
 
 static void flush_blks(QEMUFile* f)
 {
-    BlkMigBlock *blk, *tmp;
-    
-    dprintf("%s Enter submitted %d read_done %d transfered\n", __FUNCTION__, 
+    BlkMigBlock *blk, *next;
+
+    dprintf("%s Enter submitted %d read_done %d transfered\n", __FUNCTION__,
             submitted, read_done, transfered);
-  
-    for(blk = block_mig_state->first_blk; 
-        blk != NULL && !qemu_file_rate_limit(f); blk = tmp) {
+
+    for (blk = block_mig_state->first_blk;
+         blk != NULL && !qemu_file_rate_limit(f);
+         blk = next) {
         send_blk(f, blk);
-    
-        tmp = blk->next;
+
+        next = blk->next;
         qemu_free(blk->buf);
         qemu_free(blk);
-    
+
         block_mig_state->read_done--;
         block_mig_state->transferred++;
         assert(block_mig_state->read_done >= 0);
     }
     block_mig_state->first_blk = blk;
-  
-    if(block_mig_state->first_blk == NULL) {
+
+    if (block_mig_state->first_blk == NULL) {
         block_mig_state->last_blk = NULL;
     }
 
-    dprintf("%s Exit submitted %d read_done %d transferred%d\n", __FUNCTION__, 
-            block_mig_state->submitted, block_mig_state->read_done, 
+    dprintf("%s Exit submitted %d read_done %d transferred%d\n", __FUNCTION__,
+            block_mig_state->submitted, block_mig_state->read_done,
             block_mig_state->transferred);
-
-    return;
 }
 
 static int is_stage2_completed(void)
 {
     BlkMigDevState *bmds;
-  
-    if(block_mig_state->submitted > 0) {
+
+    if (block_mig_state->submitted > 0) {
         return 0;
     }
-  
+
     for (bmds = block_mig_state->bmds_first; bmds != NULL; bmds = bmds->next) {
-        if(bmds->bulk_completed == 0) {
+        if (bmds->bulk_completed == 0) {
             return 0;
         }
     }
-    
+
     return 1;
 }
 
 static int block_save_live(QEMUFile *f, int stage, void *opaque)
 {
-    int ret = 1;
-    
-    dprintf("Enter save live stage %d submitted %d transferred %d\n", stage, 
+    dprintf("Enter save live stage %d submitted %d transferred %d\n", stage,
             submitted, transferred);
-  
-    if(block_mig_state->blk_enable != 1) {
+
+    if (block_mig_state->blk_enable != 1) {
         /* no need to migrate storage */
-    
-        qemu_put_be64(f,BLK_MIG_FLAG_EOS);
+        qemu_put_be64(f, BLK_MIG_FLAG_EOS);
         return 1;
     }
-  
-    if(stage == 1) {
+
+    if (stage == 1) {
         init_blk_migration(f);
-	
+
         /* start track dirty blocks */
         set_dirty_tracking(1);
-	
     }
 
     flush_blks(f);
-  
+
     /* control the rate of transfer */
-    while ((block_mig_state->submitted + block_mig_state->read_done) * 
-           (BLOCK_SIZE) < 
-           (qemu_file_get_rate_limit(f))) {
-	
-        ret = blk_mig_save_bulked_block(f, 1);
-	
-        if (ret == 0) /* no more bulk blocks for now*/
+    while ((block_mig_state->submitted +
+            block_mig_state->read_done) * BLOCK_SIZE <
+           qemu_file_get_rate_limit(f)) {
+        if (blk_mig_save_bulked_block(f, 1) == 0) {
+            /* no more bulk blocks for now */
             break;
+        }
     }
-  
+
     flush_blks(f);
-    
-    if(stage == 3) {
-	
-        while(blk_mig_save_bulked_block(f, 0) != 0);
-	
+
+    if (stage == 3) {
+        while (blk_mig_save_bulked_block(f, 0) != 0) {
+            /* empty */
+        }
+
         blk_mig_save_dirty_blocks(f);
-	
+
         /* stop track dirty blocks */
-        set_dirty_tracking(0);;
-	
-        printf("\nBlock migration completed\n");  
+        set_dirty_tracking(0);
+
+        printf("\nBlock migration completed\n");
     }
-  
-    qemu_put_be64(f,BLK_MIG_FLAG_EOS);
-  
+
+    qemu_put_be64(f, BLK_MIG_FLAG_EOS);
+
     return ((stage == 2) && is_stage2_completed());
 }
 
@@ -477,43 +464,39 @@  static int block_load(QEMUFile *f, void *opaque, int version_id)
     int64_t addr;
     BlockDriverState *bs;
     uint8_t *buf;
-    
+
     block_mig_state->sectors_per_block = bdrv_get_sectors_per_chunk();
     buf = qemu_malloc(BLOCK_SIZE);
-    
+
     do {
-    
         addr = qemu_get_be64(f);
-    
+
         flags = addr & ~SECTOR_MASK;
         addr &= SECTOR_MASK;
-    
-        if(flags & BLK_MIG_FLAG_DEVICE_BLOCK) {
-	    
+
+        if (flags & BLK_MIG_FLAG_DEVICE_BLOCK) {
             /* get device name */
             len = qemu_get_byte(f);
-      
+
             qemu_get_buffer(f, (uint8_t *)device_name, len);
             device_name[len] = '\0';
-      
+
             bs = bdrv_find(device_name);
-      
-            qemu_get_buffer(f, buf, 
-                            BLOCK_SIZE);
-            if(bs != NULL) {
-	
-                bdrv_write(bs, (addr >> SECTOR_BITS), 
+
+            qemu_get_buffer(f, buf, BLOCK_SIZE);
+            if (bs != NULL) {
+                bdrv_write(bs, (addr >> SECTOR_BITS),
                            buf, block_mig_state->sectors_per_block);
             } else {
                 printf("Error unknown block device %s\n", device_name);
+                /* FIXME: add error handling */
             }
-        } else if(flags & BLK_MIG_FLAG_EOS) {
-	    
-        } else {
+        } else if (!(flags & BLK_MIG_FLAG_EOS)) {
             printf("Unknown flags\n");
+            /* FIXME: add error handling */
         }
-    } while(!(flags & BLK_MIG_FLAG_EOS));
-  
+    } while (!(flags & BLK_MIG_FLAG_EOS));
+
     qemu_free(buf);
 
     return 0;
@@ -525,33 +508,28 @@  static void block_set_params(int blk_enable, int shared_base, void *opaque)
 
     block_mig_state->blk_enable = blk_enable;
     block_mig_state->shared_base = shared_base;
-  
+
     /* shared base means that blk_enable = 1 */
     block_mig_state->blk_enable |= shared_base;
-  
-    return;
 }
 
 void blk_mig_info(void)
 {
     BlockDriverState *bs;
-  
+
     for (bs = bdrv_first; bs != NULL; bs = bs->next) {
         printf("Device %s\n", bs->device_name);
-        if(bs->type == BDRV_TYPE_HD) {
-            printf("device %s format %s\n", 
+        if (bs->type == BDRV_TYPE_HD) {
+            printf("device %s format %s\n",
                    bs->device_name, bs->drv->format_name);
         }
     }
 }
 
 void blk_mig_init(void)
-{ 
-    
+{
     block_mig_state = qemu_mallocz(sizeof(BlkMigState));
-    
-    register_savevm_live("block", 0, 1, block_set_params, block_save_live, 
-                         NULL, block_load, block_mig_state);
 
- 
+    register_savevm_live("block", 0, 1, block_set_params, block_save_live,
+                         NULL, block_load, block_mig_state);
 }
diff --git a/block-migration.h b/block-migration.h
index c33d3cb..39ee889 100644
--- a/block-migration.h
+++ b/block-migration.h
@@ -14,16 +14,6 @@ 
 #ifndef BLOCK_MIGRATION_H
 #define BLOCK_MIGRATION_H
 
-typedef struct BlkMigDevState {
-    BlockDriverState *bs;
-    int bulk_completed;
-    int shared_base;
-    struct BlkMigDevState *next;
-    int64_t cur_sector;
-    int64_t total_sectors;
-    int64_t dirty;
-} BlkMigDevState;
- 
 void blk_mig_init(void);
 void blk_mig_info(void);
 #endif /* BLOCK_MIGRATION_H */
diff --git a/block.c b/block.c
index 6fdabff..75ea223 100644
--- a/block.c
+++ b/block.c
@@ -643,13 +643,14 @@  int bdrv_read(BlockDriverState *bs, int64_t sector_num,
 }
 
 static void set_dirty_bitmap(BlockDriverState *bs, int64_t sector_num,
-			     int nb_sectors, int dirty)
+                             int nb_sectors, int dirty)
 {
     int64_t start, end;
+
     start = sector_num / SECTORS_PER_DIRTY_CHUNK;
     end = (sector_num + nb_sectors) / SECTORS_PER_DIRTY_CHUNK;
-    
-    for(; start <= end; start++) {
+
+    for (; start <= end; start++) {
         bs->dirty_bitmap[start] = dirty;
     }
 }
@@ -670,11 +671,11 @@  int bdrv_write(BlockDriverState *bs, int64_t sector_num,
         return -EACCES;
     if (bdrv_check_request(bs, sector_num, nb_sectors))
         return -EIO;
-    
-    if(bs->dirty_tracking) {
+
+    if (bs->dirty_tracking) {
         set_dirty_bitmap(bs, sector_num, nb_sectors, 1);
     }
-    
+
     return drv->bdrv_write(bs, sector_num, buf, nb_sectors);
 }
 
@@ -1220,11 +1221,11 @@  int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
         return -ENOTSUP;
     if (bdrv_check_request(bs, sector_num, nb_sectors))
         return -EIO;
-    
-    if(bs->dirty_tracking) {
+
+    if (bs->dirty_tracking) {
         set_dirty_bitmap(bs, sector_num, nb_sectors, 1);
     }
-    
+
     return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);
 }
 
@@ -1422,10 +1423,10 @@  BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
     if (bdrv_check_request(bs, sector_num, nb_sectors))
         return NULL;
 
-    if(bs->dirty_tracking) {
+    if (bs->dirty_tracking) {
         set_dirty_bitmap(bs, sector_num, nb_sectors, 1);
     }
-    
+
     ret = drv->bdrv_aio_writev(bs, sector_num, qiov, nb_sectors,
                                cb, opaque);
 
@@ -1966,41 +1967,43 @@  void *qemu_blockalign(BlockDriverState *bs, size_t size)
 void bdrv_set_dirty_tracking(BlockDriverState *bs, int enable)
 {
     int64_t bitmap_size;
-    if(enable) {
-        if(bs->dirty_tracking == 0) {
+
+    if (enable) {
+        if (bs->dirty_tracking == 0) {
             int64_t i;
             uint8_t test;
+
             bitmap_size = (bdrv_getlength(bs) >> SECTOR_BITS);
             bitmap_size /= SECTORS_PER_DIRTY_CHUNK;
             bitmap_size++;
-	    
+
             bs->dirty_bitmap = qemu_mallocz(bitmap_size);
-	    
+
             bs->dirty_tracking = enable;
             for(i = 0; i < bitmap_size; i++) test = bs->dirty_bitmap[i]; 
-	}
+        }
     } else {
-        if(bs->dirty_tracking != 0) {
+        if (bs->dirty_tracking != 0) {
             qemu_free(bs->dirty_bitmap);
             bs->dirty_tracking = enable;
-	}
+        }
     }
 }
 
 int bdrv_get_dirty(BlockDriverState *bs, int64_t sector)
 {
     int64_t chunk = sector / (int64_t)SECTORS_PER_DIRTY_CHUNK;
-    
-    if(bs->dirty_bitmap != NULL && 
-       (sector << SECTOR_BITS) <= bdrv_getlength(bs)) {
+
+    if (bs->dirty_bitmap != NULL &&
+        (sector << SECTOR_BITS) <= bdrv_getlength(bs)) {
         return bs->dirty_bitmap[chunk];
     } else {
         return 0;
     }
 }
 
-void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector, 
-		      int nr_sectors)
+void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector,
+                      int nr_sectors)
 {
     set_dirty_bitmap(bs, cur_sector, nr_sectors, 0);
 }
diff --git a/block.h b/block.h
index 2d4f066..85d231d 100644
--- a/block.h
+++ b/block.h
@@ -190,7 +190,7 @@  int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
 
 void bdrv_set_dirty_tracking(BlockDriverState *bs, int enable);
 int bdrv_get_dirty(BlockDriverState *bs, int64_t sector);
-void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector, 
-		      int nr_sectors);
+void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector,
+                      int nr_sectors);
 int bdrv_get_sectors_per_chunk(void);
 #endif