Drop an unused variable (Samuel Thibault).

[qemu.git] / block.c

diff --git a/block.c b/block.c
index 12fc2ef456f9a24ce78b0aa480a4c12376f1d76a..ca8d8c1e8a1c4eaaedd4ef0d2d52597c1c7ffbf4 100644 (file)
--- a/block.c
+++ b/block.c
@@ -1,8 +1,8 @@
 /*
  * QEMU System Emulator block driver
 /*
  * QEMU System Emulator block driver

- * 
+ *

  * Copyright (c) 2003 Fabrice Bellard
  * Copyright (c) 2003 Fabrice Bellard

- * 
+ *

  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
  * in the Software without restriction, including without limitation the rights
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
  * in the Software without restriction, including without limitation the rights


@@ -21,7 +21,10 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */

-#include "vl.h"
+#include "qemu-common.h"
+#ifndef QEMU_IMG
+#include "console.h"
+#endif

 #include "block_int.h"
 
 #ifdef _BSD
 #include "block_int.h"
 
 #ifdef _BSD


@@ -48,29 +51,32 @@ static BlockDriverAIOCB *bdrv_aio_write_em(BlockDriverState *bs,
         int64_t sector_num, const uint8_t *buf, int nb_sectors,
         BlockDriverCompletionFunc *cb, void *opaque);
 static void bdrv_aio_cancel_em(BlockDriverAIOCB *acb);
         int64_t sector_num, const uint8_t *buf, int nb_sectors,
         BlockDriverCompletionFunc *cb, void *opaque);
 static void bdrv_aio_cancel_em(BlockDriverAIOCB *acb);

-static int bdrv_read_em(BlockDriverState *bs, int64_t sector_num, 
+static int bdrv_read_em(BlockDriverState *bs, int64_t sector_num,

                         uint8_t *buf, int nb_sectors);
 static int bdrv_write_em(BlockDriverState *bs, int64_t sector_num,
                          const uint8_t *buf, int nb_sectors);
 
                         uint8_t *buf, int nb_sectors);
 static int bdrv_write_em(BlockDriverState *bs, int64_t sector_num,
                          const uint8_t *buf, int nb_sectors);
 

-static BlockDriverState *bdrv_first;
+BlockDriverState *bdrv_first;

 static BlockDriver *first_drv;
 
 static BlockDriver *first_drv;
 

