A different way to ask for readonly drive
PATCH 1/1 A different way to ask for readonly drive
Hi,
After feedback from Red Hat guys, I've decided to slightly modify the approach to drive's readonly.
The new approach also addresses the silent fall-back to open the drives' file as read-only when read-write fails (permission denied) that causes unexpected behavior.
Instead of the 'readonly' boolean flag, another flag introduced (a replacement), 'read_write' with three values [on|off|try]:
read_write=on : open with read and write permission, no fall-back to read-only
read_write=off: open with read-only permission
read_write=try: open with read and write permission and if fails, fall-back to read-only (the default if nothing specified)
Suggestions for better naming for flag/values welcomed.
I've tried to explicitly pass the required flags for the bdrv_open function in callers, but probably missed some.
Naphtali
--- block.c | 29 +++++++++++++++++------------ block.h | 7 +++++-- hw/xen_disk.c | 3 ++- monitor.c | 2 +- qemu-config.c | 4 ++-- qemu-img.c | 14 ++++++++------ qemu-nbd.c | 2 +- vl.c | 42 +++++++++++++++++++++++++++++++++--------- 8 files changed, 69 insertions(+), 34 deletions(-)
block.c +17 -12
@@ -356,7 +356,7 @@ int bdrv_open(BlockDriverState *bs, const char *filename, int flags)int bdrv_open2 (BlockDriverState *bs,const char *filename,int flags,BlockDriver *drv) { -int ret, open_flags, try_rw; +int ret, open_flags;char tmp_filename[PATH_MAX ];char backing_filename[PATH_MAX ];
@@ -378,7 +378,7 @@ int bdrv_open2(BlockDriverState *bs, const char *filename, int flags,/* if there is a backing file, use it */ bs1 =bdrv_new ("" ); - ret =bdrv_open2 (bs1, filename,0 , drv); + ret =bdrv_open2 (bs1, filename,BDRV_O_RDONLY , drv);if (ret <0 ) {bdrv_delete (bs1);return ret;
@@ -445,19 +445,22 @@ int bdrv_open2(BlockDriverState *bs, const char *filename, int flags, bs->enable_write_cache =1 ;/* Note: for compatibility, we open disk image files as RDWR, and -RDONLY as fallback */ - try_rw = !bs->read_only || bs->is_temporary; -if (!(flags &BDRV_O_FILE )) - open_flags = (try_rw ?BDRV_O_RDWR :0 ) | - (flags & (BDRV_O_CACHE_MASK |BDRV_O_NATIVE_AIO )); -else +RDONLY as fallback (if flag BDRV_O_RO_FBCK is on) */ + bs->read_only =BDRV_FLAGS_IS_RO (flags); +if (!(flags &BDRV_O_FILE )) { + open_flags = (flags & (BDRV_O_ACCESS |BDRV_O_CACHE_MASK |BDRV_O_NATIVE_AIO )); +if (bs->is_temporary) {/* snapshot */ + open_flags |=BDRV_O_RDWR ; + } + }else open_flags = flags & ~(BDRV_O_FILE |BDRV_O_SNAPSHOT );if (use_bdrv_whitelist && !bdrv_is_whitelisted (drv)) ret = -ENOTSUP ;else ret = drv->bdrv_open (bs, filename, open_flags); -if ((ret == -EACCES || ret == -EPERM ) && !(flags &BDRV_O_FILE )) { - ret = drv->bdrv_open (bs, filename, open_flags & ~BDRV_O_RDWR ); +if ((ret == -EACCES || ret == -EPERM ) && !(flags &BDRV_O_FILE ) && + (flags &BDRV_O_RO_FBCK )) { + ret = drv->bdrv_open (bs, filename, (open_flags & ~BDRV_O_RDWR ) |BDRV_O_RDONLY ); bs->read_only =1 ; }if (ret <0 ) {
@@ -481,12 +484,14 @@ int bdrv_open2(BlockDriverState *bs, const char *filename, int flags,/* if there is a backing file, use it */ BlockDriver *back_drv =NULL ; bs->backing_hd =bdrv_new ("" ); -/* pass on read_only property to the backing_hd */ - bs->backing_hd->read_only = bs->read_only;path_combine (backing_filename,sizeof (backing_filename), filename, bs->backing_file);if (bs->backing_format[0 ] !='\0' ) back_drv =bdrv_find_format (bs->backing_format); +/* pass on ro flags to the backing_hd */ + bs->backing_hd->read_only =BDRV_FLAGS_IS_RO (flags); + open_flags &= ~BDRV_O_ACCESS ; + open_flags |= (flags &BDRV_O_ACCESS ); ret =bdrv_open2 (bs->backing_hd, backing_filename, open_flags, back_drv);if (ret <0 ) {
block.h +5 -2
@@ -28,8 +28,9 @@ typedef struct QEMUSnapshotInfo { } QEMUSnapshotInfo;#define BDRV_O_RDONLY 0x0000 -#define BDRV_O_RDWR 0x0002 -#define BDRV_O_ACCESS 0x0003 +#define BDRV_O_RDWR 0x0001 +#define BDRV_O_ACCESS 0x0001 +#define BDRV_O_RO_FBCK 0x0002#define BDRV_O_CREAT 0x0004/* create an empty file */ #define BDRV_O_SNAPSHOT 0x0008/* open the file read only and save writes in a snapshot */ #define BDRV_O_FILE 0x0010/* open as a raw file (do not try to
@@ -41,6 +42,8 @@ typedef struct QEMUSnapshotInfo {#define BDRV_O_NATIVE_AIO 0x0080/* use native AIO instead of the thread pool */ #define BDRV_O_CACHE_MASK (BDRV_O_NOCACHE | BDRV_O_CACHE_WB) +#define BDRV_O_DFLT_OPEN (BDRV_O_RDWR | BDRV_O_RO_FBCK) +#define BDRV_FLAGS_IS_RO (flags) ((flags & BDRV_O_ACCESS) == BDRV_O_RDONLY)#define BDRV_SECTOR_BITS 9#define BDRV_SECTOR_SIZE (1 << BDRV_SECTOR_BITS)
hw/xen_disk.c +2 -1
@@ -610,7 +610,8 @@ static int blk_init(struct XenDevice *xendev)/* read-only ? */ if (strcmp (blkdev->mode,"w" ) ==0 ) { mode =O_RDWR ; - qflags =BDRV_O_RDWR ; +/* for compatibility, also allow readonly fallback, for now */ + qflags =BDRV_O_RDWR |BDRV_O_RO_FBCK ; }else { mode =O_RDONLY ; qflags =BDRV_O_RDONLY ;
monitor.c +1 -1
@@ -910,7 +910,7 @@ static void do_change_block(Monitor *mon, const char *device, }if (eject_device (mon, bs,0 ) <0 )return ; -bdrv_open2 (bs, filename,0 , drv); +bdrv_open2 (bs, filename,BDRV_O_DFLT_OPEN , drv);monitor_read_bdrv_key_start (mon, bs,NULL ,NULL ); }
qemu-config.c +2 -2
@@ -76,8 +76,8 @@ QemuOptsList qemu_drive_opts = { .type = QEMU_OPT_STRING, .help = "pci address (virtio only)", },{ - .name = "readonly", - .type = QEMU_OPT_BOOL, + .name = "read_write", + .type = QEMU_OPT_STRING, }, {/* end if list */ } },
qemu-img.c +8 -6
@@ -201,7 +201,7 @@ static BlockDriverState *bdrv_new_open(const char *filename, }else { drv =NULL ; } -if (bdrv_open2 (bs, filename,BRDV_O_FLAGS , drv) <0 ) { +if (bdrv_open2 (bs, filename,BRDV_O_FLAGS |BDRV_O_DFLT_OPEN , drv) <0 ) {error ("Could not open '%s'" , filename); }if (bdrv_is_encrypted (bs)) {
@@ -406,7 +406,7 @@ static int img_check(int argc, char **argv) }else { drv =NULL ; } -if (bdrv_open2 (bs, filename,BRDV_O_FLAGS , drv) <0 ) { +if (bdrv_open2 (bs, filename,BRDV_O_FLAGS |BDRV_O_RDONLY , drv) <0 ) {error ("Could not open '%s'" , filename); } ret =bdrv_check (bs);
@@ -465,7 +465,7 @@ static int img_commit(int argc, char **argv) }else { drv =NULL ; } -if (bdrv_open2 (bs, filename,BRDV_O_FLAGS , drv) <0 ) { +if (bdrv_open2 (bs, filename,BRDV_O_FLAGS |BDRV_O_RDWR , drv) <0 ) {error ("Could not open '%s'" , filename); } ret =bdrv_commit (bs);
@@ -884,7 +884,7 @@ static int img_info(int argc, char **argv) }else { drv =NULL ; } -if (bdrv_open2 (bs, filename,BRDV_O_FLAGS , drv) <0 ) { +if (bdrv_open2 (bs, filename,BRDV_O_FLAGS |BDRV_O_RDONLY , drv) <0 ) {error ("Could not open '%s'" , filename); }bdrv_get_format (bs, fmt_name,sizeof (fmt_name));
@@ -932,10 +932,11 @@ static int img_snapshot(int argc, char **argv)BlockDriverState *bs;QEMUSnapshotInfo sn;char *filename, *snapshot_name =NULL ; -int c, ret; +int c, ret, bdrv_oflags;int action =0 ;qemu_timeval tv; + bdrv_oflags =BDRV_O_RDWR ;/* but no read-only fallback */ /* Parse commandline parameters */ for (;;) { c =getopt (argc, argv,"la:c:d:h" );
@@ -951,6 +952,7 @@ static int img_snapshot(int argc, char **argv)return 0 ; } action =SNAPSHOT_LIST ; + bdrv_oflags =BDRV_O_RDONLY ;/* no need for RW */ break ;case 'a' :if (action) {
@@ -988,7 +990,7 @@ static int img_snapshot(int argc, char **argv)if (!bs)error ("Not enough memory" ); -if (bdrv_open2 (bs, filename,0 ,NULL ) <0 ) { +if (bdrv_open2 (bs, filename, bdrv_oflags,NULL ) <0 ) {error ("Could not open '%s'" , filename); }
qemu-nbd.c +1 -1
@@ -212,7 +212,7 @@ int main(int argc, char **argv)int opt_ind =0 ;int li;char *end; -int flags =0 ; +int flags =BDRV_O_DFLT_OPEN ;int partition =-1 ;int ret;int shared =1 ;
vl.c +33 -9
80 lines not on this page · raw message
Signature · 1 line
1.6.3.3
Quoted 9 lines · Naphtali Sprei
Hi,
After feedback from Red Hat guys, I've decided to slightly modify the approach to drive's readonly.
The new approach also addresses the silent fall-back to open the drives' file as read-only when read-write fails (permission denied) that causes unexpected behavior.
Instead of the 'readonly' boolean flag, another flag introduced (a replacement), 'read_write' with three values [on|off|try]:
read_write=on : open with read and write permission, no fall-back to read-only
read_write=off: open with read-only permission
read_write=try: open with read and write permission and if fails, fall-back to read-only (the default if nothing specified)
Quoted 8 lines
Suggestions for better naming for flag/values welcomed.
I've tried to explicitly pass the required flags for the
bdrv_openfunction in callers, but probably missed some.Naphtali
...
Instead of on/off, I'd prefer the common shortcuts rw/ro. "try" is ok, but maybe "rw-ro" is better.
So here are my suggestions:
read_write=rw
read_write=ro
read_write=rw-ro
or
access=rw
access=ro
access=rw-ro
Regards,
Stefan
Quoted 11 lines · Stefan Weil
So here are my suggestions:
read_write=rw
read_write=ro
read_write=rw-roor
access=rw
access=ro
access=rw-ro
Mine:
access=rw
access=ro
access=auto (default)
-- Jamie
Quoted 15 lines · Jamie Lokier
Quoted 6 lines · Stefan Weil
So here are my suggestions:
read_write=rw
read_write=ro
read_write=rw-roQuoted 6 lines
or
access=rw
access=ro
access=rw-ro
Quoted 7 lines
Mine:
access=rw
access=ro
access=auto (default)-- Jamie
Looks good. Best suggestion up to now (in my personal opinion).
-- Stefan
Quoted 3 lines · Jamie Lokier
access=rw
access=ro
access=auto (default)
Yes, that sounds like the least clumsy one. I still think the current implementation is a very bad default, though.
Quoted 7 lines · Christoph Hellwig
Quoted 3 lines · Jamie Lokier
access=rw
access=ro
access=auto (default)Yes, that sounds like the least clumsy one. I still think the current implementation is a very bad default, though.
Without agreeing or disagreeing over whether it's a bad default :), a usability problem occurs with the current implementation when you deliberately "chmod 444" an image to have high confidence that it's opened read only: When running as root, file permissions are ignored (except sometimes on NFS).
For that reason I use "chattr +i" on all my read-only image files, to really make sure that no qemu invocation mistake could accidentally corrupt valuable images. That works, but it's not very convenient.
If the "auto" method is kept, I think it would be an improvement if it checks the file permission itself, and does not even try to open a file O_RDWR if there are no writable permission bits - so that "chmod 444" has the same "open as read only" effect when qemu is invoked as root.
-- Jamie
Am 17.12.2009 14:16, schrieb Jamie Lokier:
Quoted 15 lines
Quoted 7 lines · Christoph Hellwig
Quoted 3 lines · Jamie Lokier
access=rw
access=ro
access=auto (default)Yes, that sounds like the least clumsy one. I still think the current implementation is a very bad default, though.
Without agreeing or disagreeing over whether it's a bad default :), a usability problem occurs with the current implementation when you deliberately "chmod 444" an image to have high confidence that it's opened read only: When running as root, file permissions are ignored (except sometimes on NFS).
Quoted 8 lines
For that reason I use "chattr +i" on all my read-only image files, to really make sure that no qemu invocation mistake could accidentally corrupt valuable images. That works, but it's not very convenient.
If the "auto" method is kept, I think it would be an improvement if it checks the file permission itself, and does not even try to open a file
O_RDWRif there are no writable permission bits - so that "chmod 444" has the same "open as read only" effect when qemu is invoked as root.
I don't think that this makes sense. That you can write the file as root is a feature of your OS and qemu has nothing to do with it. Doing anything else than accessing it would actually be unexpected behaviour on this OS. We're just writing an application, not a better OS.
You can decide to protect your images with the qemu readonly option and get the protection that qemu defines, or you take the permissions of the OS and get from the OS whatever the definition of that protection is (including write access for root). qemu can't and shouldn't know that you use the OS's protection but actually don't quite mean what it's defined to be.
Kevin
Quoted 5 lines · Kevin Wolf
Am 17.12.2009 14:16, schrieb Jamie Lokier:
You can decide to protect your images with the qemu readonly option and get the protection that qemu defines, or you take the permissions of the OS and get from the OS whatever the definition of that protection is (including write access for root).
Note that until the latest patch, "chmod 444" was the _the_ user interface to this feature of qemu. It's a bad interface, but it was the only one available. qemu is weird like that, having external file permissions control an internal behaviour switch.
Quoted 2 lines
qemu can't and shouldn't know that you use the OS's protection but actually don't quite mean what it's defined to be.
Then I concur with Christopher Hellwig, and we should drop the "auto" behaviour entirely, and force the user interface to be the qemu command line instead of "chmod" from now one.
-- Jamie
Quoted 15 lines · Jamie Lokier
Quoted 7 lines · Christoph Hellwig
Quoted 3 lines · Jamie Lokier
access=rw
access=ro
access=auto (default)Yes, that sounds like the least clumsy one. I still think the current implementation is a very bad default, though.
Without agreeing or disagreeing over whether it's a bad default :), a usability problem occurs with the current implementation when you deliberately "chmod 444" an image to have high confidence that it's opened read only: When running as root, file permissions are ignored (except sometimes on NFS).
Quoted 8 lines
For that reason I use "chattr +i" on all my read-only image files, to really make sure that no qemu invocation mistake could accidentally corrupt valuable images. That works, but it's not very convenient.
If the "auto" method is kept, I think it would be an improvement if it checks the file permission itself, and does not even try to open a file
O_RDWRif there are no writable permission bits - so that "chmod 444" has the same "open as read only" effect when qemu is invoked as root.
"Improving" on the kernel's permission checking easily ends in tears.
And if we change the the current "auto" behavior in incompatible ways anyway, then my preferred change would be to just drop it.
Am 14.12.2009 14:35, schrieb Naphtali Sprei:
Quoted 57 lines
Hi,
After feedback from Red Hat guys, I've decided to slightly modify the approach to drive's readonly.
The new approach also addresses the silent fall-back to open the drives' file as read-only when read-write fails (permission denied) that causes unexpected behavior.
Instead of the 'readonly' boolean flag, another flag introduced (a replacement), 'read_write' with three values [on|off|try]:
read_write=on : open with read and write permission, no fall-back to read-only
read_write=off: open with read-only permission
read_write=try: open with read and write permission and if fails, fall-back to read-only (the default if nothing specified)Suggestions for better naming for flag/values welcomed.
I've tried to explicitly pass the required flags for the
bdrv_openfunction in callers, but probably missed some.Naphtali
Signed-off-by Naphtali Sprei <[email protected]>--- block.c | 29 +++++++++++++++++------------ block.h | 7 +++++-- hw/xen_disk.c | 3 ++- monitor.c | 2 +- qemu-config.c | 4 ++-- qemu-img.c | 14 ++++++++------ qemu-nbd.c | 2 +- vl.c | 42 +++++++++++++++++++++++++++++++++--------- 8 files changed, 69 insertions(+), 34 deletions(-)block.c +2
-4@@ -356,7 +356,7 @@ int bdrv_open(BlockDriverState *bs, const char *filename, int flags)int bdrv_open2 (BlockDriverState *bs,const char *filename,int flags,BlockDriver *drv) { -int ret, open_flags, try_rw; +int ret, open_flags;char tmp_filename[PATH_MAX ];char backing_filename[PATH_MAX ];@@ -378,7 +378,7 @@ int bdrv_open2(BlockDriverState *bs, const char *filename, int flags,/* if there is a backing file, use it */ bs1 =bdrv_new ("" ); - ret =bdrv_open2 (bs1, filename,0 , drv); + ret =bdrv_open2 (bs1, filename,BDRV_O_RDONLY , drv);if (ret <0 ) {bdrv_delete (bs1);return ret;@@ -445,19 +445,22 @@ int bdrv_open2(BlockDriverState *bs, const char *filename, int flags, bs->enable_write_cache =1 ;/* Note: for compatibility, we open disk image files as RDWR, and -RDONLY as fallback */ - try_rw = !bs->read_only || bs->is_temporary;
block.c int bdrv_open2(BlockDriverState *bs, const char *filename, int flags, · line 453
Quoted 10 lines
block.c +6
-4-if (!(flags &BDRV_O_FILE )) - open_flags = (try_rw ?BDRV_O_RDWR :0 ) | - (flags & (BDRV_O_CACHE_MASK |BDRV_O_NATIVE_AIO )); -else +RDONLY as fallback (if flag BDRV_O_RO_FBCK is on) */ + bs->read_only =BDRV_FLAGS_IS_RO (flags); +if (!(flags &BDRV_O_FILE )) { + open_flags = (flags & (BDRV_O_ACCESS |BDRV_O_CACHE_MASK |BDRV_O_NATIVE_AIO )); +if (bs->is_temporary) {/* snapshot */ + open_flags |=BDRV_O_RDWR ;
open_flags = (open_flags & ~BDRV_O_ACCESS) | BDRV_O_RDWR;
Yes, I know, RDONLY is 0 anyway, but still... Or move the first open_flags line into the if and have a second one for is_temporary that doesn't copy BDRV_O_ACCESS.
block.c int bdrv_open2(BlockDriverState *bs, const char *filename, int flags, · line 463
Quoted 12 lines
block.c +5
-2+ } + }else open_flags = flags & ~(BDRV_O_FILE |BDRV_O_SNAPSHOT );if (use_bdrv_whitelist && !bdrv_is_whitelisted (drv)) ret = -ENOTSUP ;else ret = drv->bdrv_open (bs, filename, open_flags); -if ((ret == -EACCES || ret == -EPERM ) && !(flags &BDRV_O_FILE )) { - ret = drv->bdrv_open (bs, filename, open_flags & ~BDRV_O_RDWR ); +if ((ret == -EACCES || ret == -EPERM ) && !(flags &BDRV_O_FILE ) && + (flags &BDRV_O_RO_FBCK )) { + ret = drv->bdrv_open (bs, filename, (open_flags & ~BDRV_O_RDWR ) |BDRV_O_RDONLY );
Mask BDRV_O_ACCESS out, not only BDRV_O_RDWR.
Quoted 25 lines
block.c +4
-2bs->read_only =1 ; }if (ret <0 ) {@@ -481,12 +484,14 @@ int bdrv_open2(BlockDriverState *bs, const char *filename, int flags,/* if there is a backing file, use it */ BlockDriver *back_drv =NULL ; bs->backing_hd =bdrv_new ("" ); -/* pass on read_only property to the backing_hd */ - bs->backing_hd->read_only = bs->read_only;path_combine (backing_filename,sizeof (backing_filename), filename, bs->backing_file);if (bs->backing_format[0 ] !='\0' ) back_drv =bdrv_find_format (bs->backing_format); +/* pass on ro flags to the backing_hd */ + bs->backing_hd->read_only =BDRV_FLAGS_IS_RO (flags); + open_flags &= ~BDRV_O_ACCESS ; + open_flags |= (flags &BDRV_O_ACCESS ); ret =bdrv_open2 (bs->backing_hd, backing_filename, open_flags, back_drv);if (ret <0 ) {block.h +0
-0
block.h typedef struct QEMUSnapshotInfo { · line 32
Quoted 7 lines
block.h +2
-2@@ -28,8 +28,9 @@ typedef struct QEMUSnapshotInfo { } QEMUSnapshotInfo;#define BDRV_O_RDONLY 0x0000 -#define BDRV_O_RDWR 0x0002 -#define BDRV_O_ACCESS 0x0003 +#define BDRV_O_RDWR 0x0001 +#define BDRV_O_ACCESS 0x0001
Is this needed? I can't see why we would need more than a flag that says if we are read-write or not, but if you were to remove the old two-bit field, you should do the complete cleanup. There is not reason for BDRV_O_ACCESS to exist then any more.
In any case I don't think that saving the wasted bit belong into this patch, so better separate it out.
block.h typedef struct QEMUSnapshotInfo { · line 33
Quoted 1 line
block.h +1
-0+#define BDRV_O_RO_FBCK 0x0002
Come on, we can afford the four additional letters to make it BDRV_O_RO_FALLBACK and suddenly it becomes readable.
block.h typedef struct QEMUSnapshotInfo { · line 45
Quoted 8 lines
block.h +1
-0#define BDRV_O_CREAT 0x0004/* create an empty file */ #define BDRV_O_SNAPSHOT 0x0008/* open the file read only and save writes in a snapshot */ #define BDRV_O_FILE 0x0010/* open as a raw file (do not try to @@ -41,6 +42,8 @@ typedef struct QEMUSnapshotInfo {#define BDRV_O_NATIVE_AIO 0x0080/* use native AIO instead of the thread pool */ #define BDRV_O_CACHE_MASK (BDRV_O_NOCACHE | BDRV_O_CACHE_WB) +#define BDRV_O_DFLT_OPEN (BDRV_O_RDWR | BDRV_O_RO_FBCK)
Same here, what's wrong with spelling DEFAULT out?
Quoted 108 lines
block.h +1
-0+#define BDRV_FLAGS_IS_RO (flags) ((flags & BDRV_O_ACCESS) == BDRV_O_RDONLY)#define BDRV_SECTOR_BITS 9#define BDRV_SECTOR_SIZE (1 << BDRV_SECTOR_BITS)hw/xen_disk.c +2
-1@@ -610,7 +610,8 @@ static int blk_init(struct XenDevice *xendev)/* read-only ? */ if (strcmp (blkdev->mode,"w" ) ==0 ) { mode =O_RDWR ; - qflags =BDRV_O_RDWR ; +/* for compatibility, also allow readonly fallback, for now */ + qflags =BDRV_O_RDWR |BDRV_O_RO_FBCK ; }else { mode =O_RDONLY ; qflags =BDRV_O_RDONLY ;monitor.c +1
-1@@ -910,7 +910,7 @@ static void do_change_block(Monitor *mon, const char *device, }if (eject_device (mon, bs,0 ) <0 )return ; -bdrv_open2 (bs, filename,0 , drv); +bdrv_open2 (bs, filename,BDRV_O_DFLT_OPEN , drv);monitor_read_bdrv_key_start (mon, bs,NULL ,NULL ); }qemu-config.c +2
-2@@ -76,8 +76,8 @@ QemuOptsList qemu_drive_opts = { .type = QEMU_OPT_STRING, .help = "pci address (virtio only)", },{ - .name = "readonly", - .type = QEMU_OPT_BOOL, + .name = "read_write", + .type = QEMU_OPT_STRING, }, {/* end if list */ } },qemu-img.c +7
-5@@ -201,7 +201,7 @@ static BlockDriverState *bdrv_new_open(const char *filename, }else { drv =NULL ; } -if (bdrv_open2 (bs, filename,BRDV_O_FLAGS , drv) <0 ) { +if (bdrv_open2 (bs, filename,BRDV_O_FLAGS |BDRV_O_DFLT_OPEN , drv) <0 ) {error ("Could not open '%s'" , filename); }if (bdrv_is_encrypted (bs)) {@@ -406,7 +406,7 @@ static int img_check(int argc, char **argv) }else { drv =NULL ; } -if (bdrv_open2 (bs, filename,BRDV_O_FLAGS , drv) <0 ) { +if (bdrv_open2 (bs, filename,BRDV_O_FLAGS |BDRV_O_RDONLY , drv) <0 ) {error ("Could not open '%s'" , filename); } ret =bdrv_check (bs);@@ -465,7 +465,7 @@ static int img_commit(int argc, char **argv) }else { drv =NULL ; } -if (bdrv_open2 (bs, filename,BRDV_O_FLAGS , drv) <0 ) { +if (bdrv_open2 (bs, filename,BRDV_O_FLAGS |BDRV_O_RDWR , drv) <0 ) {error ("Could not open '%s'" , filename); } ret =bdrv_commit (bs);@@ -884,7 +884,7 @@ static int img_info(int argc, char **argv) }else { drv =NULL ; } -if (bdrv_open2 (bs, filename,BRDV_O_FLAGS , drv) <0 ) { +if (bdrv_open2 (bs, filename,BRDV_O_FLAGS |BDRV_O_RDONLY , drv) <0 ) {error ("Could not open '%s'" , filename); }bdrv_get_format (bs, fmt_name,sizeof (fmt_name));@@ -932,10 +932,11 @@ static int img_snapshot(int argc, char **argv)BlockDriverState *bs;QEMUSnapshotInfo sn;char *filename, *snapshot_name =NULL ; -int c, ret; +int c, ret, bdrv_oflags;int action =0 ;qemu_timeval tv; + bdrv_oflags =BDRV_O_RDWR ;/* but no read-only fallback */ /* Parse commandline parameters */ for (;;) { c =getopt (argc, argv,"la:c:d:h" );@@ -951,6 +952,7 @@ static int img_snapshot(int argc, char **argv)return 0 ; } action =SNAPSHOT_LIST ; + bdrv_oflags =BDRV_O_RDONLY ;/* no need for RW */ break ;case 'a' :if (action) {
qemu-img.c static int img_snapshot(int argc, char **argv) · line 993
Quoted 5 lines
qemu-img.c +1
-1@@ -988,7 +990,7 @@ static int img_snapshot(int argc, char **argv)if (!bs)error ("Not enough memory" ); -if (bdrv_open2 (bs, filename,0 ,NULL ) <0 ) { +if (bdrv_open2 (bs, filename, bdrv_oflags,NULL ) <0 ) {
Not related to your patch, but I think we want to have BRDV_O_FLAGS here, too. And we need to get rid of that typo some time. Well, I guess something for my own to-do list.
Quoted 62 lines
qemu-img.c +0
-0error ("Could not open '%s'" , filename); }qemu-nbd.c +1
-1@@ -212,7 +212,7 @@ int main(int argc, char **argv)int opt_ind =0 ;int li;char *end; -int flags =0 ; +int flags =BDRV_O_DFLT_OPEN ;int partition =-1 ;int ret;int shared =1 ;vl.c +10
-2@@ -2090,6 +2090,7 @@ DriveInfo *drive_init(QemuOpts *opts, void *opaque, int *fatal_error) {const char *buf; +const char *rw_buf =0 ;const char *file =NULL ;char devname[128 ];const char *serial;@@ -2104,12 +2105,12 @@ DriveInfo *drive_init(QemuOpts *opts, void *opaque,int index;int cache;int aio =0 ; -int ro =0 ;int bdrv_flags;int on_read_error, on_write_error;const char *devaddr;DriveInfo *dinfo;int snapshot =0 ; +int read_write, ro_fallback; *fatal_error =1 ;@@ -2137,7 +2138,7 @@ DriveInfo *drive_init(QemuOpts *opts, void *opaque, secs =qemu_opt_get_number (opts,"secs" ,0 ); snapshot =qemu_opt_get_bool (opts,"snapshot" ,0 ); - ro =qemu_opt_get_bool (opts,"readonly" ,0 ); + rw_buf =qemu_opt_get (opts,"read_write" ); file =qemu_opt_get (opts,"file" ); serial =qemu_opt_get (opts,"serial" );@@ -2420,6 +2421,29 @@ DriveInfo *drive_init(QemuOpts *opts, void *opaque, *fatal_error =0 ;return NULL ; } + + read_write =1 ; + ro_fallback =1 ; +if (rw_buf) { +if (!strcmp (rw_buf,"off" )) { + read_write =0 ; + ro_fallback =0 ;
vl.c DriveInfo *drive_init(QemuOpts *opts, void *opaque, · line 2440
Quoted 10 lines
vl.c +10
-0+if (type !=IF_SCSI && type !=IF_VIRTIO && type !=IF_FLOPPY ) { +fprintf (stderr,"qemu: read_write=off flag not supported for drive of this interface\n" ); +return NULL ; + } + }else if (!strcmp (rw_buf,"on" )) { + read_write =1 ; + ro_fallback =0 ; + }else if (!strcmp (rw_buf,"try" )) {/* default, but keep it explicit */ + read_write =1 ; + ro_fallback =1 ;
We probably should have the check or SCSI/virtio/floppy here, too. If the user explicitly requests that we should try read-only and it's not available with the device I think that's a reason to exit with an error.
Quoted 12 lines
vl.c +6
-0+ }else { +fprintf (stderr,"qemu: '%s' invalid read_write option (valid values: [on|off|try] )\n" , buf); +return NULL ; + } + } + bdrv_flags =0 ;if (snapshot) { bdrv_flags |=BDRV_O_SNAPSHOT ;@@ -2436,16 +2460,16 @@ DriveInfo *drive_init(QemuOpts *opts, void *opaque, bdrv_flags &= ~BDRV_O_NATIVE_AIO ; }
vl.c DriveInfo *drive_init(QemuOpts *opts, void *opaque, · line 2465
Quoted 10 lines
vl.c +3
-6-if (ro ==1 ) { -if (type ==IF_IDE ) { -fprintf (stderr,"qemu: readonly flag not supported for drive with ide interface\n" ); -return NULL ; - } - (void )bdrv_set_read_only (dinfo->bdrv,1 ); +if (read_write) { + bdrv_flags |=BDRV_O_RDWR ; + }
If BDRV_O_ACCESS continues to exist, BDRV_O_RDWR is not a flag but a value for that field. To make things clearer, I'd prefer something like this then:
/* Set BDRV_O_ACCESS value */bdrv_flags |= read_write ? BDRV_O_RDWR : BDRV_O_RDONLY;
vl.c DriveInfo *drive_init(QemuOpts *opts, void *opaque, · line 2475
Quoted 11 lines
vl.c +4
-1+if (ro_fallback) { + bdrv_flags |=BDRV_O_RO_FBCK ; } +if (bdrv_open2 (dinfo->bdrv, file, bdrv_flags, drv) <0 ) { -fprintf (stderr,"qemu: could not open disk image %s: %s\n" , +fprintf (stderr,"qemu: could not open disk image %s with requested permission: %s\n" , file,strerror (errno));return NULL ; }
Kevin
Quoted 8 lines · Naphtali Sprei
block.c | 29 +++++++++++++++++------------ block.h | 7 +++++-- hw/xen_disk.c | 3 ++- monitor.c | 2 +- qemu-config.c | 4 ++-- qemu-img.c | 14 ++++++++------ qemu-nbd.c | 2 +- vl.c | 42 +++++++++++++++++++++++++++++++++---------
Please update qemu-options.hx, the -drive documentation.
As well as helping users, this also allows us (libvirt, libguestfs) to detect whether the particular version of qemu we are using offers this feature.
Rich.
Signature · 4 lines
Richard Jones, Virtualization Group, Red Hat http://people.redhat.com/~rjones libguestfs lets you edit virtual machines. Supports shell scripting, bindings from many languages. http://et.redhat.com/~rjones/libguestfs/ See what it can do: http://et.redhat.com/~rjones/libguestfs/recipes.html