| Message ID | 1390972061-26560-3-git-send-email-famz@redhat.com |
|---|---|
| State | New |
| Headers | show |
The Wednesday 29 Jan 2014 à 13:07:29 (+0800), Fam Zheng wrote : > BlockDriverState.op_blockers is an array of lists with BLOCK_OP_TYPE_MAX > elements. Each list is a list of blockers of an operation type > (BlockOpType), that marks this BDS as currently blocked for a certain > type of operation with reason errors stored in the list. The rule of > usage is: > > * BDS user who wants to take an operation should check if there's any > blocker of the type with bdrv_op_is_blocked(). > > * BDS user who wants to block certain types of operation, should call > bdrv_op_block (or bdrv_op_block_all to block all types of operations, > which is similar to the existing bdrv_set_in_use()). > > * A blocker is only referenced by op_blockers, so the lifecycle is > managed by caller, and shouldn't be lost until unblock, so typically > a caller does these: > > - Allocate a blocker with error_setg or similar, call bdrv_op_block() > to block some operations. > - Hold the blocker, do his job. > - Unblock operations that it blocked, with the same reason pointer > passed to bdrv_op_unblock(). > - Release the blocker with error_free(). > > Signed-off-by: Fam Zheng <famz@redhat.com> > --- > block.c | 71 +++++++++++++++++++++++++++++++++++++++++++++++ > include/block/block.h | 7 +++++ > include/block/block_int.h | 5 ++++ > 3 files changed, 83 insertions(+) > > diff --git a/block.c b/block.c > index cb21a5f..967de98 100644 > --- a/block.c > +++ b/block.c > @@ -1838,6 +1838,8 @@ static void bdrv_move_feature_fields(BlockDriverState *bs_dest, > * We do want to swap name but don't want to swap linked list entries > */ > bs_dest->node_list = bs_src->node_list; > + memcpy(bs_dest->op_blockers, bs_src->op_blockers, > + sizeof(bs_dest->op_blockers)); > } > > /* > @@ -5119,6 +5121,75 @@ void bdrv_unref(BlockDriverState *bs) > } > } > > +struct BdrvOpBlocker { > + Error *reason; > + QLIST_ENTRY(BdrvOpBlocker) list; > +}; > + > +bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp) > +{ > + BdrvOpBlocker *blocker; > + assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX); > + if (!QLIST_EMPTY(&bs->op_blockers[op])) { > + blocker = QLIST_FIRST(&bs->op_blockers[op]); > + if (errp) { > + *errp = error_copy(blocker->reason); When an operation is blocked the first reason found is returned as **errp. I think that this could lead to some randomization of the error messages depending on the bdrv_op_block call order. > + } > + return true; > + } > + return false; > +} > + > +void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason) > +{ > + BdrvOpBlocker *blocker; > + assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX); > + > + blocker = g_malloc0(sizeof(BdrvOpBlocker)); > + blocker->reason = reason; > + QLIST_INSERT_HEAD(&bs->op_blockers[op], blocker, list); > +} > + > +void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason) > +{ > + BdrvOpBlocker *blocker, *next; > + assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX); > + QLIST_FOREACH_SAFE(blocker, &bs->op_blockers[op], list, next) { > + if (blocker->reason == reason) { > + QLIST_REMOVE(blocker, list); > + g_free(blocker); > + } > + } > +} > + > +void bdrv_op_block_all(BlockDriverState *bs, Error *reason) > +{ > + int i; > + for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) { > + bdrv_op_block(bs, i, reason); > + } > +} > + > +void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason) > +{ > + int i; > + for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) { > + bdrv_op_unblock(bs, i, reason); > + } > +} > + > +bool bdrv_op_blocker_is_empty(BlockDriverState *bs) > +{ > + int i; > + > + for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) { > + if (!QLIST_EMPTY(&bs->op_blockers[i])) { > + return false; > + } > + } > + return true; > +} > + > void bdrv_set_in_use(BlockDriverState *bs, int in_use) > { > assert(bs->in_use != in_use); > diff --git a/include/block/block.h b/include/block/block.h > index 9626650..f4a70c9 100644 > --- a/include/block/block.h > +++ b/include/block/block.h > @@ -473,6 +473,13 @@ void bdrv_unref(BlockDriverState *bs); > void bdrv_set_in_use(BlockDriverState *bs, int in_use); > int bdrv_in_use(BlockDriverState *bs); > > +bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp); > +void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason); > +void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason); > +void bdrv_op_block_all(BlockDriverState *bs, Error *reason); > +void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason); > +bool bdrv_op_blocker_is_empty(BlockDriverState *bs); > + > #ifdef CONFIG_LINUX_AIO > int raw_get_aio_fd(BlockDriverState *bs); > #else > diff --git a/include/block/block_int.h b/include/block/block_int.h > index 0bcf1c9..4e558d0 100644 > --- a/include/block/block_int.h > +++ b/include/block/block_int.h > @@ -270,6 +270,8 @@ typedef struct BlockLimits { > size_t opt_mem_alignment; > } BlockLimits; > > +typedef struct BdrvOpBlocker BdrvOpBlocker; > + > /* > * Note: the function bdrv_append() copies and swaps contents of > * BlockDriverStates, so if you add new fields to this struct, please > @@ -361,6 +363,9 @@ struct BlockDriverState { > > QLIST_HEAD(, BdrvTrackedRequest) tracked_requests; > > + /* operation blockers */ > + QLIST_HEAD(, BdrvOpBlocker) op_blockers[BLOCK_OP_TYPE_MAX]; > + > /* long-running background operation */ > BlockJob *job; > > -- > 1.8.5.3 > >
The Wednesday 29 Jan 2014 à 13:07:29 (+0800), Fam Zheng wrote : > BlockDriverState.op_blockers is an array of lists with BLOCK_OP_TYPE_MAX > elements. Each list is a list of blockers of an operation type > (BlockOpType), that marks this BDS as currently blocked for a certain > type of operation with reason errors stored in the list. The rule of > usage is: > > * BDS user who wants to take an operation should check if there's any > blocker of the type with bdrv_op_is_blocked(). > > * BDS user who wants to block certain types of operation, should call > bdrv_op_block (or bdrv_op_block_all to block all types of operations, > which is similar to the existing bdrv_set_in_use()). > > * A blocker is only referenced by op_blockers, so the lifecycle is > managed by caller, and shouldn't be lost until unblock, so typically > a caller does these: > > - Allocate a blocker with error_setg or similar, call bdrv_op_block() > to block some operations. > - Hold the blocker, do his job. > - Unblock operations that it blocked, with the same reason pointer > passed to bdrv_op_unblock(). > - Release the blocker with error_free(). > > Signed-off-by: Fam Zheng <famz@redhat.com> > --- > block.c | 71 +++++++++++++++++++++++++++++++++++++++++++++++ > include/block/block.h | 7 +++++ > include/block/block_int.h | 5 ++++ > 3 files changed, 83 insertions(+) > > diff --git a/block.c b/block.c > index cb21a5f..967de98 100644 > --- a/block.c > +++ b/block.c > @@ -1838,6 +1838,8 @@ static void bdrv_move_feature_fields(BlockDriverState *bs_dest, > * We do want to swap name but don't want to swap linked list entries > */ > bs_dest->node_list = bs_src->node_list; > + memcpy(bs_dest->op_blockers, bs_src->op_blockers, > + sizeof(bs_dest->op_blockers)); > } > > /* > @@ -5119,6 +5121,75 @@ void bdrv_unref(BlockDriverState *bs) > } > } > > +struct BdrvOpBlocker { > + Error *reason; > + QLIST_ENTRY(BdrvOpBlocker) list; > +}; > + > +bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp) > +{ > + BdrvOpBlocker *blocker; > + assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX); > + if (!QLIST_EMPTY(&bs->op_blockers[op])) { > + blocker = QLIST_FIRST(&bs->op_blockers[op]); > + if (errp) { > + *errp = error_copy(blocker->reason); > + } > + return true; > + } > + return false; > +} > + > +void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason) > +{ > + BdrvOpBlocker *blocker; > + assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX); > + > + blocker = g_malloc0(sizeof(BdrvOpBlocker)); > + blocker->reason = reason; > + QLIST_INSERT_HEAD(&bs->op_blockers[op], blocker, list); > +} > + > +void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason) > +{ > + BdrvOpBlocker *blocker, *next; > + assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX); > + QLIST_FOREACH_SAFE(blocker, &bs->op_blockers[op], list, next) { > + if (blocker->reason == reason) { > + QLIST_REMOVE(blocker, list); > + g_free(blocker); > + } > + } > +} > + > +void bdrv_op_block_all(BlockDriverState *bs, Error *reason) > +{ > + int i; > + for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) { > + bdrv_op_block(bs, i, reason); > + } > +} > + > +void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason) > +{ > + int i; > + for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) { > + bdrv_op_unblock(bs, i, reason); > + } > +} > + > +bool bdrv_op_blocker_is_empty(BlockDriverState *bs) > +{ > + int i; > + > + for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) { > + if (!QLIST_EMPTY(&bs->op_blockers[i])) { > + return false; > + } > + } > + return true; > +} > + > void bdrv_set_in_use(BlockDriverState *bs, int in_use) > { > assert(bs->in_use != in_use); > diff --git a/include/block/block.h b/include/block/block.h > index 9626650..f4a70c9 100644 > --- a/include/block/block.h > +++ b/include/block/block.h > @@ -473,6 +473,13 @@ void bdrv_unref(BlockDriverState *bs); > void bdrv_set_in_use(BlockDriverState *bs, int in_use); > int bdrv_in_use(BlockDriverState *bs); > > +bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp); > +void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason); > +void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason); > +void bdrv_op_block_all(BlockDriverState *bs, Error *reason); > +void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason); > +bool bdrv_op_blocker_is_empty(BlockDriverState *bs); > + > #ifdef CONFIG_LINUX_AIO > int raw_get_aio_fd(BlockDriverState *bs); > #else > diff --git a/include/block/block_int.h b/include/block/block_int.h > index 0bcf1c9..4e558d0 100644 > --- a/include/block/block_int.h > +++ b/include/block/block_int.h > @@ -270,6 +270,8 @@ typedef struct BlockLimits { > size_t opt_mem_alignment; > } BlockLimits; > > +typedef struct BdrvOpBlocker BdrvOpBlocker; > + > /* > * Note: the function bdrv_append() copies and swaps contents of > * BlockDriverStates, so if you add new fields to this struct, please > @@ -361,6 +363,9 @@ struct BlockDriverState { > > QLIST_HEAD(, BdrvTrackedRequest) tracked_requests; > > + /* operation blockers */ > + QLIST_HEAD(, BdrvOpBlocker) op_blockers[BLOCK_OP_TYPE_MAX]; Is a loop doing QLIST_INIT on this array elements required ? > + > /* long-running background operation */ > BlockJob *job; > > -- > 1.8.5.3 > >
On Thu, 02/13 13:24, Benoît Canet wrote: > The Wednesday 29 Jan 2014 à 13:07:29 (+0800), Fam Zheng wrote : > > +bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp) > > +{ > > + BdrvOpBlocker *blocker; > > + assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX); > > + if (!QLIST_EMPTY(&bs->op_blockers[op])) { > > + blocker = QLIST_FIRST(&bs->op_blockers[op]); > > + if (errp) { > > + *errp = error_copy(blocker->reason); > > When an operation is blocked the first reason found is returned as **errp. > > I think that this could lead to some randomization of the error messages > depending on the bdrv_op_block call order. > This is not randomization IMO. I think for a program that could fail with more than one reasons, it fails on and reports the first failure. This behavior is not uncommon. Being verbose here does not show much more help, but it's still very easy to add later when users asks for it. Fam
On Thu, 02/13 13:37, Benoît Canet wrote: > The Wednesday 29 Jan 2014 à 13:07:29 (+0800), Fam Zheng wrote : > > diff --git a/include/block/block_int.h b/include/block/block_int.h > > index 0bcf1c9..4e558d0 100644 > > --- a/include/block/block_int.h > > +++ b/include/block/block_int.h > > @@ -270,6 +270,8 @@ typedef struct BlockLimits { > > size_t opt_mem_alignment; > > } BlockLimits; > > > > +typedef struct BdrvOpBlocker BdrvOpBlocker; > > + > > /* > > * Note: the function bdrv_append() copies and swaps contents of > > * BlockDriverStates, so if you add new fields to this struct, please > > @@ -361,6 +363,9 @@ struct BlockDriverState { > > > > QLIST_HEAD(, BdrvTrackedRequest) tracked_requests; > > > > + /* operation blockers */ > > + QLIST_HEAD(, BdrvOpBlocker) op_blockers[BLOCK_OP_TYPE_MAX]; > > Is a loop doing QLIST_INIT on this array elements required ? > Yes, we better do it. Thanks, Fam
diff --git a/block.c b/block.c index cb21a5f..967de98 100644 --- a/block.c +++ b/block.c @@ -1838,6 +1838,8 @@ static void bdrv_move_feature_fields(BlockDriverState *bs_dest, * We do want to swap name but don't want to swap linked list entries */ bs_dest->node_list = bs_src->node_list; + memcpy(bs_dest->op_blockers, bs_src->op_blockers, + sizeof(bs_dest->op_blockers)); } /* @@ -5119,6 +5121,75 @@ void bdrv_unref(BlockDriverState *bs) } } +struct BdrvOpBlocker { + Error *reason; + QLIST_ENTRY(BdrvOpBlocker) list; +}; + +bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp) +{ + BdrvOpBlocker *blocker; + assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX); + if (!QLIST_EMPTY(&bs->op_blockers[op])) { + blocker = QLIST_FIRST(&bs->op_blockers[op]); + if (errp) { + *errp = error_copy(blocker->reason); + } + return true; + } + return false; +} + +void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason) +{ + BdrvOpBlocker *blocker; + assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX); + + blocker = g_malloc0(sizeof(BdrvOpBlocker)); + blocker->reason = reason; + QLIST_INSERT_HEAD(&bs->op_blockers[op], blocker, list); +} + +void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason) +{ + BdrvOpBlocker *blocker, *next; + assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX); + QLIST_FOREACH_SAFE(blocker, &bs->op_blockers[op], list, next) { + if (blocker->reason == reason) { + QLIST_REMOVE(blocker, list); + g_free(blocker); + } + } +} + +void bdrv_op_block_all(BlockDriverState *bs, Error *reason) +{ + int i; + for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) { + bdrv_op_block(bs, i, reason); + } +} + +void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason) +{ + int i; + for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) { + bdrv_op_unblock(bs, i, reason); + } +} + +bool bdrv_op_blocker_is_empty(BlockDriverState *bs) +{ + int i; + + for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) { + if (!QLIST_EMPTY(&bs->op_blockers[i])) { + return false; + } + } + return true; +} + void bdrv_set_in_use(BlockDriverState *bs, int in_use) { assert(bs->in_use != in_use); diff --git a/include/block/block.h b/include/block/block.h index 9626650..f4a70c9 100644 --- a/include/block/block.h +++ b/include/block/block.h @@ -473,6 +473,13 @@ void bdrv_unref(BlockDriverState *bs); void bdrv_set_in_use(BlockDriverState *bs, int in_use); int bdrv_in_use(BlockDriverState *bs); +bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp); +void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason); +void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason); +void bdrv_op_block_all(BlockDriverState *bs, Error *reason); +void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason); +bool bdrv_op_blocker_is_empty(BlockDriverState *bs); + #ifdef CONFIG_LINUX_AIO int raw_get_aio_fd(BlockDriverState *bs); #else diff --git a/include/block/block_int.h b/include/block/block_int.h index 0bcf1c9..4e558d0 100644 --- a/include/block/block_int.h +++ b/include/block/block_int.h @@ -270,6 +270,8 @@ typedef struct BlockLimits { size_t opt_mem_alignment; } BlockLimits; +typedef struct BdrvOpBlocker BdrvOpBlocker; + /* * Note: the function bdrv_append() copies and swaps contents of * BlockDriverStates, so if you add new fields to this struct, please @@ -361,6 +363,9 @@ struct BlockDriverState { QLIST_HEAD(, BdrvTrackedRequest) tracked_requests; + /* operation blockers */ + QLIST_HEAD(, BdrvOpBlocker) op_blockers[BLOCK_OP_TYPE_MAX]; + /* long-running background operation */ BlockJob *job;
BlockDriverState.op_blockers is an array of lists with BLOCK_OP_TYPE_MAX elements. Each list is a list of blockers of an operation type (BlockOpType), that marks this BDS as currently blocked for a certain type of operation with reason errors stored in the list. The rule of usage is: * BDS user who wants to take an operation should check if there's any blocker of the type with bdrv_op_is_blocked(). * BDS user who wants to block certain types of operation, should call bdrv_op_block (or bdrv_op_block_all to block all types of operations, which is similar to the existing bdrv_set_in_use()). * A blocker is only referenced by op_blockers, so the lifecycle is managed by caller, and shouldn't be lost until unblock, so typically a caller does these: - Allocate a blocker with error_setg or similar, call bdrv_op_block() to block some operations. - Hold the blocker, do his job. - Unblock operations that it blocked, with the same reason pointer passed to bdrv_op_unblock(). - Release the blocker with error_free(). Signed-off-by: Fam Zheng <famz@redhat.com> --- block.c | 71 +++++++++++++++++++++++++++++++++++++++++++++++ include/block/block.h | 7 +++++ include/block/block_int.h | 5 ++++ 3 files changed, 83 insertions(+)