-#ifdef _WIN32
-#define PATH_SEP '\\'
-#else
-#define PATH_SEP '/'
-#endif
-

 int path_is_absolute(const char *path)
 {
     const char *p;
 int path_is_absolute(const char *path)
 {
     const char *p;

+#ifdef _WIN32
+    /* specific case for names like: "\\.\d:" */
+    if (*path == '/' || *path == '\\')
+        return 1;
+#endif

     p = strchr(path, ':');
     if (p)
         p++;
     else
         p = path;
     p = strchr(path, ':');
     if (p)
         p++;
     else
         p = path;

-    return (*p == PATH_SEP);
+#ifdef _WIN32
+    return (*p == '/' || *p == '\\');
+#else
+    return (*p == '/');
+#endif

 }
 
 /* if filename is absolute, just copy it to dest. Otherwise, build a
 }
 
 /* if filename is absolute, just copy it to dest. Otherwise, build a


@@ -93,7 +99,15 @@ void path_combine(char *dest, int dest_size,
             p++;
         else
             p = base_path;
             p++;
         else
             p = base_path;

-        p1 = strrchr(base_path, PATH_SEP);
+        p1 = strrchr(base_path, '/');
+#ifdef _WIN32
+        {
+            const char *p2;
+            p2 = strrchr(base_path, '\\');
+            if (!p1 || p2 > p1)
+                p1 = p2;
+        }
+#endif

         if (p1)
             p1++;
         else
         if (p1)
             p1++;
         else


@@ -110,7 +124,7 @@ void path_combine(char *dest, int dest_size,
 }
 
 
 }
 
 

-void bdrv_register(BlockDriver *bdrv)
+static void bdrv_register(BlockDriver *bdrv)

 {
     if (!bdrv->bdrv_aio_read) {
         /* add AIO emulation layer */
 {
     if (!bdrv->bdrv_aio_read) {
         /* add AIO emulation layer */


@@ -156,7 +170,7 @@ BlockDriver *bdrv_find_format(const char *format_name)
     return NULL;
 }
 
     return NULL;
 }
 

-int bdrv_create(BlockDriver *drv, 
+int bdrv_create(BlockDriver *drv,

                 const char *filename, int64_t size_in_sectors,
                 const char *backing_file, int flags)
 {
                 const char *filename, int64_t size_in_sectors,
                 const char *backing_file, int flags)
 {


@@ -168,7 +182,10 @@ int bdrv_create(BlockDriver *drv,
 #ifdef _WIN32
 void get_tmp_filename(char *filename, int size)
 {
 #ifdef _WIN32
 void get_tmp_filename(char *filename, int size)
 {

-    tmpnam(filename);
+    char temp_dir[MAX_PATH];
+
+    GetTempPath(MAX_PATH, temp_dir);
+    GetTempFileName(temp_dir, "qem", 0, filename);

 }
 #else
 void get_tmp_filename(char *filename, int size)
 }
 #else
 void get_tmp_filename(char *filename, int size)


@@ -188,10 +205,10 @@ static int is_windows_drive_prefix(const char *filename)
              (filename[0] >= 'A' && filename[0] <= 'Z')) &&
             filename[1] == ':');
 }
              (filename[0] >= 'A' && filename[0] <= 'Z')) &&
             filename[1] == ':');
 }

