Block drivers can implement this new operation .bdrv_lockf to actually lock the
image in the protocol specific way.
Signed-off-by: Fam Zheng <f...@redhat.com>
---
block.c | 57 +++++++++++++++++++++++++++++++++++++++++++++++
include/block/block.h | 11 ++++++++-
include/block/block_int.h | 5 +++++
3 files changed, 72 insertions(+), 1 deletion(-)
diff --git a/block.c b/block.c
index 736432f..4c2a3ff 100644
--- a/block.c
+++ b/block.c
@@ -854,6 +854,50 @@ out:
g_free(gen_node_name);
}
+BdrvLockfCmd bdrv_get_locking_cmd(int flags)
+{
+ if (flags & BDRV_O_NO_LOCK) {
+ return BDRV_LOCKF_UNLOCK;
+ } else if (flags & BDRV_O_SHARED_LOCK) {
+ return BDRV_LOCKF_SHARED;
+ } else if (flags & BDRV_O_RDWR) {
+ return BDRV_LOCKF_EXCLUSIVE;
+ } else {
+ return BDRV_LOCKF_SHARED;
+ }
+}
+
+static int bdrv_lock_unlock_image_do(BlockDriverState *bs, BdrvLockfCmd cmd)
+{
+ int ret;
+
+ if (bs->cur_lock == cmd) {
+ return 0;
+ } else if (!bs->drv) {
+ return -ENOMEDIUM;
+ } else if (!bs->drv->bdrv_lockf) {
+ return 0;
+ }
+ ret = bs->drv->bdrv_lockf(bs, cmd);
+ if (ret == -ENOTSUP) {
+ /* Handle it the same way as !bs->drv->bdrv_lockf */
+ ret = 0;
+ } else if (ret == 0) {
+ bs->cur_lock = cmd;
+ }
+ return ret;
+}
+
+static int bdrv_lock_image(BlockDriverState *bs)
+{
+ return bdrv_lock_unlock_image_do(bs, bdrv_get_locking_cmd(bs->open_flags));
+}
+
+static int bdrv_unlock_image(BlockDriverState *bs)
+{
+ return bdrv_lock_unlock_image_do(bs, BDRV_LOCKF_UNLOCK);
+}
+
static QemuOptsList bdrv_runtime_opts = {
.name = "bdrv_common",
.head = QTAILQ_HEAD_INITIALIZER(bdrv_runtime_opts.head),
@@ -1003,6 +1047,14 @@ static int bdrv_open_common(BlockDriverState *bs,
BdrvChild *file,
goto free_and_fail;
}
+ if (!(open_flags & (BDRV_O_NO_LOCK | BDRV_O_INACTIVE))) {
+ ret = bdrv_lock_image(bs);
+ if (ret) {
+ error_setg(errp, "Failed to lock image");
+ goto free_and_fail;
+ }
+ }
+
ret = refresh_total_sectors(bs, bs->total_sectors);
if (ret < 0) {
error_setg_errno(errp, -ret, "Could not refresh total sector count");
@@ -2164,6 +2216,7 @@ static void bdrv_close(BlockDriverState *bs)
if (bs->drv) {
BdrvChild *child, *next;
+ bdrv_unlock_image(bs);
bs->drv->bdrv_close(bs);
bs->drv = NULL;
@@ -3187,6 +3240,9 @@ void bdrv_invalidate_cache(BlockDriverState *bs, Error
**errp)
error_setg_errno(errp, -ret, "Could not refresh total sector count");
return;
}
+ if (!(bs->open_flags & BDRV_O_NO_LOCK)) {
+ bdrv_lock_image(bs);
+ }
}
void bdrv_invalidate_cache_all(Error **errp)
@@ -3229,6 +3285,7 @@ static int bdrv_inactivate_recurse(BlockDriverState *bs,
}
if (setting_flag) {
+ ret = bdrv_unlock_image(bs);
bs->open_flags |= BDRV_O_INACTIVE;
}
return 0;
diff --git a/include/block/block.h b/include/block/block.h
index 02b598b..782ef2f 100644
--- a/include/block/block.h
+++ b/include/block/block.h
@@ -183,6 +183,15 @@ typedef enum BlockOpType {
BLOCK_OP_TYPE_MAX,
} BlockOpType;
+typedef enum {
+ /* The values are ordered so that lower number implies higher restriction.
+ * Starting from 1 to make 0 an invalid value.
+ * */
+ BDRV_LOCKF_EXCLUSIVE = 1,
+ BDRV_LOCKF_SHARED,
+ BDRV_LOCKF_UNLOCK,
+} BdrvLockfCmd;
+
void bdrv_info_print(Monitor *mon, const QObject *data);
void bdrv_info(Monitor *mon, QObject **ret_data);
void bdrv_stats_print(Monitor *mon, const QObject *data);
@@ -274,7 +283,7 @@ int bdrv_drop_intermediate(BlockDriverState *active,
BlockDriverState *top,
BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
BlockDriverState *bs);
BlockDriverState *bdrv_find_base(BlockDriverState *bs);
-
+BdrvLockfCmd bdrv_get_locking_cmd(int flags);
typedef struct BdrvCheckResult {
int corruptions;
diff --git a/include/block/block_int.h b/include/block/block_int.h
index 30a9717..29cc632 100644
--- a/include/block/block_int.h
+++ b/include/block/block_int.h
@@ -317,6 +317,10 @@ struct BlockDriver {
Error **errp);
void (*bdrv_del_child)(BlockDriverState *parent, BdrvChild *child,
Error **errp);
+ /**
+ * Lock/unlock the image.
+ */
+ int (*bdrv_lockf)(BlockDriverState *bs, BdrvLockfCmd cmd);
QLIST_ENTRY(BlockDriver) list;
};
@@ -500,6 +504,7 @@ struct BlockDriverState {
unsigned io_plug_disabled;
int quiesce_counter;
+ BdrvLockfCmd cur_lock;
};
struct BlockBackendRootState {
--
2.8.2
