[Qemu-devel] [PATCH] Snapshot block device support

[Rusty Russell <rusty@rustcorp.com.au>]

Hi Fabrice,

	I haven't got the IDE emulation to work for me yet (is it
supposed to yet?), but this allows the "-snapshot" option and "C-a s"
to commit the disks.  The blocks which change are committed to backing
store, and a bitmap of changed blocks is kept.

Diff + new test file below.
Rusty.
--
  Anyone who quotes me in their sig is an idiot. -- Rusty Russell.

tests/test_block.c:
================
#define _GNU_SOURCE /* For lseek64 */
#include "../block.c"

#define NUM_SECTORS 2560

static int memisset(const void *mem, int c, size_t len)
{
	size_t i;

	for (i = 0; i < len; i++)
		if (((unsigned char *)mem)[i] != (unsigned char)c)
			return 0;
	return 1;
}

static int read_test(BlockDriverState *bs, unsigned char contents[])
{
	int i;
	unsigned char sector[512];
	unsigned char ten_sectors[5120];

	/* Single read test. */
	for (i = 0; i < NUM_SECTORS; i++) {
		if (bdrv_read(bs, i, sector, 1) != 0)
			return 0;
		if (!memisset(sector, contents[i], 512))
			return 0;
	}

	/* Multiple read test. */
	for (i = 0; i < NUM_SECTORS - 10; i++) {
		int j;
		if (bdrv_read(bs, i, ten_sectors, 10) != 0)
			return 0;

		for (j = 0; j < 10; j++)
			if (!memisset(ten_sectors + j*512, contents[i+j], 512))
				return 0;
	}
	return 1;
}

int main(int argc, char *argv[])
{
	int fd, i;
	unsigned char sector[512];
	unsigned char ten_sectors[5120];
	unsigned char contents[NUM_SECTORS];
	BlockDriverState *bs;

	fd = open(argv[1], O_RDWR|O_CREAT|O_TRUNC, 0600);
	for (i = 0; i < NUM_SECTORS; i++) {
		memset(sector, i, sizeof(sector));
		if (write(fd, sector, sizeof(sector)) != sizeof(sector))
			abort();
		contents[i] = i;
	}
	close(fd);

	bs = bdrv_open(argv[1], argv[2] ? 1 : 0);

	/* Test data is as we expect. */
	if (!read_test(bs, contents))
		abort();

	/* Single write test. */
	memset(sector, 2, sizeof(sector));
	if (bdrv_write(bs, 0, sector, 1) != 0)
		abort();
	contents[0] = 2;
	if (!read_test(bs, contents))
		abort();

	memset(sector, 0, sizeof(sector));
	if (bdrv_read(bs, 0, sector, 1) != 0)
		abort();
	if (!memisset(sector, 2, sizeof(sector)))
		abort();

	/* Random test */
	for (i = 0; i < 10000; i++) {
		int j;
		int num_sectors = (random() % 10) + 1;
		int sect_start = random() % (NUM_SECTORS - num_sectors);

		if (random() % 2) {
			if (bdrv_read(bs,sect_start,ten_sectors,num_sectors))
				abort();
			for (j = 0; j < num_sectors; j++)
				if (!memisset(ten_sectors + j*512,
					      contents[sect_start + j],
					      512))
					abort();
		} else {
			for (j = 0; j < num_sectors; j++) {
				contents[sect_start + j] = random();
				memset(ten_sectors + j*512,
				       contents[sect_start + j],
				       512);
			}
			if (bdrv_write(bs,sect_start,ten_sectors,num_sectors))
				abort();
		}
	}

	if (!read_test(bs, contents))
		abort();

	if (argv[2]) {
		/* Test that it hasn't touched initial file. */
		fd = open(argv[1], O_RDONLY);
		if (fd < 0)
			abort();
		for (i = 0; i < NUM_SECTORS; i++) {
			if (read(fd, sector, sizeof(sector)) != sizeof(sector))
				abort();
			if (!memisset(sector, i, sizeof(sector)))
				abort();
		}
		close(fd);

		/* Test that commit works. */
		bdrv_commit(bs);
		fd = open(argv[1], O_RDONLY);
		if (fd < 0)
			abort();
		for (i = 0; i < NUM_SECTORS; i++) {
			if (read(fd, sector, sizeof(sector)) != sizeof(sector))
				abort();
			if (!memisset(sector, contents[i], sizeof(sector)))
				abort();
		}
		close(fd);
	}

	printf("All tests on %s%s passed!\n", argv[1],
	       argv[2] ? " (with undo)" : "");
	return 0;
}
================
Index: block.c
===================================================================
RCS file: /cvsroot/qemu/qemu/block.c,v
retrieving revision 1.2
diff -u -r1.2 block.c
--- block.c	30 Jun 2003 23:17:31 -0000	1.2
+++ block.c	2 Jul 2003 06:45:08 -0000
@@ -45,9 +45,14 @@
     int fd;
     int64_t total_sectors;
     int read_only;