-    
+

 static int is_windows_drive(const char *filename)
 {
 static int is_windows_drive(const char *filename)
 {

-    if (is_windows_drive_prefix(filename) && 
+    if (is_windows_drive_prefix(filename) &&

         filename[2] == '\0')
         return 1;
     if (strstart(filename, "\\\\.\\", NULL) ||
         filename[2] == '\0')
         return 1;
     if (strstart(filename, "\\\\.\\", NULL) ||


@@ -222,7 +239,7 @@ static BlockDriver *find_protocol(const char *filename)
     memcpy(protocol, filename, len);
     protocol[len] = '\0';
     for(drv1 = first_drv; drv1 != NULL; drv1 = drv1->next) {
     memcpy(protocol, filename, len);
     protocol[len] = '\0';
     for(drv1 = first_drv; drv1 != NULL; drv1 = drv1->next) {

-        if (drv1->protocol_name && 
+        if (drv1->protocol_name &&

             !strcmp(drv1->protocol_name, protocol))
             return drv1;
     }
             !strcmp(drv1->protocol_name, protocol))
             return drv1;
     }


@@ -237,7 +254,7 @@ static BlockDriver *find_image_format(const char *filename)
     BlockDriver *drv1, *drv;
     uint8_t buf[2048];
     BlockDriverState *bs;
     BlockDriver *drv1, *drv;
     uint8_t buf[2048];
     BlockDriverState *bs;

-    
+

     /* detect host devices. By convention, /dev/cdrom[N] is always
        recognized as a host CDROM */
     if (strstart(filename, "/dev/cdrom", NULL))
     /* detect host devices. By convention, /dev/cdrom[N] is always
        recognized as a host CDROM */
     if (strstart(filename, "/dev/cdrom", NULL))


@@ -248,13 +265,13 @@ static BlockDriver *find_image_format(const char *filename)
 #else
     {
         struct stat st;
 #else
     {
         struct stat st;

-        if (stat(filename, &st) >= 0 && 
+        if (stat(filename, &st) >= 0 &&

             (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode))) {
             return &bdrv_host_device;
         }
     }
 #endif
             (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode))) {
             return &bdrv_host_device;
         }
     }
 #endif

-    
+

     drv = find_protocol(filename);
     /* no need to test disk image formats for vvfat */
     if (drv == &bdrv_vvfat)
     drv = find_protocol(filename);
     /* no need to test disk image formats for vvfat */
     if (drv == &bdrv_vvfat)


@@ -308,9 +325,9 @@ int bdrv_open2(BlockDriverState *bs, const char *filename, int flags,
                BlockDriver *drv)
 {
     int ret, open_flags;
                BlockDriver *drv)
 {
     int ret, open_flags;

-    char tmp_filename[1024];
-    char backing_filename[1024];
-    
+    char tmp_filename[PATH_MAX];
+    char backing_filename[PATH_MAX];
+

     bs->read_only = 0;
     bs->is_temporary = 0;
     bs->encrypted = 0;
     bs->read_only = 0;
     bs->is_temporary = 0;
     bs->encrypted = 0;


@@ -318,7 +335,7 @@ int bdrv_open2(BlockDriverState *bs, const char *filename, int flags,
     if (flags & BDRV_O_SNAPSHOT) {
         BlockDriverState *bs1;
         int64_t total_size;
     if (flags & BDRV_O_SNAPSHOT) {
         BlockDriverState *bs1;
         int64_t total_size;

-        
+

         /* if snapshot, we create a temporary backing file and open it
            instead of opening 'filename' directly */
 
         /* if snapshot, we create a temporary backing file and open it
            instead of opening 'filename' directly */
 


@@ -333,10 +350,11 @@ int bdrv_open2(BlockDriverState *bs, const char *filename, int flags,
         }
         total_size = bdrv_getlength(bs1) >> SECTOR_BITS;
         bdrv_delete(bs1);
         }
         total_size = bdrv_getlength(bs1) >> SECTOR_BITS;
         bdrv_delete(bs1);

-        
+

         get_tmp_filename(tmp_filename, sizeof(tmp_filename));
         get_tmp_filename(tmp_filename, sizeof(tmp_filename));

-        if (bdrv_create(&bdrv_qcow2, tmp_filename, 
-                        total_size, filename, 0) < 0) {
+        realpath(filename, backing_filename);
+        if (bdrv_create(&bdrv_qcow2, tmp_filename,
+                        total_size, backing_filename, 0) < 0) {

             return -1;
         }
         filename = tmp_filename;
             return -1;
         }
         filename = tmp_filename;


@@ -479,7 +497,7 @@ int bdrv_commit(BlockDriverState *bs)
 }
 
 /* return < 0 if error. See bdrv_write() for the return codes */
 }
 
 /* return < 0 if error. See bdrv_write() for the return codes */

-int bdrv_read(BlockDriverState *bs, int64_t sector_num, 
+int bdrv_read(BlockDriverState *bs, int64_t sector_num,

               uint8_t *buf, int nb_sectors)
 {
     BlockDriver *drv = bs->drv;
               uint8_t *buf, int nb_sectors)
 {
     BlockDriver *drv = bs->drv;


@@ -510,13 +528,13 @@ int bdrv_read(BlockDriverState *bs, int64_t sector_num,
     }
 }
 
     }
 }
 

-/* Return < 0 if error. Important errors are: 
+/* Return < 0 if error. Important errors are:

   -EIO         generic I/O error (may happen for all errors)
   -ENOMEDIUM   No media inserted.
   -EINVAL      Invalid sector number or nb_sectors
   -EACCES      Trying to write a read-only device
 */
   -EIO         generic I/O error (may happen for all errors)
   -ENOMEDIUM   No media inserted.
   -EINVAL      Invalid sector number or nb_sectors
   -EACCES      Trying to write a read-only device
 */

-int bdrv_write(BlockDriverState *bs, int64_t sector_num, 
+int bdrv_write(BlockDriverState *bs, int64_t sector_num,

                const uint8_t *buf, int nb_sectors)
 {
     BlockDriver *drv = bs->drv;
                const uint8_t *buf, int nb_sectors)
 {
     BlockDriver *drv = bs->drv;


@@ -525,7 +543,7 @@ int bdrv_write(BlockDriverState *bs, int64_t sector_num,
     if (bs->read_only)
         return -EACCES;
     if (sector_num == 0 && bs->boot_sector_enabled && nb_sectors > 0) {
     if (bs->read_only)
         return -EACCES;
     if (sector_num == 0 && bs->boot_sector_enabled && nb_sectors > 0) {

-        memcpy(bs->boot_sector_data, buf, 512);   
+        memcpy(bs->boot_sector_data, buf, 512);

     }
     if (drv->bdrv_pwrite) {
         int ret, len;
     }
     if (drv->bdrv_pwrite) {
         int ret, len;


@@ -542,7 +560,7 @@ int bdrv_write(BlockDriverState *bs, int64_t sector_num,
     }
 }
 
     }
 }
 

-static int bdrv_pread_em(BlockDriverState *bs, int64_t offset, 
+static int bdrv_pread_em(BlockDriverState *bs, int64_t offset,

                          uint8_t *buf, int count1)
 {
     uint8_t tmp_buf[SECTOR_SIZE];
                          uint8_t *buf, int count1)
 {
     uint8_t tmp_buf[SECTOR_SIZE];


@@ -586,7 +604,7 @@ static int bdrv_pread_em(BlockDriverState *bs, int64_t offset,
     return count1;
 }
 
     return count1;
 }
 

-static int bdrv_pwrite_em(BlockDriverState *bs, int64_t offset, 
+static int bdrv_pwrite_em(BlockDriverState *bs, int64_t offset,

                           const uint8_t *buf, int count1)
 {
     uint8_t tmp_buf[SECTOR_SIZE];
                           const uint8_t *buf, int count1)
 {
     uint8_t tmp_buf[SECTOR_SIZE];


@@ -635,9 +653,9 @@ static int bdrv_pwrite_em(BlockDriverState *bs, int64_t offset,
 }
 
 /**
 }
 
 /**

- * Read with byte offsets (needed only for file protocols) 
+ * Read with byte offsets (needed only for file protocols)

  */
  */

-int bdrv_pread(BlockDriverState *bs, int64_t offset, 
+int bdrv_pread(BlockDriverState *bs, int64_t offset,

                void *buf1, int count1)
 {
     BlockDriver *drv = bs->drv;
                void *buf1, int count1)
 {
     BlockDriver *drv = bs->drv;


@@ -649,10 +667,10 @@ int bdrv_pread(BlockDriverState *bs, int64_t offset,
     return drv->bdrv_pread(bs, offset, buf1, count1);
 }
 
     return drv->bdrv_pread(bs, offset, buf1, count1);
 }
 

-/** 
- * Write with byte offsets (needed only for file protocols) 
+/**
+ * Write with byte offsets (needed only for file protocols)

  */
  */

-int bdrv_pwrite(BlockDriverState *bs, int64_t offset, 
+int bdrv_pwrite(BlockDriverState *bs, int64_t offset,

                 const void *buf1, int count1)
 {
     BlockDriver *drv = bs->drv;
                 const void *buf1, int count1)
 {
     BlockDriver *drv = bs->drv;


@@ -714,7 +732,7 @@ void bdrv_set_boot_sector(BlockDriverState *bs, const uint8_t *data, int size)
     memset(bs->boot_sector_data + size, 0, 512 - size);
 }
 
     memset(bs->boot_sector_data + size, 0, 512 - size);
 }
 

-void bdrv_set_geometry_hint(BlockDriverState *bs, 
+void bdrv_set_geometry_hint(BlockDriverState *bs,

                             int cyls, int heads, int secs)
 {
     bs->cyls = cyls;
                             int cyls, int heads, int secs)
 {
     bs->cyls = cyls;


@@ -734,7 +752,7 @@ void bdrv_set_translation_hint(BlockDriverState *bs, int translation)
     bs->translation = translation;
 }
 
     bs->translation = translation;
 }
 

-void bdrv_get_geometry_hint(BlockDriverState *bs, 
+void bdrv_get_geometry_hint(BlockDriverState *bs,

                             int *pcyls, int *pheads, int *psecs)
 {
     *pcyls = bs->cyls;
                             int *pcyls, int *pheads, int *psecs)
 {
     *pcyls = bs->cyls;


@@ -763,7 +781,7 @@ int bdrv_is_read_only(BlockDriverState *bs)
 }
 
 /* XXX: no longer used */
 }
 
 /* XXX: no longer used */

-void bdrv_set_change_cb(BlockDriverState *bs, 
+void bdrv_set_change_cb(BlockDriverState *bs,

                         void (*change_cb)(void *opaque), void *opaque)
 {
     bs->change_cb = change_cb;
                         void (*change_cb)(void *opaque), void *opaque)
 {
     bs->change_cb = change_cb;


@@ -801,7 +819,7 @@ void bdrv_get_format(BlockDriverState *bs, char *buf, int buf_size)
     }
 }
 
     }
 }
 

-void bdrv_iterate_format(void (*it)(void *opaque, const char *name), 
+void bdrv_iterate_format(void (*it)(void *opaque, const char *name),

                          void *opaque)
 {
     BlockDriver *drv;
                          void *opaque)
 {
     BlockDriver *drv;


@@ -844,6 +862,7 @@ void bdrv_flush(BlockDriverState *bs)
         bdrv_flush(bs->backing_hd);
 }
 
         bdrv_flush(bs->backing_hd);
 }
 

+#ifndef QEMU_IMG

 void bdrv_info(void)
 {
     BlockDriverState *bs;
 void bdrv_info(void)
 {
     BlockDriverState *bs;


@@ -867,9 +886,12 @@ void bdrv_info(void)
             term_printf(" locked=%d", bs->locked);
         }
         if (bs->drv) {
             term_printf(" locked=%d", bs->locked);
         }
         if (bs->drv) {

-            term_printf(" file=%s", bs->filename);
-            if (bs->backing_file[0] != '\0')
-                term_printf(" backing_file=%s", bs->backing_file);
+            term_printf(" file=");
+           term_print_filename(bs->filename);
+            if (bs->backing_file[0] != '\0') {
+                term_printf(" backing_file=");
+               term_print_filename(bs->backing_file);
+           }

             term_printf(" ro=%d", bs->read_only);
             term_printf(" drv=%s", bs->drv->format_name);
             if (bs->encrypted)
             term_printf(" ro=%d", bs->read_only);
             term_printf(" drv=%s", bs->drv->format_name);
             if (bs->encrypted)


@@ -880,8 +902,9 @@ void bdrv_info(void)
         term_printf("\n");
     }
 }
         term_printf("\n");
     }
 }

+#endif

 
 

-void bdrv_get_backing_filename(BlockDriverState *bs, 
+void bdrv_get_backing_filename(BlockDriverState *bs,

                                char *filename, int filename_size)
 {
     if (!bs->backing_hd) {
                                char *filename, int filename_size)
 {
     if (!bs->backing_hd) {


@@ -891,7 +914,7 @@ void bdrv_get_backing_filename(BlockDriverState *bs,
     }
 }
 
     }
 }
 

-int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num, 
+int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,

                           const uint8_t *buf, int nb_sectors)
 {
     BlockDriver *drv = bs->drv;
                           const uint8_t *buf, int nb_sectors)
 {
     BlockDriver *drv = bs->drv;


@@ -901,7 +924,7 @@ int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
         return -ENOTSUP;
     return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);
 }
         return -ENOTSUP;
     return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);
 }

-    
+

 int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
 {
     BlockDriver *drv = bs->drv;
 int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
 {
     BlockDriver *drv = bs->drv;


@@ -916,7 +939,7 @@ int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
 /**************************************************************/
 /* handling of snapshots */
 
 /**************************************************************/
 /* handling of snapshots */
 

-int bdrv_snapshot_create(BlockDriverState *bs, 
+int bdrv_snapshot_create(BlockDriverState *bs,

                          QEMUSnapshotInfo *sn_info)
 {
     BlockDriver *drv = bs->drv;
                          QEMUSnapshotInfo *sn_info)
 {
     BlockDriver *drv = bs->drv;


@@ -927,7 +950,7 @@ int bdrv_snapshot_create(BlockDriverState *bs,
     return drv->bdrv_snapshot_create(bs, sn_info);
 }
 
     return drv->bdrv_snapshot_create(bs, sn_info);
 }
 

-int bdrv_snapshot_goto(BlockDriverState *bs, 
+int bdrv_snapshot_goto(BlockDriverState *bs,

                        const char *snapshot_id)
 {
     BlockDriver *drv = bs->drv;
                        const char *snapshot_id)
 {
     BlockDriver *drv = bs->drv;


@@ -948,7 +971,7 @@ int bdrv_snapshot_delete(BlockDriverState *bs, const char *snapshot_id)
     return drv->bdrv_snapshot_delete(bs, snapshot_id);
 }
 
     return drv->bdrv_snapshot_delete(bs, snapshot_id);
 }
 

-int bdrv_snapshot_list(BlockDriverState *bs, 
+int bdrv_snapshot_list(BlockDriverState *bs,

                        QEMUSnapshotInfo **psn_info)
 {
     BlockDriver *drv = bs->drv;
                        QEMUSnapshotInfo **psn_info)
 {
     BlockDriver *drv = bs->drv;


@@ -973,12 +996,12 @@ char *get_human_readable_size(char *buf, int buf_size, int64_t size)
         base = 1024;
         for(i = 0; i < NB_SUFFIXES; i++) {
             if (size < (10 * base)) {
         base = 1024;
         for(i = 0; i < NB_SUFFIXES; i++) {
             if (size < (10 * base)) {

-                snprintf(buf, buf_size, "%0.1f%c", 
+                snprintf(buf, buf_size, "%0.1f%c",

                          (double)size / base,
                          suffixes[i]);
                 break;
             } else if (size < (1000 * base) || i == (NB_SUFFIXES - 1)) {
                          (double)size / base,
                          suffixes[i]);
                 break;
             } else if (size < (1000 * base) || i == (NB_SUFFIXES - 1)) {

-                snprintf(buf, buf_size, "%" PRId64 "%c", 
+                snprintf(buf, buf_size, "%" PRId64 "%c",

                          ((size + (base >> 1)) / base),
                          suffixes[i]);
                 break;
                          ((size + (base >> 1)) / base),
                          suffixes[i]);
                 break;


@@ -992,30 +1015,38 @@ char *get_human_readable_size(char *buf, int buf_size, int64_t size)
 char *bdrv_snapshot_dump(char *buf, int buf_size, QEMUSnapshotInfo *sn)
 {
     char buf1[128], date_buf[128], clock_buf[128];
 char *bdrv_snapshot_dump(char *buf, int buf_size, QEMUSnapshotInfo *sn)
 {
     char buf1[128], date_buf[128], clock_buf[128];

+#ifdef _WIN32
+    struct tm *ptm;
+#else

     struct tm tm;
     struct tm tm;

+#endif

     time_t ti;
     int64_t secs;
 
     if (!sn) {
     time_t ti;
     int64_t secs;
 
     if (!sn) {

-        snprintf(buf, buf_size, 
-                 "%-10s%-20s%7s%20s%15s", 
+        snprintf(buf, buf_size,
+                 "%-10s%-20s%7s%20s%15s",

                  "ID", "TAG", "VM SIZE", "DATE", "VM CLOCK");
     } else {
         ti = sn->date_sec;
                  "ID", "TAG", "VM SIZE", "DATE", "VM CLOCK");
     } else {
         ti = sn->date_sec;

-#ifndef _WIN32
+#ifdef _WIN32
+        ptm = localtime(&ti);
+        strftime(date_buf, sizeof(date_buf),
+                 "%Y-%m-%d %H:%M:%S", ptm);
+#else

         localtime_r(&ti, &tm);
         localtime_r(&ti, &tm);

-#endif

         strftime(date_buf, sizeof(date_buf),
                  "%Y-%m-%d %H:%M:%S", &tm);
         strftime(date_buf, sizeof(date_buf),
                  "%Y-%m-%d %H:%M:%S", &tm);

+#endif

         secs = sn->vm_clock_nsec / 1000000000;
         snprintf(clock_buf, sizeof(clock_buf),
                  "%02d:%02d:%02d.%03d",
                  (int)(secs / 3600),
                  (int)((secs / 60) % 60),
         secs = sn->vm_clock_nsec / 1000000000;
         snprintf(clock_buf, sizeof(clock_buf),
                  "%02d:%02d:%02d.%03d",
                  (int)(secs / 3600),
                  (int)((secs / 60) % 60),

-                 (int)(secs % 60), 
+                 (int)(secs % 60),

                  (int)((sn->vm_clock_nsec / 1000000) % 1000));
         snprintf(buf, buf_size,
                  (int)((sn->vm_clock_nsec / 1000000) % 1000));
         snprintf(buf, buf_size,

-                 "%-10s%-20s%7s%20s%15s", 
+                 "%-10s%-20s%7s%20s%15s",

                  sn->id_str, sn->name,
                  get_human_readable_size(buf1, sizeof(buf1), sn->vm_state_size),
                  date_buf,
                  sn->id_str, sn->name,
                  get_human_readable_size(buf1, sizeof(buf1), sn->vm_state_size),
                  date_buf,


@@ -1036,7 +1067,7 @@ BlockDriverAIOCB *bdrv_aio_read(BlockDriverState *bs, int64_t sector_num,
 
     if (!drv)
         return NULL;
 
     if (!drv)
         return NULL;

-    
+

     /* XXX: we assume that nb_sectors == 0 is suppored by the async read */
     if (sector_num == 0 && bs->boot_sector_enabled && nb_sectors > 0) {
         memcpy(buf, bs->boot_sector_data, 512);
     /* XXX: we assume that nb_sectors == 0 is suppored by the async read */
     if (sector_num == 0 && bs->boot_sector_enabled && nb_sectors > 0) {
         memcpy(buf, bs->boot_sector_data, 512);


@@ -1059,7 +1090,7 @@ BlockDriverAIOCB *bdrv_aio_write(BlockDriverState *bs, int64_t sector_num,
     if (bs->read_only)
         return NULL;
     if (sector_num == 0 && bs->boot_sector_enabled && nb_sectors > 0) {
     if (bs->read_only)
         return NULL;
     if (sector_num == 0 && bs->boot_sector_enabled && nb_sectors > 0) {

-        memcpy(bs->boot_sector_data, buf, 512);   
+        memcpy(bs->boot_sector_data, buf, 512);

     }
 
     return drv->bdrv_aio_write(bs, sector_num, buf, nb_sectors, cb, opaque);
     }
 
     return drv->bdrv_aio_write(bs, sector_num, buf, nb_sectors, cb, opaque);


@@ -1076,7 +1107,7 @@ void bdrv_aio_cancel(BlockDriverAIOCB *acb)
 /**************************************************************/
 /* async block device emulation */
 
 /**************************************************************/
 /* async block device emulation */
 

-#ifdef QEMU_TOOL
+#ifdef QEMU_IMG

 static BlockDriverAIOCB *bdrv_aio_read_em(BlockDriverState *bs,
         int64_t sector_num, uint8_t *buf, int nb_sectors,
         BlockDriverCompletionFunc *cb, void *opaque)
 static BlockDriverAIOCB *bdrv_aio_read_em(BlockDriverState *bs,
         int64_t sector_num, uint8_t *buf, int nb_sectors,
         BlockDriverCompletionFunc *cb, void *opaque)


@@ -1146,7 +1177,7 @@ static void bdrv_aio_cancel_em(BlockDriverAIOCB *blockacb)
     qemu_bh_cancel(acb->bh);
     qemu_aio_release(acb);
 }
     qemu_bh_cancel(acb->bh);
     qemu_aio_release(acb);
 }

-#endif /* !QEMU_TOOL */
+#endif /* !QEMU_IMG */

 
 /**************************************************************/
 /* sync block device emulation */
 
 /**************************************************************/
 /* sync block device emulation */


@@ -1158,7 +1189,7 @@ static void bdrv_rw_em_cb(void *opaque, int ret)
 
 #define NOT_DONE 0x7fffffff
 
 
 #define NOT_DONE 0x7fffffff
 

-static int bdrv_read_em(BlockDriverState *bs, int64_t sector_num, 
+static int bdrv_read_em(BlockDriverState *bs, int64_t sector_num,

                         uint8_t *buf, int nb_sectors)
 {
     int async_ret;
                         uint8_t *buf, int nb_sectors)
 {
     int async_ret;


@@ -1166,7 +1197,7 @@ static int bdrv_read_em(BlockDriverState *bs, int64_t sector_num,
 
     async_ret = NOT_DONE;
     qemu_aio_wait_start();
 
     async_ret = NOT_DONE;
     qemu_aio_wait_start();

-    acb = bdrv_aio_read(bs, sector_num, buf, nb_sectors, 
+    acb = bdrv_aio_read(bs, sector_num, buf, nb_sectors,

                         bdrv_rw_em_cb, &async_ret);
     if (acb == NULL) {
         qemu_aio_wait_end();
                         bdrv_rw_em_cb, &async_ret);
     if (acb == NULL) {
         qemu_aio_wait_end();


@@ -1187,7 +1218,7 @@ static int bdrv_write_em(BlockDriverState *bs, int64_t sector_num,
 
     async_ret = NOT_DONE;
     qemu_aio_wait_start();
 
     async_ret = NOT_DONE;
     qemu_aio_wait_start();

-    acb = bdrv_aio_write(bs, sector_num, buf, nb_sectors, 
+    acb = bdrv_aio_write(bs, sector_num, buf, nb_sectors,

                          bdrv_rw_em_cb, &async_ret);
     if (acb == NULL) {
         qemu_aio_wait_end();
                          bdrv_rw_em_cb, &async_ret);
     if (acb == NULL) {
         qemu_aio_wait_end();


@@ -1215,6 +1246,7 @@ void bdrv_init(void)
     bdrv_register(&bdrv_vpc);
     bdrv_register(&bdrv_vvfat);
     bdrv_register(&bdrv_qcow2);
     bdrv_register(&bdrv_vpc);
     bdrv_register(&bdrv_vvfat);
     bdrv_register(&bdrv_qcow2);

+    bdrv_register(&bdrv_parallels);

 }
 
 void *qemu_aio_get(BlockDriverState *bs, BlockDriverCompletionFunc *cb,
 }
 
 void *qemu_aio_get(BlockDriverState *bs, BlockDriverCompletionFunc *cb,


@@ -1266,7 +1298,7 @@ int bdrv_is_inserted(BlockDriverState *bs)
 
 /**
  * Return TRUE if the media changed since the last call to this
 
 /**
  * Return TRUE if the media changed since the last call to this

- * function. It is currently only used for floppy disks 
+ * function. It is currently only used for floppy disks

  */
 int bdrv_media_changed(BlockDriverState *bs)
 {
  */
 int bdrv_media_changed(BlockDriverState *bs)
 {