c/mirror_zfs
1
0
Fork 0
mirror of https://git.proxmox.com/git/mirror_zfs.git synced 2025-10-26 18:05:04 +03:00
Code Issues Packages Projects Releases Wiki Activity

txg: generalise txg_wait_synced_sig() to txg_wait_synced_flags() (#17284)

Browse Source 
txg_wait_synced_sig() is "wait for txg, unless a signal arrives". We
expect that future development will require similar "wait unless X"
behaviour.

This generalises the API as txg_wait_synced_flags(), where the provided
flags describe the events that should cause the call to return.

Instead of a boolean, the return is now an error code, which the caller
can use to know which event caused the call to return.

The existing call to txg_wait_synced_sig() is now
txg_wait_synced_flags(TXG_WAIT_SIGNAL).

Sponsored-by: Klara, Inc.
Sponsored-by: Wasabi Technology, Inc.

Signed-off-by: Rob Norris <robn@despairlabs.com>
Reviewed-by: Allan Jude <allan@klarasystems.com>
Reviewed-by: Alexander Motin <mav@FreeBSD.org>
(cherry picked from commit a7de203c86)
This commit is contained in:
Rob Norris 2025-05-03 08:29:50 +10:00 committed by Tony Hutter
parent 52749ebb49
commit ce9cd12c97
4 changed files with 52 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
include/sys/txg.h
View File

@ -66,6 +66,20 @@ typedef struct txg_list {
txg_node_t *tl_head[TXG_SIZE];
} txg_list_t;
/*
* Wait flags for txg_wait_synced_flags(). By default (TXG_WAIT_NONE), it will
* wait until the wanted txg is reached, or block forever. Additional flags
* indicate other conditions that the caller is interested in, that will cause
* the wait to break and return an error code describing the condition.
*/
typedef enum {
/* No special flags. Guaranteed to block forever or return 0 */
TXG_WAIT_NONE = 0,
/* If a signal arrives while waiting, abort and return EINTR */
TXG_WAIT_SIGNAL = (1 << 0),
} txg_wait_flag_t;
struct dsl_pool;
extern void txg_init(struct dsl_pool *dp, uint64_t txg);
@ -86,13 +100,16 @@ extern void txg_kick(struct dsl_pool *dp, uint64_t txg);
* Try to make this happen as soon as possible (eg. kick off any
* necessary syncs immediately). If txg==0, wait for the currently open
* txg to finish syncing.
* See txg_wait_flag_t above for a description of how the flags affect the wait.
*/
extern void txg_wait_synced(struct dsl_pool *dp, uint64_t txg);
extern int txg_wait_synced_flags(struct dsl_pool *dp, uint64_t txg,
txg_wait_flag_t flags);
/*
* Wait as above. Returns true if the thread was signaled while waiting.
* Traditional form of txg_wait_synced_flags, waits forever.
* Shorthand for VERIFY0(txg_wait_synced_flags(dp, TXG_WAIT_NONE))
*/
extern boolean_t txg_wait_synced_sig(struct dsl_pool *dp, uint64_t txg);
extern void txg_wait_synced(struct dsl_pool *dp, uint64_t txg);
/*
* Wait until the given transaction group, or one after it, is

19
module/zfs/dsl_synctask.c
View File

@ -86,12 +86,19 @@ top:
dmu_tx_commit(tx);
if (sigfunc != NULL && txg_wait_synced_sig(dp, dst.dst_txg)) {
/* current contract is to call func once */
sigfunc(arg, tx);
sigfunc = NULL; /* in case we're performing an EAGAIN retry */
}
txg_wait_synced(dp, dst.dst_txg);
if (sigfunc != NULL) {
err = txg_wait_synced_flags(dp, dst.dst_txg, TXG_WAIT_SIGNAL);
if (err != 0) {
VERIFY3U(err, ==, EINTR);
/* current contract is to call func once */
sigfunc(arg, tx);
/* in case we're performing an EAGAIN retry */
sigfunc = NULL;
txg_wait_synced(dp, dst.dst_txg);
}
} else
txg_wait_synced(dp, dst.dst_txg);
if (dst.dst_error == EAGAIN) {
txg_wait_synced(dp, dst.dst_txg + TXG_DEFER_SIZE);

34
module/zfs/txg.c
View File

@ -699,11 +699,13 @@ txg_delay(dsl_pool_t *dp, uint64_t txg, hrtime_t delay, hrtime_t resolution)
mutex_exit(&tx->tx_sync_lock);
}
static boolean_t
txg_wait_synced_impl(dsl_pool_t *dp, uint64_t txg, boolean_t wait_sig)
int
txg_wait_synced_flags(dsl_pool_t *dp, uint64_t txg, txg_wait_flag_t flags)
{
int error = 0;
tx_state_t *tx = &dp->dp_tx;
ASSERT0(flags & ~TXG_WAIT_SIGNAL);
ASSERT(!dsl_pool_config_held(dp));
mutex_enter(&tx->tx_sync_lock);
@ -715,13 +717,19 @@ txg_wait_synced_impl(dsl_pool_t *dp, uint64_t txg, boolean_t wait_sig)
dprintf("txg=%llu quiesce_txg=%llu sync_txg=%llu\n",
(u_longlong_t)txg, (u_longlong_t)tx->tx_quiesce_txg_waiting,
(u_longlong_t)tx->tx_sync_txg_waiting);
/*
* Keep pushing util the pool gets to the wanted txg. If something
* else interesting happens, we'll set an error and break out.
*/
while (tx->tx_synced_txg < txg) {
dprintf("broadcasting sync more "
"tx_synced=%llu waiting=%llu dp=%px\n",
(u_longlong_t)tx->tx_synced_txg,
(u_longlong_t)tx->tx_sync_txg_waiting, dp);
cv_broadcast(&tx->tx_sync_more_cv);
if (wait_sig) {
if (flags & TXG_WAIT_SIGNAL) {
/*
* Condition wait here but stop if the thread receives a
* signal. The caller may call txg_wait_synced*() again
@ -729,31 +737,23 @@ txg_wait_synced_impl(dsl_pool_t *dp, uint64_t txg, boolean_t wait_sig)
*/
if (cv_wait_io_sig(&tx->tx_sync_done_cv,
&tx->tx_sync_lock) == 0) {
mutex_exit(&tx->tx_sync_lock);
return (B_TRUE);
error = SET_ERROR(EINTR);
break;
}
} else {
/* Uninterruptable wait, until the condvar fires */
cv_wait_io(&tx->tx_sync_done_cv, &tx->tx_sync_lock);
}
}
mutex_exit(&tx->tx_sync_lock);
return (B_FALSE);
return (error);
}
void
txg_wait_synced(dsl_pool_t *dp, uint64_t txg)
{
VERIFY0(txg_wait_synced_impl(dp, txg, B_FALSE));
}
/*
* Similar to a txg_wait_synced but it can be interrupted from a signal.
* Returns B_TRUE if the thread was signaled while waiting.
*/
boolean_t
txg_wait_synced_sig(dsl_pool_t *dp, uint64_t txg)
{
return (txg_wait_synced_impl(dp, txg, B_TRUE));
VERIFY0(txg_wait_synced_flags(dp, txg, TXG_WAIT_NONE));
}
/*

4
module/zfs/zcp.c
View File

@ -970,8 +970,8 @@ zcp_pool_error(zcp_run_info_t *ri, const char *poolname, int error)
}
/*
* This callback is called when txg_wait_synced_sig encountered a signal.
* The txg_wait_synced_sig will continue to wait for the txg to complete
* This callback is called when txg_wait_synced_flags encountered a signal.
* The txg_wait_synced_flags will continue to wait for the txg to complete
* after calling this callback.
*/
static void