The following changes since commit 5704c36d25ee84e7129722cb0db53df9faefe943:

Merge remote-tracking branch 'remotes/kraxel/tags/fixes-31-20181112-pull-request' into staging (2018-11-12 15:55:40 +0000)

for you to fetch changes up to 1a42e5d8298d1b0f90d2254e7d559391dd3a45ca:

Merge remote-tracking branch 'mreitz/tags/pull-block-2018-11-12' into queue-block (2018-11-12 17:57:32 +0100)

Block layer patches:

- file-posix: Don't waste a file descriptor for locking, don't lock the

same bit multiple times

- nvme: Fix double free and memory leak

- Misc error handling fixes

- Added NULL checks found by static analysis

- Allow more block drivers to not be included in the qemu build

Fam Zheng (4):

file-posix: Use error API properly

file-posix: Skip effectiveless OFD lock operations

file-posix: Drop s->lock_fd

tests: Add unit tests for image locking

Jeff Cody (1):

block: Make more block drivers compile-time configurable

Kevin Wolf (1):

Merge remote-tracking branch 'mreitz/tags/pull-block-2018-11-12' into queue-block

Li Qiang (2):

nvme: don't unref ctrl_mem when device unrealized

nvme: free cmbuf in nvme_exit

From: Liam Merwick <Liam.Merwick@oracle.com>

Although the function block_job_get() can return NULL, it would be a

serious bug if it did so (because the job yields before executing anything

(if it started successfully); but otherwise, commit_active_start() would

have returned an error). However, as a precaution, before dereferencing

the 'job' pointer in img_commit() assert it is not NULL.

Signed-off-by: Liam Merwick <Liam.Merwick@oracle.com>

Reviewed-by: Max Reitz <mreitz@redhat.com>

Message-id: 1541453919-25973-4-git-send-email-Liam.Merwick@oracle.com

Signed-off-by: Max Reitz <mreitz@redhat.com>

qemu-img.c | 1 +

1 file changed, 1 insertion(+)

diff --git a/qemu-img.c b/qemu-img.c

--- a/qemu-img.c

+++ b/qemu-img.c

@@ -XXX,XX +XXX,XX @@ static int img_commit(int argc, char **argv)

}

job = block_job_get("commit");

+ assert(job);

run_block_job(job, &local_err);

