* [Qemu-devel] [PATCH v3 7/7] qemu-iotests: add 039 qcow2 lazy refcounts test [not found] <1343371793-18073-1-git-send-email-stefanha@linux.vnet.ibm.com> @ 2012-07-27 6:49 ` Stefan Hajnoczi 0 siblings, 0 replies; 4+ messages in thread From: Stefan Hajnoczi @ 2012-07-27 6:49 UTC (permalink / raw) To: qemu-devel; +Cc: Kevin Wolf, Khoa Huynh, Anthony Liguori, Stefan Hajnoczi This tests establishes the basic post-conditions of the qcow2 lazy refcounts features: 1. If the image was closed normally, it is marked clean. 2. If an allocating write was performed and the image was not closed normally, then it is marked dirty. a. Written data can be read back successfully. b. The image file can be repaired and will be marked clean again. c. The image file is automatically repaired when opened read/write. Signed-off-by: Stefan Hajnoczi <stefanha@linux.vnet.ibm.com> --- tests/qemu-iotests/039 | 136 ++++++++++++++++++++++++++++++++++++++++++++ tests/qemu-iotests/039.out | 53 +++++++++++++++++ tests/qemu-iotests/group | 1 + 3 files changed, 190 insertions(+) create mode 100755 tests/qemu-iotests/039 create mode 100644 tests/qemu-iotests/039.out diff --git a/tests/qemu-iotests/039 b/tests/qemu-iotests/039 new file mode 100755 index 0000000..a749fcf --- /dev/null +++ b/tests/qemu-iotests/039 @@ -0,0 +1,136 @@ +#!/bin/bash +# +# Test qcow2 lazy refcounts +# +# Copyright (C) 2012 Red Hat, Inc. +# Copyright IBM, Corp. 2010 +# +# Based on test 038. +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see <http://www.gnu.org/licenses/>. +# + +# creator +owner=stefanha@linux.vnet.ibm.com + +seq=`basename $0` +echo "QA output created by $seq" + +here=`pwd` +tmp=/tmp/$$ +status=1 # failure is the default! + +_cleanup() +{ + _cleanup_test_img +} +trap "_cleanup; exit \$status" 0 1 2 3 15 + +# get standard environment, filters and checks +. ./common.rc +. ./common.filter + +_supported_fmt qcow2 +_supported_proto generic +_supported_os Linux + +size=128M + +echo +echo "== Checking that image is clean on shutdown ==" + +IMGOPTS="compat=1.1,lazy_refcounts=on" +_make_test_img $size + +$QEMU_IO -c "write -P 0x5a 0 512" $TEST_IMG | _filter_qemu_io + +# The dirty bit must not be set +./qcow2.py $TEST_IMG dump-header | grep incompatible_features +_check_test_img + +echo +echo "== Creating a dirty image file ==" + +IMGOPTS="compat=1.1,lazy_refcounts=on" +_make_test_img $size + +old_ulimit=$(ulimit -c) +ulimit -c 0 # do not produce a core dump on abort(3) +$QEMU_IO -c "write -P 0x5a 0 512" -c "abort" $TEST_IMG | _filter_qemu_io +ulimit -c "$old_ulimit" + +# The dirty bit must be set +./qcow2.py $TEST_IMG dump-header | grep incompatible_features +_check_test_img + +echo +echo "== Read-only access must still work ==" + +$QEMU_IO -r -c "read -P 0x5a 0 512" $TEST_IMG | _filter_qemu_io + +# The dirty bit must be set +./qcow2.py $TEST_IMG dump-header | grep incompatible_features + +echo +echo "== Repairing the image file must succeed ==" + +$QEMU_IMG check -r all $TEST_IMG + +# The dirty bit must not be set +./qcow2.py $TEST_IMG dump-header | grep incompatible_features + +echo +echo "== Data should still be accessible after repair ==" + +$QEMU_IO -c "read -P 0x5a 0 512" $TEST_IMG | _filter_qemu_io + +echo +echo "== Opening a dirty image read/write should repair it ==" + +IMGOPTS="compat=1.1,lazy_refcounts=on" +_make_test_img $size + +old_ulimit=$(ulimit -c) +ulimit -c 0 # do not produce a core dump on abort(3) +$QEMU_IO -c "write -P 0x5a 0 512" -c "abort" $TEST_IMG | _filter_qemu_io +ulimit -c "$old_ulimit" + +# The dirty bit must be set +./qcow2.py $TEST_IMG dump-header | grep incompatible_features + +$QEMU_IO -c "write 0 512" $TEST_IMG | _filter_qemu_io + +# The dirty bit must not be set +./qcow2.py $TEST_IMG dump-header | grep incompatible_features + +echo +echo "== Creating an image file with lazy_refcounts=off ==" + +IMGOPTS="compat=1.1,lazy_refcounts=off" +_make_test_img $size + +old_ulimit=$(ulimit -c) +ulimit -c 0 # do not produce a core dump on abort(3) +$QEMU_IO -c "write -P 0x5a 0 512" -c "abort" $TEST_IMG | _filter_qemu_io +ulimit -c "$old_ulimit" + +# The dirty bit must not be set since lazy_refcounts=off +./qcow2.py $TEST_IMG dump-header | grep incompatible_features +_check_test_img + +# success, all done +echo "*** done" +rm -f $seq.full +status=0 + diff --git a/tests/qemu-iotests/039.out b/tests/qemu-iotests/039.out new file mode 100644 index 0000000..8ad570d --- /dev/null +++ b/tests/qemu-iotests/039.out @@ -0,0 +1,53 @@ +QA output created by 039 + +== Checking that image is clean on shutdown == +Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 lazy_refcounts=on +wrote 512/512 bytes at offset 0 +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +incompatible_features 0x0 +No errors were found on the image. + +== Creating a dirty image file == +Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 lazy_refcounts=on +wrote 512/512 bytes at offset 0 +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +incompatible_features 0x1 +ERROR OFLAG_COPIED: offset=8000000000050000 refcount=0 +ERROR cluster 5 refcount=0 reference=1 + +2 errors were found on the image. +Data may be corrupted, or further writes to the image may corrupt it. + +== Read-only access must still work == +read 512/512 bytes at offset 0 +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +incompatible_features 0x1 + +== Repairing the image file must succeed == +ERROR OFLAG_COPIED: offset=8000000000050000 refcount=0 +Repairing cluster 5 refcount=0 reference=1 +No errors were found on the image. +incompatible_features 0x0 + +== Data should still be accessible after repair == +read 512/512 bytes at offset 0 +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) + +== Opening a dirty image read/write should repair it == +Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 lazy_refcounts=on +wrote 512/512 bytes at offset 0 +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +incompatible_features 0x1 +ERROR OFLAG_COPIED: offset=8000000000050000 refcount=0 +Repairing cluster 5 refcount=0 reference=1 +wrote 512/512 bytes at offset 0 +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +incompatible_features 0x0 + +== Creating an image file with lazy_refcounts=off == +Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 +wrote 512/512 bytes at offset 0 +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +incompatible_features 0x0 +No errors were found on the image. +*** done diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group index 7a2c92b..ebb5ca4 100644 --- a/tests/qemu-iotests/group +++ b/tests/qemu-iotests/group @@ -45,3 +45,4 @@ 036 rw auto quick 037 rw auto backing 038 rw auto backing +039 rw auto -- 1.7.10.4 ^ permalink raw reply related [flat|nested] 4+ messages in thread
* [Qemu-devel] [PATCH v3 0/7] qcow2: implement lazy refcounts optimization
@ 2012-07-27 8:05 Stefan Hajnoczi
2012-07-27 8:05 ` [Qemu-devel] [PATCH v3 7/7] qemu-iotests: add 039 qcow2 lazy refcounts test Stefan Hajnoczi
0 siblings, 1 reply; 4+ messages in thread
From: Stefan Hajnoczi @ 2012-07-27 8:05 UTC (permalink / raw)
To: qemu-devel; +Cc: Kevin Wolf, Khoa Huynh, Anthony Liguori, Stefan Hajnoczi
[Resend because most of the emails seem to have been dropped]
This series aims to improve qcow2 performance with cache=writethrough and
cache=directsync. In particular it reduces the impact of metadata updates for
allocating writes.
This optimization should help make qcow2 a good choice even for
cache=writethrough and cache=directsync where QED has traditionally had an
advantage due to less metadata - this allows us to converge image format
development in QEMU around the qcow2v3 format.
Allocating writes are expensive because they involve updating L2 tables and
refcount blocks. In addition they can also cause L2 table allocation and
refcount block allocation but these remain unaffected by this optimization.
The key insight is that refcounts are not required to access data in the image.
This means that we can postpone refcount updates without violating the data
integrity guarantee that cache=writethrough and cache=directsync give.
The trade-off for postponing refcount updates is that the image may not be
completely consistent in case of power failure or crash. If the image is dirty
then it must be repaired before performing further modifications, in other
words we need an fsck-like scan on startup.
fio benchmark results:
WRITE lazy_refcounts=off io=552650KB
WRITE lazy_refcounts=on io=708264KB (+28%)
Disk: Intel X25-M 120GB 2nd Gen
Host file system: ext4
Host kernel: Linux 3.2.0-3-amd64 Debian
Note that these random 8k writes are to an empty qcow2 file. This is the worst
case scenario for cache=writethrough and cache=directsync because each I/O is
likely to involve metadata I/O, including refcount updates.
$ qemu-system-x86_64 -enable-kvm -m 1024 \
-drive if=virtio,cache=none,file=../vm/rhel-6.img \
-drive if=virtio,cache=writethrough,file=a.qcow2
Job file:
[global]
ioengine=aio
buffered=0
rw=write
bs=8k
runtime=3m
time_based=1
iodepth=1
filename=/dev/vdb
[job1]
v3:
* Fix typo in qcow2 spec on lazy refcounts [Kevin]
* Add test for automatic repair when dirty image is opened read/write [Kevin]
v2:
* Fixed feature bit qcow2 spec formatting [Kevin]
* Record feature bit names in qcow2 header for better error messages [Kevin]
* Use separate enums for different feature bit types [Kevin]
* Check that dirty bit is still set after read-only image access [Kevin]
* Check that the dirty flag is never set with lazy_refcounts=off [Kevin]
Stefan Hajnoczi (7):
docs: add dirty bit to qcow2 specification
qcow2: introduce dirty bit
docs: add lazy refcounts bit to qcow2 specification
qemu-iotests: ignore qemu-img create lazy_refcounts output
qcow2: implement lazy refcounts
qemu-io: add "abort" command to simulate program crash
qemu-iotests: add 039 qcow2 lazy refcounts test
block/qcow2-cluster.c | 5 +-
block/qcow2.c | 121 ++++++++++++++++++++++++++++++++++---
block/qcow2.h | 21 +++++++
block_int.h | 26 ++++----
docs/specs/qcow2.txt | 14 ++++-
qemu-io.c | 12 ++++
tests/qemu-iotests/031.out | 20 +++----
tests/qemu-iotests/036.out | 4 +-
tests/qemu-iotests/039 | 136 ++++++++++++++++++++++++++++++++++++++++++
tests/qemu-iotests/039.out | 53 ++++++++++++++++
tests/qemu-iotests/common.rc | 3 +-
tests/qemu-iotests/group | 1 +
12 files changed, 381 insertions(+), 35 deletions(-)
create mode 100755 tests/qemu-iotests/039
create mode 100644 tests/qemu-iotests/039.out
--
1.7.10.4
^ permalink raw reply [flat|nested] 4+ messages in thread* [Qemu-devel] [PATCH v3 7/7] qemu-iotests: add 039 qcow2 lazy refcounts test 2012-07-27 8:05 [Qemu-devel] [PATCH v3 0/7] qcow2: implement lazy refcounts optimization Stefan Hajnoczi @ 2012-07-27 8:05 ` Stefan Hajnoczi 2012-07-27 13:30 ` Kevin Wolf 0 siblings, 1 reply; 4+ messages in thread From: Stefan Hajnoczi @ 2012-07-27 8:05 UTC (permalink / raw) To: qemu-devel; +Cc: Kevin Wolf, Khoa Huynh, Anthony Liguori, Stefan Hajnoczi This tests establishes the basic post-conditions of the qcow2 lazy refcounts features: 1. If the image was closed normally, it is marked clean. 2. If an allocating write was performed and the image was not closed normally, then it is marked dirty. a. Written data can be read back successfully. b. The image file can be repaired and will be marked clean again. c. The image file is automatically repaired when opened read/write. Signed-off-by: Stefan Hajnoczi <stefanha@linux.vnet.ibm.com> --- tests/qemu-iotests/039 | 136 ++++++++++++++++++++++++++++++++++++++++++++ tests/qemu-iotests/039.out | 53 +++++++++++++++++ tests/qemu-iotests/group | 1 + 3 files changed, 190 insertions(+) create mode 100755 tests/qemu-iotests/039 create mode 100644 tests/qemu-iotests/039.out diff --git a/tests/qemu-iotests/039 b/tests/qemu-iotests/039 new file mode 100755 index 0000000..a749fcf --- /dev/null +++ b/tests/qemu-iotests/039 @@ -0,0 +1,136 @@ +#!/bin/bash +# +# Test qcow2 lazy refcounts +# +# Copyright (C) 2012 Red Hat, Inc. +# Copyright IBM, Corp. 2010 +# +# Based on test 038. +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see <http://www.gnu.org/licenses/>. +# + +# creator +owner=stefanha@linux.vnet.ibm.com + +seq=`basename $0` +echo "QA output created by $seq" + +here=`pwd` +tmp=/tmp/$$ +status=1 # failure is the default! + +_cleanup() +{ + _cleanup_test_img +} +trap "_cleanup; exit \$status" 0 1 2 3 15 + +# get standard environment, filters and checks +. ./common.rc +. ./common.filter + +_supported_fmt qcow2 +_supported_proto generic +_supported_os Linux + +size=128M + +echo +echo "== Checking that image is clean on shutdown ==" + +IMGOPTS="compat=1.1,lazy_refcounts=on" +_make_test_img $size + +$QEMU_IO -c "write -P 0x5a 0 512" $TEST_IMG | _filter_qemu_io + +# The dirty bit must not be set +./qcow2.py $TEST_IMG dump-header | grep incompatible_features +_check_test_img + +echo +echo "== Creating a dirty image file ==" + +IMGOPTS="compat=1.1,lazy_refcounts=on" +_make_test_img $size + +old_ulimit=$(ulimit -c) +ulimit -c 0 # do not produce a core dump on abort(3) +$QEMU_IO -c "write -P 0x5a 0 512" -c "abort" $TEST_IMG | _filter_qemu_io +ulimit -c "$old_ulimit" + +# The dirty bit must be set +./qcow2.py $TEST_IMG dump-header | grep incompatible_features +_check_test_img + +echo +echo "== Read-only access must still work ==" + +$QEMU_IO -r -c "read -P 0x5a 0 512" $TEST_IMG | _filter_qemu_io + +# The dirty bit must be set +./qcow2.py $TEST_IMG dump-header | grep incompatible_features + +echo +echo "== Repairing the image file must succeed ==" + +$QEMU_IMG check -r all $TEST_IMG + +# The dirty bit must not be set +./qcow2.py $TEST_IMG dump-header | grep incompatible_features + +echo +echo "== Data should still be accessible after repair ==" + +$QEMU_IO -c "read -P 0x5a 0 512" $TEST_IMG | _filter_qemu_io + +echo +echo "== Opening a dirty image read/write should repair it ==" + +IMGOPTS="compat=1.1,lazy_refcounts=on" +_make_test_img $size + +old_ulimit=$(ulimit -c) +ulimit -c 0 # do not produce a core dump on abort(3) +$QEMU_IO -c "write -P 0x5a 0 512" -c "abort" $TEST_IMG | _filter_qemu_io +ulimit -c "$old_ulimit" + +# The dirty bit must be set +./qcow2.py $TEST_IMG dump-header | grep incompatible_features + +$QEMU_IO -c "write 0 512" $TEST_IMG | _filter_qemu_io + +# The dirty bit must not be set +./qcow2.py $TEST_IMG dump-header | grep incompatible_features + +echo +echo "== Creating an image file with lazy_refcounts=off ==" + +IMGOPTS="compat=1.1,lazy_refcounts=off" +_make_test_img $size + +old_ulimit=$(ulimit -c) +ulimit -c 0 # do not produce a core dump on abort(3) +$QEMU_IO -c "write -P 0x5a 0 512" -c "abort" $TEST_IMG | _filter_qemu_io +ulimit -c "$old_ulimit" + +# The dirty bit must not be set since lazy_refcounts=off +./qcow2.py $TEST_IMG dump-header | grep incompatible_features +_check_test_img + +# success, all done +echo "*** done" +rm -f $seq.full +status=0 + diff --git a/tests/qemu-iotests/039.out b/tests/qemu-iotests/039.out new file mode 100644 index 0000000..8ad570d --- /dev/null +++ b/tests/qemu-iotests/039.out @@ -0,0 +1,53 @@ +QA output created by 039 + +== Checking that image is clean on shutdown == +Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 lazy_refcounts=on +wrote 512/512 bytes at offset 0 +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +incompatible_features 0x0 +No errors were found on the image. + +== Creating a dirty image file == +Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 lazy_refcounts=on +wrote 512/512 bytes at offset 0 +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +incompatible_features 0x1 +ERROR OFLAG_COPIED: offset=8000000000050000 refcount=0 +ERROR cluster 5 refcount=0 reference=1 + +2 errors were found on the image. +Data may be corrupted, or further writes to the image may corrupt it. + +== Read-only access must still work == +read 512/512 bytes at offset 0 +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +incompatible_features 0x1 + +== Repairing the image file must succeed == +ERROR OFLAG_COPIED: offset=8000000000050000 refcount=0 +Repairing cluster 5 refcount=0 reference=1 +No errors were found on the image. +incompatible_features 0x0 + +== Data should still be accessible after repair == +read 512/512 bytes at offset 0 +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) + +== Opening a dirty image read/write should repair it == +Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 lazy_refcounts=on +wrote 512/512 bytes at offset 0 +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +incompatible_features 0x1 +ERROR OFLAG_COPIED: offset=8000000000050000 refcount=0 +Repairing cluster 5 refcount=0 reference=1 +wrote 512/512 bytes at offset 0 +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +incompatible_features 0x0 + +== Creating an image file with lazy_refcounts=off == +Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 +wrote 512/512 bytes at offset 0 +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +incompatible_features 0x0 +No errors were found on the image. +*** done diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group index 7a2c92b..ebb5ca4 100644 --- a/tests/qemu-iotests/group +++ b/tests/qemu-iotests/group @@ -45,3 +45,4 @@ 036 rw auto quick 037 rw auto backing 038 rw auto backing +039 rw auto -- 1.7.10.4 ^ permalink raw reply related [flat|nested] 4+ messages in thread
* Re: [Qemu-devel] [PATCH v3 7/7] qemu-iotests: add 039 qcow2 lazy refcounts test 2012-07-27 8:05 ` [Qemu-devel] [PATCH v3 7/7] qemu-iotests: add 039 qcow2 lazy refcounts test Stefan Hajnoczi @ 2012-07-27 13:30 ` Kevin Wolf 2012-07-30 10:21 ` Stefan Hajnoczi 0 siblings, 1 reply; 4+ messages in thread From: Kevin Wolf @ 2012-07-27 13:30 UTC (permalink / raw) To: Stefan Hajnoczi; +Cc: Khoa Huynh, Anthony Liguori, qemu-devel Am 27.07.2012 10:05, schrieb Stefan Hajnoczi: > This tests establishes the basic post-conditions of the qcow2 lazy > refcounts features: > > 1. If the image was closed normally, it is marked clean. > > 2. If an allocating write was performed and the image was not closed > normally, then it is marked dirty. > > a. Written data can be read back successfully. > b. The image file can be repaired and will be marked clean again. > c. The image file is automatically repaired when opened read/write. > > Signed-off-by: Stefan Hajnoczi <stefanha@linux.vnet.ibm.com> Thanks, applied all patches for now. But can you please respin this single patch to make it work with -nocache? I don't really mind how you do it, options include skipping the test, overriding the cache option, possibly inserting some 'flush' qemu-io commands etc. It just shouldn't fail (even more so because -nocache is the option I use the most with qemu-iotests). Kevin ^ permalink raw reply [flat|nested] 4+ messages in thread
* Re: [Qemu-devel] [PATCH v3 7/7] qemu-iotests: add 039 qcow2 lazy refcounts test 2012-07-27 13:30 ` Kevin Wolf @ 2012-07-30 10:21 ` Stefan Hajnoczi 0 siblings, 0 replies; 4+ messages in thread From: Stefan Hajnoczi @ 2012-07-30 10:21 UTC (permalink / raw) To: Kevin Wolf; +Cc: Khoa Huynh, Anthony Liguori, Stefan Hajnoczi, qemu-devel On Fri, Jul 27, 2012 at 2:30 PM, Kevin Wolf <kwolf@redhat.com> wrote: > Am 27.07.2012 10:05, schrieb Stefan Hajnoczi: >> This tests establishes the basic post-conditions of the qcow2 lazy >> refcounts features: >> >> 1. If the image was closed normally, it is marked clean. >> >> 2. If an allocating write was performed and the image was not closed >> normally, then it is marked dirty. >> >> a. Written data can be read back successfully. >> b. The image file can be repaired and will be marked clean again. >> c. The image file is automatically repaired when opened read/write. >> >> Signed-off-by: Stefan Hajnoczi <stefanha@linux.vnet.ibm.com> > > Thanks, applied all patches for now. But can you please respin this > single patch to make it work with -nocache? Sure. Stefan ^ permalink raw reply [flat|nested] 4+ messages in thread
end of thread, other threads:[~2012-07-30 10:21 UTC | newest]
Thread overview: 4+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
[not found] <1343371793-18073-1-git-send-email-stefanha@linux.vnet.ibm.com>
2012-07-27 6:49 ` [Qemu-devel] [PATCH v3 7/7] qemu-iotests: add 039 qcow2 lazy refcounts test Stefan Hajnoczi
2012-07-27 8:05 [Qemu-devel] [PATCH v3 0/7] qcow2: implement lazy refcounts optimization Stefan Hajnoczi
2012-07-27 8:05 ` [Qemu-devel] [PATCH v3 7/7] qemu-iotests: add 039 qcow2 lazy refcounts test Stefan Hajnoczi
2012-07-27 13:30 ` Kevin Wolf
2012-07-30 10:21 ` Stefan Hajnoczi
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox; as well as URLs for NNTP newsgroup(s).