From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: From: Vladimir Davydov Subject: [PATCH v2 1/3] vinyl: make tx_manager_abort_writers_for_ddl more thorough Date: Thu, 28 Mar 2019 18:52:27 +0300 Message-Id: <1574fba56e436ce5129fc0a2853afb3f8c946279.1553787937.git.vdavydov.dev@gmail.com> In-Reply-To: References: In-Reply-To: References: To: kostja@tarantool.org Cc: tarantool-patches@freelists.org List-ID: We need to abort all transactions writing to an altered space when a new index is built. Currently, we use the write set to look up such transactions, but it isn't quite correct, because a transaction could yield on disk read before inserting a statement into the write set. To address this problem, this patch adds vy_tx->last_lsm, which points to the primary index of the space affected by the last prepared transaction. Now, tx_manager_abort_writers_for_ddl will look not only at the write set, but also at this variable to check if it needs to abort a transaction. Needed for #3420 --- src/box/vinyl.c | 4 +++- src/box/vy_tx.c | 8 ++++++-- src/box/vy_tx.h | 15 ++++++++++++++- 3 files changed, 23 insertions(+), 4 deletions(-) diff --git a/src/box/vinyl.c b/src/box/vinyl.c index 3ef43e18..24f900cb 100644 --- a/src/box/vinyl.c +++ b/src/box/vinyl.c @@ -2433,8 +2433,10 @@ vinyl_engine_begin_statement(struct engine *engine, struct txn *txn) (void)engine; struct vy_tx *tx = txn->engine_tx; struct txn_stmt *stmt = txn_current_stmt(txn); + struct index *pk = space_index(stmt->space, 0); assert(tx != NULL); - return vy_tx_begin_statement(tx, &stmt->engine_savepoint); + return vy_tx_begin_statement(tx, pk != NULL ? vy_lsm(pk) : NULL, + &stmt->engine_savepoint); } static void diff --git a/src/box/vy_tx.c b/src/box/vy_tx.c index 1b8224f4..889e094e 100644 --- a/src/box/vy_tx.c +++ b/src/box/vy_tx.c @@ -322,6 +322,7 @@ vy_tx_read_set_free_cb(vy_tx_read_set_t *read_set, void vy_tx_create(struct tx_manager *xm, struct vy_tx *tx) { + tx->last_lsm = NULL; stailq_create(&tx->log); write_set_new(&tx->write_set); tx->write_set_version = 0; @@ -869,13 +870,14 @@ vy_tx_rollback(struct vy_tx *tx) } int -vy_tx_begin_statement(struct vy_tx *tx, void **savepoint) +vy_tx_begin_statement(struct vy_tx *tx, struct vy_lsm *lsm, void **savepoint) { if (tx->state == VINYL_TX_ABORT) { diag_set(ClientError, ER_TRANSACTION_CONFLICT); return -1; } assert(tx->state == VINYL_TX_READY); + tx->last_lsm = lsm; if (stailq_empty(&tx->log)) rlist_add_entry(&tx->xm->writers, tx, in_writers); *savepoint = stailq_last(&tx->log); @@ -1112,7 +1114,9 @@ tx_manager_abort_writers_for_ddl(struct tx_manager *xm, struct vy_lsm *lsm) { struct vy_tx *tx; rlist_foreach_entry(tx, &xm->writers, in_writers) { - if (tx->state == VINYL_TX_READY && + if (tx->state != VINYL_TX_READY) + continue; + if (tx->last_lsm == lsm || write_set_search_key(&tx->write_set, lsm, lsm->env->empty_key) != NULL) vy_tx_abort(tx); diff --git a/src/box/vy_tx.h b/src/box/vy_tx.h index aaa31bee..1767b509 100644 --- a/src/box/vy_tx.h +++ b/src/box/vy_tx.h @@ -140,6 +140,16 @@ struct vy_tx { /** Transaction manager. */ struct tx_manager *xm; /** + * Pointer to the primary index LSM tree of the space + * affected by the last prepared statement. + * + * We need it so that we can abort a transaction on DDL + * even if it hasn't inserted anything into the write set + * yet (e.g. yielded on unique check) and therefore would + * otherwise be ignored by tx_manager_abort_writers_for_ddl. + */ + struct vy_lsm *last_lsm; + /** * In memory transaction log. Contains both reads * and writes. */ @@ -325,9 +335,12 @@ vy_tx_rollback(struct vy_tx *tx); * Return the save point corresponding to the current * transaction state. The transaction can be rolled back * to a save point with vy_tx_rollback_statement(). + * + * @lsm is supposed to point to the LSM tree corresponding + * to the primary index of the affected space. */ int -vy_tx_begin_statement(struct vy_tx *tx, void **savepoint); +vy_tx_begin_statement(struct vy_tx *tx, struct vy_lsm *lsm, void **savepoint); /** * Rollback a transaction statement. -- 2.11.0