if (local_err) {

goto unref_backing;

2.19.1

From: Fam Zheng <famz@redhat.com>

The lock_fd field is not strictly necessary because transferring locked

bytes from old fd to the new one shouldn't fail anyway. This spares the

user one fd per image.

Signed-off-by: Fam Zheng <famz@redhat.com>

Reviewed-by: Max Reitz <mreitz@redhat.com>

block/file-posix.c | 37 +++++++++++++------------------------

1 file changed, 13 insertions(+), 24 deletions(-)

diff --git a/block/file-posix.c b/block/file-posix.c

--- a/block/file-posix.c

+++ b/block/file-posix.c

@@ -XXX,XX +XXX,XX @@ do { \

typedef struct BDRVRawState {

int fd;

- int lock_fd;

bool use_lock;

int type;

int open_flags;

@@ -XXX,XX +XXX,XX @@ typedef struct BDRVRawState {

uint64_t shared_perm;

/* The perms bits whose corresponding bytes are already locked in

- * s->lock_fd. */

+ * s->fd. */

uint64_t locked_perm;

uint64_t locked_shared_perm;

@@ -XXX,XX +XXX,XX @@ static int raw_open_common(BlockDriverState *bs, QDict *options,

s->fd = fd;

- s->lock_fd = -1;

- if (s->use_lock) {

- fd = qemu_open(filename, s->open_flags);

- if (fd < 0) {

- ret = -errno;

- error_setg_errno(errp, errno, "Could not open '%s' for locking",

- filename);

- qemu_close(s->fd);

- goto fail;

- }

- s->lock_fd = fd;

- }

s->perm = 0;

s->shared_perm = BLK_PERM_ALL;

@@ -XXX,XX +XXX,XX @@ static int raw_handle_perm_lock(BlockDriverState *bs,

return 0;

- assert(s->lock_fd > 0);

switch (op) {

case RAW_PL_PREPARE:

- ret = raw_apply_lock_bytes(s, s->lock_fd, s->perm | new_perm,

+ ret = raw_apply_lock_bytes(s, s->fd, s->perm | new_perm,

~s->shared_perm | ~new_shared,

false, errp);

if (!ret) {

- ret = raw_check_lock_bytes(s->lock_fd, new_perm, new_shared, errp);

+ ret = raw_check_lock_bytes(s->fd, new_perm, new_shared, errp);

if (!ret) {

return 0;

}

@@ -XXX,XX +XXX,XX @@ static int raw_handle_perm_lock(BlockDriverState *bs,

op = RAW_PL_ABORT;

/* fall through to unlock bytes. */

case RAW_PL_ABORT:

- raw_apply_lock_bytes(s, s->lock_fd, s->perm, ~s->shared_perm,

+ raw_apply_lock_bytes(s, s->fd, s->perm, ~s->shared_perm,

true, &local_err);

if (local_err) {

/* Theoretically the above call only unlocks bytes and it cannot

@@ -XXX,XX +XXX,XX @@ static int raw_handle_perm_lock(BlockDriverState *bs,

}

break;

case RAW_PL_COMMIT:

- raw_apply_lock_bytes(s, s->lock_fd, new_perm, ~new_shared,

+ raw_apply_lock_bytes(s, s->fd, new_perm, ~new_shared,

true, &local_err);

if (local_err) {

/* Theoretically the above call only unlocks bytes and it cannot

@@ -XXX,XX +XXX,XX @@ static void raw_reopen_commit(BDRVReopenState *state)

{

BDRVRawReopenState *rs = state->opaque;

BDRVRawState *s = state->bs->opaque;

+ Error *local_err = NULL;

s->check_cache_dropped = rs->check_cache_dropped;

s->open_flags = rs->open_flags;

+ /* Copy locks to the new fd before closing the old one. */

+ raw_apply_lock_bytes(NULL, rs->fd, s->locked_perm,

+ ~s->locked_shared_perm, false, &local_err);

+ if (local_err) {

+ /* shouldn't fail in a sane host, but report it just in case. */

+ error_report_err(local_err);

+ }

qemu_close(s->fd);

s->fd = rs->fd;

@@ -XXX,XX +XXX,XX @@ static void raw_close(BlockDriverState *bs)

qemu_close(s->fd);

s->fd = -1;

}

- if (s->lock_fd >= 0) {

- qemu_close(s->lock_fd);

- s->lock_fd = -1;

- }

/**

2.19.1

From: Liam Merwick <Liam.Merwick@oracle.com>

The calls to find_mapping_for_cluster() may return NULL but it

isn't always checked for before dereferencing the value returned.

Additionally, add some asserts to cover cases where NULL can't

be returned but which might not be obvious at first glance.

Signed-off-by: Liam Merwick <Liam.Merwick@oracle.com>

Message-id: 1541453919-25973-5-git-send-email-Liam.Merwick@oracle.com

[mreitz: Dropped superfluous check of "mapping" following an assertion

that it is not NULL, and fixed some indentation]

Signed-off-by: Max Reitz <mreitz@redhat.com>

block/vvfat.c | 46 ++++++++++++++++++++++++++++++----------------

1 file changed, 30 insertions(+), 16 deletions(-)

diff --git a/block/vvfat.c b/block/vvfat.c

--- a/block/vvfat.c

+++ b/block/vvfat.c

@@ -XXX,XX +XXX,XX @@ static inline void array_free(array_t* array)

/* does not automatically grow */

static inline void* array_get(array_t* array,unsigned int index) {

assert(index < array->next);

+ assert(array->pointer);

return array->pointer + index * array->item_size;

-static inline int array_ensure_allocated(array_t* array, int index)

+static inline void array_ensure_allocated(array_t *array, int index)

if((index + 1) * array->item_size > array->size) {

int new_size = (index + 32) * array->item_size;

array->pointer = g_realloc(array->pointer, new_size);

- if (!array->pointer)

- return -1;

+ assert(array->pointer);

memset(array->pointer + array->size, 0, new_size - array->size);

array->size = new_size;

array->next = index + 1;

-

- return 0;

static inline void* array_get_next(array_t* array) {

unsigned int next = array->next;

- if (array_ensure_allocated(array, next) < 0)

- return NULL;

-

+ array_ensure_allocated(array, next);

array->next = next + 1;

return array_get(array, next);

}

@@ -XXX,XX +XXX,XX @@ static int commit_direntries(BDRVVVFATState* s,

direntry_t* direntry = array_get(&(s->directory), dir_index);

uint32_t first_cluster = dir_index == 0 ? 0 : begin_of_direntry(direntry);

mapping_t* mapping = find_mapping_for_cluster(s, first_cluster);

-

int factor = 0x10 * s->sectors_per_cluster;

int old_cluster_count, new_cluster_count;

- int current_dir_index = mapping->info.dir.first_dir_index;

- int first_dir_index = current_dir_index;

+ int current_dir_index;

+ int first_dir_index;

int ret, i;

uint32_t c;

-DLOG(fprintf(stderr, "commit_direntries for %s, parent_mapping_index %d\n", mapping->path, parent_mapping_index));

-

assert(direntry);

assert(mapping);

assert(mapping->begin == first_cluster);

@@ -XXX,XX +XXX,XX @@ DLOG(fprintf(stderr, "commit_direntries for %s, parent_mapping_index %d\n", mapp

assert(mapping->mode & MODE_DIRECTORY);

assert(dir_index == 0 || is_directory(direntry));

+ DLOG(fprintf(stderr, "commit_direntries for %s, parent_mapping_index %d\n",

+ mapping->path, parent_mapping_index));

+

+ current_dir_index = mapping->info.dir.first_dir_index;

+ first_dir_index = current_dir_index;

mapping->info.dir.parent_mapping_index = parent_mapping_index;

if (first_cluster == 0) {

@@ -XXX,XX +XXX,XX @@ DLOG(fprintf(stderr, "commit_direntries for %s, parent_mapping_index %d\n", mapp

direntry = array_get(&(s->directory), first_dir_index + i);

if (is_directory(direntry) && !is_dot(direntry)) {

mapping = find_mapping_for_cluster(s, first_cluster);

+ if (mapping == NULL) {

+ return -1;

+ }

assert(mapping->mode & MODE_DIRECTORY);

ret = commit_direntries(s, first_dir_index + i,

array_index(&(s->mapping), mapping));

@@ -XXX,XX +XXX,XX @@ static int commit_one_file(BDRVVVFATState* s,

assert(offset < size);

assert((offset % s->cluster_size) == 0);

+ if (mapping == NULL) {

+ return -1;

+ }

+

for (i = s->cluster_size; i < offset; i += s->cluster_size)

c = modified_fat_get(s, c);

@@ -XXX,XX +XXX,XX @@ static int handle_renames_and_mkdirs(BDRVVVFATState* s)

if (commit->action == ACTION_RENAME) {

mapping_t* mapping = find_mapping_for_cluster(s,

commit->param.rename.cluster);

- char* old_path = mapping->path;

+ char *old_path;

+ if (mapping == NULL) {

+ return -1;

+ }

+ old_path = mapping->path;

assert(commit->path);

mapping->path = commit->path;

if (rename(old_path, mapping->path))

@@ -XXX,XX +XXX,XX @@ static int handle_renames_and_mkdirs(BDRVVVFATState* s)

direntry_t* d = direntry + i;

if (is_file(d) || (is_directory(d) && !is_dot(d))) {

+ int l;

+ char *new_path;

mapping_t* m = find_mapping_for_cluster(s,

begin_of_direntry(d));

- int l = strlen(m->path);

- char* new_path = g_malloc(l + diff + 1);

+ if (m == NULL) {

+ return -1;

+ }

+ l = strlen(m->path);

+ new_path = g_malloc(l + diff + 1);

assert(!strncmp(m->path, mapping->path, l2));

2.19.1

From: zhenwei pi <pizhenwei@bytedance.com>

Function block_latency_histogram_set may return error, but qapi ignore this.

This can be reproduced easily by qmp command:

virsh qemu-monitor-command INSTANCE '{"execute":"x-block-latency-histogram-set",

"arguments":{"device":"drive-virtio-disk1","boundaries":[10,200,40]}}'

In fact this command does not work, but we still get success result.

qmp_x_block_latency_histogram_set is a batch setting API, report error ASAP.

Signed-off-by: zhenwei pi <pizhenwei@bytedance.com>

blockdev.c | 19 ++++++++++++++++---

1 file changed, 16 insertions(+), 3 deletions(-)

diff --git a/blockdev.c b/blockdev.c

--- a/blockdev.c

+++ b/blockdev.c

@@ -XXX,XX +XXX,XX @@ void qmp_x_block_latency_histogram_set(

{

BlockBackend *blk = blk_by_name(device);

BlockAcctStats *stats;

+ int ret;

if (!blk) {

error_setg(errp, "Device '%s' not found", device);

@@ -XXX,XX +XXX,XX @@ void qmp_x_block_latency_histogram_set(

if (has_boundaries || has_boundaries_read) {

- block_latency_histogram_set(

+ ret = block_latency_histogram_set(

stats, BLOCK_ACCT_READ,

has_boundaries_read ? boundaries_read : boundaries);

+ if (ret) {

+ error_setg(errp, "Device '%s' set read boundaries fail", device);

+ return;

+ }

2.19.1

From: Fam Zheng <famz@redhat.com>

Use error_report for situations that affect user operation (i.e. we're

actually returning error), and warn_report/warn_report_err when some

less critical error happened but the user operation can still carry on.

For raw_normalize_devicepath, add Error parameter to propagate to

its callers.

Suggested-by: Markus Armbruster <armbru@redhat.com>

Signed-off-by: Fam Zheng <famz@redhat.com>

block/file-posix.c | 39 ++++++++++++++++-----------------------

1 file changed, 16 insertions(+), 23 deletions(-)

diff --git a/block/file-posix.c b/block/file-posix.c

--- a/block/file-posix.c

+++ b/block/file-posix.c

@@ -XXX,XX +XXX,XX @@ static int cdrom_reopen(BlockDriverState *bs);

#endif

#if defined(__NetBSD__)

-static int raw_normalize_devicepath(const char **filename)

+static int raw_normalize_devicepath(const char **filename, Error **errp)

static char namebuf[PATH_MAX];

const char *dp, *fname;

@@ -XXX,XX +XXX,XX @@ static int raw_normalize_devicepath(const char **filename)

fname = *filename;

dp = strrchr(fname, '/');

if (lstat(fname, &sb) < 0) {

- fprintf(stderr, "%s: stat failed: %s\n",

- fname, strerror(errno));

+ error_setg_errno(errp, errno, "%s: stat failed", fname);

return -errno;

@@ -XXX,XX +XXX,XX @@ static int raw_normalize_devicepath(const char **filename)

snprintf(namebuf, PATH_MAX, "%.*s/r%s",

(int)(dp - fname), fname, dp + 1);

}

- fprintf(stderr, "%s is a block device", fname);

*filename = namebuf;

- fprintf(stderr, ", using %s\n", *filename);

+ warn_report("%s is a block device, using %s", fname, *filename);

#else

-static int raw_normalize_devicepath(const char **filename)

+static int raw_normalize_devicepath(const char **filename, Error **errp)

return 0;

2.19.1

From: Liam Merwick <Liam.Merwick@oracle.com>

The dev_id returned by the call to blk_get_attached_dev_id() in

blk_root_get_parent_desc() can be NULL (an internal call to

object_get_canonical_path may have returned NULL).

Instead of just checking this case before before dereferencing,

adjust blk_get_attached_dev_id() to return the empty string if no

object path can be found (similar to the case when blk->dev is NULL

and an empty string is returned).

Signed-off-by: Liam Merwick <Liam.Merwick@oracle.com>

Message-id: 1541453919-25973-3-git-send-email-Liam.Merwick@oracle.com

Reviewed-by: Max Reitz <mreitz@redhat.com>

Signed-off-by: Max Reitz <mreitz@redhat.com>

---

block/block-backend.c | 3 ++-

1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/block/block-backend.c b/block/block-backend.c

--- a/block/block-backend.c

+++ b/block/block-backend.c

@@ -XXX,XX +XXX,XX @@ char *blk_get_attached_dev_id(BlockBackend *blk)

} else if (dev->id) {

return g_strdup(dev->id);

- return object_get_canonical_path(OBJECT(dev));

+ return object_get_canonical_path(OBJECT(dev)) ?: g_strdup("");

2.19.1

From: Liam Merwick <Liam.Merwick@oracle.com>

In the assert checking the array dereference of JobVerbTable[verb]

in job_apply_verb() the check of the index, verb, allows an overrun

because an index equal to the array size is permitted.

Similarly, in the assert check of JobSTT[s0][s1] with index s1

in job_state_transition(), an off-by-one overrun is not flagged

either.

This is not a run-time issue as there are no callers actually

passing in the max value.

Signed-off-by: Liam Merwick <Liam.Merwick@oracle.com>

Reviewed-by: Darren Kenny <Darren.Kenny@oracle.com>

Reviewed-by: Mark Kanda <Mark.Kanda@oracle.com>

Reviewed-by: Eric Blake <eblake@redhat.com>

Reviewed-by: John Snow <jsnow@redhat.com>

Message-id: 1541453919-25973-2-git-send-email-Liam.Merwick@oracle.com

Signed-off-by: Max Reitz <mreitz@redhat.com>

job.c | 4 ++--

1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/job.c b/job.c

--- a/job.c

+++ b/job.c

@@ -XXX,XX +XXX,XX @@ bool job_is_internal(Job *job)

static void job_state_transition(Job *job, JobStatus s1)

JobStatus s0 = job->status;

- assert(s1 >= 0 && s1 <= JOB_STATUS__MAX);

+ assert(s1 >= 0 && s1 < JOB_STATUS__MAX);

trace_job_state_transition(job, job->ret,

JobSTT[s0][s1] ? "allowed" : "disallowed",

JobStatus_str(s0), JobStatus_str(s1));

@@ -XXX,XX +XXX,XX @@ static void job_state_transition(Job *job, JobStatus s1)

int job_apply_verb(Job *job, JobVerb verb, Error **errp)

JobStatus s0 = job->status;

- assert(verb >= 0 && verb <= JOB_VERB__MAX);

+ assert(verb >= 0 && verb < JOB_VERB__MAX);

trace_job_apply_verb(job, JobStatus_str(s0), JobVerb_str(verb),

JobVerbTable[verb][s0] ? "allowed" : "prohibited");

if (JobVerbTable[verb][s0]) {

2.19.1

From: Fam Zheng <famz@redhat.com>

Signed-off-by: Fam Zheng <famz@redhat.com>

tests/test-image-locking.c | 157 +++++++++++++++++++++++++++++++++++++

tests/Makefile.include | 2 +

2 files changed, 159 insertions(+)

create mode 100644 tests/test-image-locking.c

diff --git a/tests/test-image-locking.c b/tests/test-image-locking.c

new file mode 100644

index XXXXXXX..XXXXXXX

--- /dev/null

+++ b/tests/test-image-locking.c

@@ -XXX,XX +XXX,XX @@

+/*

+ * Image locking tests

+ * Copyright (c) 2018 Red Hat Inc.

+ * Author: Fam Zheng <famz@redhat.com>

+ * 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

+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

+ * copies of the Software, and to permit persons to whom the Software is

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in

+ * all copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

+ * THE SOFTWARE.

+

+#include "qemu/osdep.h"

+#include "block/block.h"

+#include "sysemu/block-backend.h"

+#include "qapi/error.h"

+#include "qapi/qmp/qdict.h"

+

+static BlockBackend *open_image(const char *path,

+ uint64_t perm, uint64_t shared_perm,

+ Error **errp)

+{

+ Error *local_err = NULL;

+ BlockBackend *blk;

+ QDict *options = qdict_new();

+

+ qdict_put_str(options, "driver", "raw");

+ blk = blk_new_open(path, NULL, options, BDRV_O_RDWR, &local_err);

+ if (blk) {

+ g_assert_null(local_err);

+ if (blk_set_perm(blk, perm, shared_perm, errp)) {

+ blk_unref(blk);

+ blk = NULL;

+ }

+ } else {

+ error_propagate(errp, local_err);

+ }

+ return blk;

+}

+

+static void check_locked_bytes(int fd, uint64_t perm_locks,

+ uint64_t shared_perm_locks)

+{

+ int i;

+

+ if (!perm_locks && !shared_perm_locks) {

+ g_assert(!qemu_lock_fd_test(fd, 0, 0, true));

+ return;

+ }

+ for (i = 0; (1ULL << i) <= BLK_PERM_ALL; i++) {

+ uint64_t bit = (1ULL << i);

+ bool perm_expected = !!(bit & perm_locks);

+ bool shared_perm_expected = !!(bit & shared_perm_locks);

+ g_assert_cmpint(perm_expected, ==,

+ !!qemu_lock_fd_test(fd, 100 + i, 1, true));

+ g_assert_cmpint(shared_perm_expected, ==,

+ !!qemu_lock_fd_test(fd, 200 + i, 1, true));

+ }

+}

+

+static void test_image_locking_basic(void)

+{

+ BlockBackend *blk1, *blk2, *blk3;

+ char img_path[] = "/tmp/qtest.XXXXXX";

+ uint64_t perm, shared_perm;

+

+ int fd = mkstemp(img_path);

+ assert(fd >= 0);

+

+ perm = BLK_PERM_WRITE | BLK_PERM_CONSISTENT_READ;

+ shared_perm = BLK_PERM_ALL;

+ blk1 = open_image(img_path, perm, shared_perm, &error_abort);

+ g_assert(blk1);

+

+ check_locked_bytes(fd, perm, ~shared_perm);

+

+ /* compatible perm between blk1 and blk2 */

+ blk2 = open_image(img_path, perm | BLK_PERM_RESIZE, shared_perm, NULL);

+ g_assert(blk2);

+ check_locked_bytes(fd, perm | BLK_PERM_RESIZE, ~shared_perm);

+

+ /* incompatible perm with already open blk1 and blk2 */

+ blk3 = open_image(img_path, perm, BLK_PERM_WRITE_UNCHANGED, NULL);

+ g_assert_null(blk3);

+

+ blk_unref(blk2);

+

+ /* Check that extra bytes in blk2 are correctly unlocked */

+ check_locked_bytes(fd, perm, ~shared_perm);

+

+ blk_unref(blk1);

+

+ /* Image is unused, no lock there */

+ check_locked_bytes(fd, 0, 0);

+ blk3 = open_image(img_path, perm, BLK_PERM_WRITE_UNCHANGED, &error_abort);

+ g_assert(blk3);

+ blk_unref(blk3);

+ close(fd);

+ unlink(img_path);

+}

+

+static void test_set_perm_abort(void)

+{

+ BlockBackend *blk1, *blk2;

+ char img_path[] = "/tmp/qtest.XXXXXX";

+ uint64_t perm, shared_perm;

+ int r;

+ int fd = mkstemp(img_path);

+ assert(fd >= 0);

+

+ perm = BLK_PERM_WRITE | BLK_PERM_CONSISTENT_READ;

+ shared_perm = BLK_PERM_ALL;

+ blk1 = open_image(img_path, perm, shared_perm, &error_abort);

+ g_assert(blk1);

+

+ blk2 = open_image(img_path, perm, shared_perm, &error_abort);

+ g_assert(blk2);

+

+ check_locked_bytes(fd, perm, ~shared_perm);

+

+ /* A failed blk_set_perm mustn't change perm status (locked bytes) */

+ r = blk_set_perm(blk2, perm | BLK_PERM_RESIZE, BLK_PERM_WRITE_UNCHANGED,

+ NULL);

+ g_assert_cmpint(r, !=, 0);

+ check_locked_bytes(fd, perm, ~shared_perm);

+ blk_unref(blk1);

+ blk_unref(blk2);

+}

+

+int main(int argc, char **argv)

+{

+ bdrv_init();

+ qemu_init_main_loop(&error_abort);