Patchwork [1/6] Fix coding style

login
register
mail settings
Submitter Pierre Riteau
Date Nov. 26, 2009, 6:44 p.m.
Message ID <1259261046-32650-2-git-send-email-Pierre.Riteau@irisa.fr>
Download mbox | patch
Permalink /patch/39586/
State New
Headers show

Comments

Pierre Riteau - Nov. 26, 2009, 6:44 p.m.
Signed-off-by: Pierre Riteau <Pierre.Riteau@irisa.fr>
---
 block-migration.c |  366 ++++++++++++++++++++++++++---------------------------
 block-migration.h |    2 +-
 savevm.c          |   41 +++---
 3 files changed, 200 insertions(+), 209 deletions(-)

Patch

diff --git a/block-migration.c b/block-migration.c
index 09771ed..0cb162a 100644
--- a/block-migration.c
+++ b/block-migration.c
@@ -21,23 +21,23 @@ 
 #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
 
 #define MAX_IS_ALLOCATED_SEARCH 65536
-#define MAX_BLOCKS_READ 10000
-#define BLOCKS_READ_CHANGE 100
-#define INITIAL_BLOCKS_READ 100
+#define MAX_BLOCKS_READ         10000
+#define BLOCKS_READ_CHANGE      100
+#define INITIAL_BLOCKS_READ     100
 
 //#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
 
@@ -68,87 +68,87 @@  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, 
+
+    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 */
+
+    /* we going to transfer 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) {
+    cur_sector &= ~((int64_t)block_mig_state->sectors_per_block - 1);
+
+    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,90 +157,86 @@  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, 
+
+    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 */
+
+    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 */
     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);
-  
+    qemu_put_be64(f, (cur_sector << SECTOR_BITS) | BLK_MIG_FLAG_DEVICE_BLOCK);
+
     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);
-  
+
+    /* Device name */
+    qemu_put_be64(f, (blk->sector << SECTOR_BITS) | BLK_MIG_FLAG_DEVICE_BLOCK);
+
     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);
-  
+
+    qemu_put_buffer(f, blk->buf, BLOCK_SIZE);
+
     return;
 }
 
@@ -251,10 +247,10 @@  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;
 }
 
@@ -262,35 +258,35 @@  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;
 }
 
@@ -299,14 +295,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 +310,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,70 +325,70 @@  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, 
+
+    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) {
                 }
-		
+
                 /* device name */
-                qemu_put_be64(f,(sector << SECTOR_BITS) 
+                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;
-            }  
+            }
         }
     }
-    
+
     return;
 }
 
 static void flush_blks(QEMUFile* f)
 {
     BlkMigBlock *blk, *tmp;
-    
-    dprintf("%s Enter submitted %d read_done %d transfered\n", __FUNCTION__, 
+
+    dprintf("%s Enter submitted %d read_done %d transfered\n", __FUNCTION__,
             submitted, read_done, transfered);
-  
-    for(blk = block_mig_state->first_blk; 
+
+    for (blk = block_mig_state->first_blk;
         blk != NULL && !qemu_file_rate_limit(f); blk = tmp) {
         send_blk(f, blk);
-    
+
         tmp = 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;
@@ -402,71 +397,72 @@  static void flush_blks(QEMUFile* f)
 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) < 
+    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*/
+
+        if (ret == 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);
+
         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 +473,40 @@  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);
             }
-        } else if(flags & BLK_MIG_FLAG_EOS) {
-	    
+        } else if (flags & BLK_MIG_FLAG_EOS) {
+
         } else {
             printf("Unknown flags\n");
         }
-    } while(!(flags & BLK_MIG_FLAG_EOS));
-  
+    } while (!(flags & BLK_MIG_FLAG_EOS));
+
     qemu_free(buf);
 
     return 0;