+    const char *filename;
+
+    /* If snapshot set, this is nonnull and these are used. */
+    unsigned char *changes_map;
+    int changes_fd;
 };
 
-BlockDriverState *bdrv_open(const char *filename)
+BlockDriverState *bdrv_open(const char *filename, int snapshot)
 {
     BlockDriverState *bs;
     int fd;
@@ -56,12 +61,12 @@
     bs = malloc(sizeof(BlockDriverState));
     if(!bs)
         return NULL;
+
     bs->read_only = 0;
     fd = open(filename, O_RDWR);
     if (fd < 0) {
         fd = open(filename, O_RDONLY);
         if (fd < 0) {
-            close(fd);
             free(bs);
             return NULL;
         }
@@ -70,44 +75,176 @@
     size = lseek64(fd, 0, SEEK_END);
     bs->total_sectors = size / 512;
     bs->fd = fd;
+    bs->filename = filename;
+
+    if (snapshot) {
+	/* Lazy paging in of /dev/zero for changes bitmap. */
+	int dev_zero;
+	char template[] = "/tmp/vl.XXXXXX";
+
+	dev_zero = open("/dev/zero", O_RDONLY);
+	if (dev_zero < 0) {
+	    close(fd);
+	    free(bs);
+	    return NULL;
+	}
+
+	bs->changes_map = mmap(NULL, size, PROT_READ|PROT_WRITE, MAP_PRIVATE,
+			       dev_zero, 0);
+	close(dev_zero);
+	if (bs->changes_map == MAP_FAILED) {
+	    close(fd);
+	    free(bs);
+	    return NULL;
+	}
+
+	/* Now, create a (sparse) temporary file for backing blocks. */
+	bs->changes_fd = mkstemp(template);
+	if (bs->changes_fd < 0) {
+	    munmap(bs->changes_map, bs->total_sectors * 512);
+	    close(fd);
+	    free(bs);
+	    return NULL;
+	}
+	/* Delete it. */
+	unlink(template);
+    } else {
+	bs->changes_map = NULL;
+    }
+
     return bs;
 }
 
 void bdrv_close(BlockDriverState *bs)
 {
     close(bs->fd);
+    if (bs->changes_map) {
+	munmap(bs->changes_map, bs->total_sectors * 512);
+	close(bs->changes_fd);
+    }
     free(bs);
 }
 
+static inline void set_bit(unsigned char *bitmap, int64_t bitnum)
+{
+    bitmap[bitnum / 8] |= (1 << (bitnum%8));
+}
+
+static inline int is_bit_set(const unsigned char *bitmap, int64_t bitnum)
+{
+    return !!(bitmap[bitnum / 8] & (1 << (bitnum%8)));
+}
+
+void bdrv_commit(BlockDriverState *bs)
+{
+    int64_t i;
+    unsigned char *changes_map;
+
+    if (!bs->changes_map) {
+	fprintf(stderr, "Already committing to %s\n", bs->filename);
+	return;
+    }
+
+    if (bs->read_only) {
+	fprintf(stderr, "Can't commit to %s: read-only\n", bs->filename);
+	return;
+    }
+
+    changes_map = bs->changes_map;
+    for (i = 0; i < bs->total_sectors; i++) {
+	if (is_bit_set(changes_map, i)) {
+	    unsigned char sector[512];
+	    if (bdrv_read(bs, i, sector, 1) != 0) {
+		fprintf(stderr, "Error reading sector %lli: aborting commit\n",
+			(long long)i);
+		return;
+	    }
+
+	    /* Make bdrv_write write to real file for a moment. */
+	    bs->changes_map = NULL;
+	    if (bdrv_write(bs, i, sector, 1) != 0) {
+		fprintf(stderr, "Error writing sector %lli: aborting commit\n",
+			(long long)i);
+		bs->changes_map = changes_map;
+		return;
+	    }
+	    bs->changes_map = changes_map;
+	}
+    }
+    fprintf(stderr, "Committed snapshot to %s\n", bs->filename);
+}
+    
+/* Return true if first block has been changed (ie. current version is
+ * in backing store).  Set the number of continuous blocks for which
+ * that is true. */
+static int is_changed(const unsigned char *bitmap,
+		      int64_t sector_num, int nb_sectors,
+		      int *num_same)
+{
+    int changed;
+
+    if (!bitmap || nb_sectors == 0) {
+	*num_same = nb_sectors;
+	return 0;
+    }
+
+    changed = is_bit_set(bitmap, sector_num);
+    for (*num_same = 1; *num_same < nb_sectors; (*num_same)++) {
+	if (is_bit_set(bitmap, sector_num + *num_same) != changed)
+	    break;
+    }
+
+    return changed;
+}
+    
 /* return -1 if error */
 int bdrv_read(BlockDriverState *bs, int64_t sector_num, 
               uint8_t *buf, int nb_sectors)
 {
-    int ret;
+    int ret, num_same, fd;
 
-    lseek64(bs->fd, sector_num * 512, SEEK_SET);
-    ret = read(bs->fd, buf, nb_sectors * 512);
-    if (ret != nb_sectors * 512)
+    fd = bs->fd;
+    if (is_changed(bs->changes_map, sector_num, nb_sectors, &num_same))
+	fd = bs->changes_fd;
+
+    lseek64(fd, sector_num * 512, SEEK_SET);
+    ret = read(fd, buf, num_same * 512);
+    if (ret != num_same * 512) {
+	fprintf(stderr, "Block: Failed to read %i sectors at %lli\n",
+		num_same, (long long)sector_num);
         return -1;
-    else
-        return 0;
+    }
+
+    /* Recurse to do rest of blocks. */
+    if (num_same < nb_sectors)
+	return bdrv_read(bs, sector_num + num_same, buf + 512 * num_same,
+			 nb_sectors - num_same);
+    return 0;
 }
 
 /* return -1 if error */
 int bdrv_write(BlockDriverState *bs, int64_t sector_num, 
                const uint8_t *buf, int nb_sectors)
 {
-    int ret;
+    int ret, fd, i;
 
-    if (bs->read_only)
-        return -1;
+    fd = bs->fd;
+
+    if (bs->changes_map)
+	fd = bs->changes_fd;
+    else if (bs->read_only)
+	return -1;
 
-    lseek64(bs->fd, sector_num * 512, SEEK_SET);
-    ret = write(bs->fd, buf, nb_sectors * 512);
+    lseek64(fd, sector_num * 512, SEEK_SET);
+    ret = write(fd, buf, nb_sectors * 512);
     if (ret != nb_sectors * 512)
         return -1;
-    else
-        return 0;
+
+    if (bs->changes_map)
+	for (i = 0; i < nb_sectors; i++)
+	    set_bit(bs->changes_map, sector_num + i);
+
+    return 0;
 }
 
 void bdrv_get_geometry(BlockDriverState *bs, int64_t *nb_sectors_ptr)
Index: vl.c
===================================================================
RCS file: /cvsroot/qemu/qemu/vl.c,v
retrieving revision 1.10
diff -u -r1.10 vl.c
--- vl.c	1 Jul 2003 16:27:45 -0000	1.10
+++ vl.c	2 Jul 2003 06:45:09 -0000
@@ -52,6 +52,7 @@
 
 #define DEBUG_LOGFILE "/tmp/vl.log"
 #define DEFAULT_NETWORK_SCRIPT "/etc/vl-ifup"
+#define MAX_DISKS 2
 
 //#define DEBUG_UNUSED_IOPORT
 //#define DEBUG_IRQ_LATENCY
@@ -63,6 +64,8 @@
 #define INITRD_LOAD_ADDR   0x00400000
 #define KERNEL_PARAMS_ADDR 0x00090000
 
+BlockDriverState *bs_table[MAX_DISKS];
+
 /* from plex86 (BSD license) */
 struct  __attribute__ ((packed)) linux_params {
   // For 0x00..0x3f, see 'struct screen_info' in linux/include/linux/tty.h.
@@ -1265,6 +1268,7 @@
     printf("\n"
            "C-a h    print this help\n"
            "C-a x    exit emulatior\n"
+	   "C-a s    save disk data back to file (if -snapshot)\n"
            "C-a b    send break (magic sysrq)\n"
            "C-a C-a  send C-a\n"
            );
@@ -1282,6 +1286,14 @@
         case 'x':
             exit(0);
             break;
+	case 's': {
+	    int i;
+
+	    for (i = 0; i < MAX_DISKS; i++)
+		if (bs_table[i])
+		    bdrv_commit(bs_table[i]);
+	    break;
+	    }
         case 'b':
             /* send break */
             s->rbr = 0;
@@ -1976,8 +1988,6 @@
 /* set to 1 set disable mult support */
 #define MAX_MULT_SECTORS 8
 
-#define MAX_DISKS 2
-
 struct IDEState;
 
 typedef void EndTransferFunc(struct IDEState *);
@@ -2009,7 +2019,6 @@
     uint8_t io_buffer[MAX_MULT_SECTORS*512 + 4];
 } IDEState;
 
-BlockDriverState *bs_table[MAX_DISKS];
 IDEState ide_state[MAX_DISKS];
 
 static void padstr(char *str, const char *src, int len)
@@ -2577,6 +2586,7 @@
            "-initrd file   use 'file' as initial ram disk\n"
            "-hda file      use 'file' as hard disk 0 image\n"
            "-hdb file      use 'file' as hard disk 1 image\n"
+	   "-snapshot      write to temporary files instead of disk files\n"
            "-m megs        set virtual RAM size to megs MB\n"
            "-n script      set network init script [default=%s]\n"
            "\n"
@@ -2595,12 +2605,13 @@
     { "initrd", 1, NULL, 0, },
     { "hda", 1, NULL, 0, },
     { "hdb", 1, NULL, 0, },
+    { "snapshot", 0, NULL, 0, },
     { NULL, 0, NULL, 0 },
 };
 
 int main(int argc, char **argv)
 {
-    int c, ret, initrd_size, i, use_gdbstub, gdbstub_port, long_index;
+    int c, ret, initrd_size, i, use_gdbstub, gdbstub_port, snapshot, long_index;
     struct linux_params *params;
     struct sigaction act;
     struct itimerval itv;
@@ -2617,6 +2628,7 @@
     pstrcpy(network_script, sizeof(network_script), DEFAULT_NETWORK_SCRIPT);
     use_gdbstub = 0;
     gdbstub_port = DEFAULT_GDBSTUB_PORT;
+    snapshot = 0;
     for(;;) {
         c = getopt_long_only(argc, argv, "hm:dn:sp:", long_options, &long_index);
         if (c == -1)
@@ -2633,6 +2645,9 @@
             case 2:
                 hd_filename[1] = optarg;
                 break;
+	    case 3:
+		snapshot = 1;
+		break;
             }
             break;
         case 'h':
@@ -2679,7 +2694,7 @@
     /* open the virtual block devices */
     for(i = 0; i < MAX_DISKS; i++) {
         if (hd_filename[i]) {
-            bs_table[i] = bdrv_open(hd_filename[i]);
+            bs_table[i] = bdrv_open(hd_filename[i], snapshot);
             if (!bs_table[i]) {
                 fprintf(stderr, "vl: could not open hard disk image '%s\n",
                         hd_filename[i]);
Index: vl.h
===================================================================
RCS file: /cvsroot/qemu/qemu/vl.h,v
retrieving revision 1.1
diff -u -r1.1 vl.h
--- vl.h	30 Jun 2003 10:03:06 -0000	1.1
+++ vl.h	2 Jul 2003 06:45:09 -0000
@@ -27,13 +27,13 @@
 /* block.c */
 typedef struct BlockDriverState BlockDriverState;
 
-BlockDriverState *bdrv_open(const char *filename);
+BlockDriverState *bdrv_open(const char *filename, int snapshot);
 void bdrv_close(BlockDriverState *bs);
 int bdrv_read(BlockDriverState *bs, int64_t sector_num, 
               uint8_t *buf, int nb_sectors);
 int bdrv_write(BlockDriverState *bs, int64_t sector_num, 
                const uint8_t *buf, int nb_sectors);
 void bdrv_get_geometry(BlockDriverState *bs, int64_t *nb_sectors_ptr);
-
+void bdrv_commit(BlockDriverState *bs);
 
 #endif /* VL_H */
Index: tests/Makefile
===================================================================
RCS file: /cvsroot/qemu/qemu/tests/Makefile,v
retrieving revision 1.21
diff -u -r1.21 Makefile
--- tests/Makefile	15 Jun 2003 20:42:31 -0000	1.21
+++ tests/Makefile	2 Jul 2003 06:45:10 -0000
@@ -6,7 +6,7 @@
 ifeq ($(ARCH),i386)
 TESTS=testclone testsig testthread sha1-i386 test-i386 runcom
 endif
-TESTS+=sha1 test_path
+TESTS+=sha1 test_path test_block
 
 QEMU=../qemu
 
@@ -28,6 +28,12 @@
 test_path: test_path.c
 	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $<
 	./$@ || { rm $@; exit 1; }
+
+test_block: test_block.c
+	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $<
+	./$@ test_block_data || { rm -f $@ test_block_data; exit 1; }
+	./$@ test_block_data undo || { rm -f $@ test_block_data; exit 1; }
+	@rm -f test_block_data
 
 # i386 emulation test (test various opcodes) */
 test-i386: test-i386.c test-i386-code16.S test-i386-vm86.S \