@@ -525,33 +518,30 @@  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..9961abd 100644
--- a/block-migration.h
+++ b/block-migration.h
@@ -23,7 +23,7 @@  typedef struct BlkMigDevState {
     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/savevm.c b/savevm.c
index 4668843..e875e16 100644
--- a/savevm.c
+++ b/savevm.c
@@ -264,11 +264,11 @@  QEMUFile *qemu_popen(FILE *stdio_file, const char *mode)
 
     s->stdio_file = stdio_file;
 
-    if(mode[0] == 'r') {
-        s->file = qemu_fopen_ops(s, NULL, stdio_get_buffer, stdio_pclose, 
+    if (mode[0] == 'r') {
+        s->file = qemu_fopen_ops(s, NULL, stdio_get_buffer, stdio_pclose,
 				 NULL, NULL, NULL);
     } else {
-        s->file = qemu_fopen_ops(s, stdio_put_buffer, NULL, stdio_pclose, 
+        s->file = qemu_fopen_ops(s, stdio_put_buffer, NULL, stdio_pclose,
 				 NULL, NULL, NULL);
     }
     return s->file;
@@ -279,7 +279,7 @@  QEMUFile *qemu_popen_cmd(const char *command, const char *mode)
     FILE *popen_file;
 
     popen_file = popen(command, mode);
-    if(popen_file == NULL) {
+    if (popen_file == NULL) {
         return NULL;
     }
 
@@ -313,11 +313,11 @@  QEMUFile *qemu_fdopen(int fd, const char *mode)
     if (!s->stdio_file)
         goto fail;
 
-    if(mode[0] == 'r') {
-        s->file = qemu_fopen_ops(s, NULL, stdio_get_buffer, stdio_fclose, 
+    if (mode[0] == 'r') {
+        s->file = qemu_fopen_ops(s, NULL, stdio_get_buffer, stdio_fclose,
 				 NULL, NULL, NULL);
     } else {
-        s->file = qemu_fopen_ops(s, stdio_put_buffer, NULL, stdio_fclose, 
+        s->file = qemu_fopen_ops(s, stdio_put_buffer, NULL, stdio_fclose,
 				 NULL, NULL, NULL);
     }
     return s->file;
@@ -332,7 +332,7 @@  QEMUFile *qemu_fopen_socket(int fd)
     QEMUFileSocket *s = qemu_mallocz(sizeof(QEMUFileSocket));
 
     s->fd = fd;
-    s->file = qemu_fopen_ops(s, NULL, socket_get_buffer, socket_close, 
+    s->file = qemu_fopen_ops(s, NULL, socket_get_buffer, socket_close,
 			     NULL, NULL, NULL);
     return s->file;
 }
@@ -369,12 +369,12 @@  QEMUFile *qemu_fopen(const char *filename, const char *mode)
     s->stdio_file = fopen(filename, mode);
     if (!s->stdio_file)
         goto fail;
-    
-    if(mode[0] == 'w') {
-        s->file = qemu_fopen_ops(s, file_put_buffer, NULL, stdio_fclose, 
+
+    if (mode[0] == 'w') {
+        s->file = qemu_fopen_ops(s, file_put_buffer, NULL, stdio_fclose,
 				 NULL, NULL, NULL);
     } else {
-        s->file = qemu_fopen_ops(s, NULL, file_get_buffer, stdio_fclose, 
+        s->file = qemu_fopen_ops(s, NULL, file_get_buffer, stdio_fclose,
 			       NULL, NULL, NULL);
     }
     return s->file;
@@ -403,7 +403,7 @@  static int bdrv_fclose(void *opaque)
 static QEMUFile *qemu_fopen_bdrv(BlockDriverState *bs, int is_writable)
 {
     if (is_writable)
-        return qemu_fopen_ops(bs, block_put_buffer, NULL, bdrv_fclose, 
+        return qemu_fopen_ops(bs, block_put_buffer, NULL, bdrv_fclose,
 			      NULL, NULL, NULL);
     return qemu_fopen_ops(bs, NULL, block_get_buffer, bdrv_fclose, NULL, NULL, NULL);
 }
@@ -605,8 +605,9 @@  int qemu_file_rate_limit(QEMUFile *f)
 
 size_t qemu_file_get_rate_limit(QEMUFile *f)
 {
-    if (f->get_rate_limit)
+    if (f->get_rate_limit) {
         return f->get_rate_limit(f->opaque);
+    }
 
     return 0;
 }
@@ -1125,7 +1126,7 @@  int vmstate_load_state(QEMUFile *f, const VMStateDescription *vmsd,
         if (ret)
             return ret;
     }
-    while(field->name) {
+    while (field->name) {
         if ((field->field_exists &&
              field->field_exists(opaque, version_id)) ||
             (!field->field_exists &&
@@ -1176,7 +1177,7 @@  void vmstate_save_state(QEMUFile *f, const VMStateDescription *vmsd,
     if (vmsd->pre_save) {
         vmsd->pre_save(opaque);
     }
-    while(field->name) {
+    while (field->name) {
         if (!field->field_exists ||
             field->field_exists(opaque, vmsd->version_id)) {
             void *base_addr = opaque + field->offset;
@@ -1241,12 +1242,12 @@  int qemu_savevm_state_begin(QEMUFile *f, int blk_enable, int shared)
     SaveStateEntry *se;
 
     QTAILQ_FOREACH(se, &savevm_handlers, entry) {
-        if(se->set_params == NULL) {
+        if (se->set_params == NULL) {
             continue;
-	}
-	se->set_params(blk_enable, shared, se->opaque);
+        }
+        se->set_params(blk_enable, shared, se->opaque);
     }
-    
+
     qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
     qemu_put_be32(f, QEMU_VM_FILE_VERSION);