From 03d30b3e2925e35a97928e32c9a86deadb863a30 Mon Sep 17 00:00:00 2001 From: Mohamad Chaarawi Date: Fri, 19 Apr 2024 17:15:28 +0000 Subject: [PATCH] Revert "DAOS-11406 rdb: Use VOS local TXs (#12330)" This reverts commit b9b4f29e59ddc01258ceb97b37d63193704ac603. Test-tag: test_daos_vol_mpich test_ior_small test_mdtest_small test_osa_online_drain_oclass test_create_pool_quantity test_aggregation_punching test_smallfilecount Skip-func-hw-test-medium-md-on-ssd: false Skip-func-hw-test-medium: true Quick-Functional: true Required-githooks: true Signed-off-by: Mohamad Chaarawi Priority: 2 --- src/rdb/rdb.c | 12 +- src/rdb/rdb_internal.h | 46 ++++---- src/rdb/rdb_raft.c | 177 +++++++++++----------------- src/rdb/rdb_tx.c | 253 ++++++++++++++++------------------------- src/rdb/rdb_util.c | 58 ++-------- 5 files changed, 207 insertions(+), 339 deletions(-) diff --git a/src/rdb/rdb.c b/src/rdb/rdb.c index e3a55dc031c..8e88d10dfa8 100644 --- a/src/rdb/rdb.c +++ b/src/rdb/rdb.c @@ -20,6 +20,10 @@ static int rdb_open_internal(daos_handle_t pool, daos_handle_t mc, const uuid_t uuid, uint64_t caller_term, struct rdb_cbs *cbs, void *arg, struct rdb **dbp); +static int +rdb_chkptd_start(struct rdb *db); +static void +rdb_chkptd_stop(struct rdb *db); /** * Create an RDB replica at \a path with \a uuid, \a size, and \a replicas, and @@ -71,7 +75,8 @@ rdb_create(const char *path, const uuid_t uuid, uint64_t caller_term, size_t siz /* Initialize the layout version. */ d_iov_set(&value, &version, sizeof(version)); - rc = rdb_mc_update(mc, RDB_MC_ATTRS, 1 /* n */, &rdb_mc_version, &value, NULL /* vtx */); + rc = rdb_mc_update(mc, RDB_MC_ATTRS, 1 /* n */, &rdb_mc_version, + &value); if (rc != 0) goto out_mc_hdl; @@ -85,7 +90,7 @@ rdb_create(const char *path, const uuid_t uuid, uint64_t caller_term, size_t siz * rdb_start() checks this attribute when starting a DB. */ d_iov_set(&value, (void *)uuid, sizeof(uuid_t)); - rc = rdb_mc_update(mc, RDB_MC_ATTRS, 1 /* n */, &rdb_mc_uuid, &value, NULL /* vtx */); + rc = rdb_mc_update(mc, RDB_MC_ATTRS, 1 /* n */, &rdb_mc_uuid, &value); if (rc != 0) goto out_mc_hdl; @@ -224,9 +229,6 @@ rdb_lookup(const uuid_t uuid) return rdb_obj(entry); } -static int rdb_chkptd_start(struct rdb *db); -static void rdb_chkptd_stop(struct rdb *db); - /* * If created successfully, the new DB handle will consume pool and mc, which * the caller shall not close in this case. diff --git a/src/rdb/rdb_internal.h b/src/rdb/rdb_internal.h index 9195314e5c7..f7e53daf615 100644 --- a/src/rdb/rdb_internal.h +++ b/src/rdb/rdb_internal.h @@ -298,6 +298,11 @@ int rdb_send_raft_rpc(crt_rpc_t *rpc, struct rdb *db); int rdb_abort_raft_rpcs(struct rdb *db); void rdb_recvd(void *arg); +/* rdb_tx.c *******************************************************************/ + +int rdb_tx_apply(struct rdb *db, uint64_t index, const void *buf, size_t len, + void *result, bool *critp); + /* rdb_kvs.c ******************************************************************/ /* KVS cache entry */ @@ -347,11 +352,6 @@ void rdb_anchor_from_hashes(struct rdb_anchor *anchor, daos_anchor_t *akey_anchor, daos_anchor_t *ev_anchor, daos_anchor_t *sv_anchor); -struct dtx_handle; -typedef struct dtx_handle *rdb_vos_tx_t; - -int rdb_vos_tx_begin(struct rdb *db, int nvops, rdb_vos_tx_t *vtx); -int rdb_vos_tx_end(struct rdb *db, rdb_vos_tx_t vtx, int err); int rdb_vos_fetch(daos_handle_t cont, daos_epoch_t epoch, rdb_oid_t oid, daos_key_t *akey, d_iov_t *value); int rdb_vos_fetch_addr(daos_handle_t cont, daos_epoch_t epoch, rdb_oid_t oid, @@ -362,10 +362,10 @@ int rdb_vos_iter_fetch(daos_handle_t cont, daos_epoch_t epoch, rdb_oid_t oid, daos_key_t *akey_out, d_iov_t *value); int rdb_vos_iterate(daos_handle_t cont, daos_epoch_t epoch, rdb_oid_t oid, bool backward, rdb_iterate_cb_t cb, void *arg); -int rdb_vos_update(daos_handle_t cont, daos_epoch_t epoch, rdb_oid_t oid, bool crit, int n, - d_iov_t akeys[], d_iov_t values[], rdb_vos_tx_t vtx); -int rdb_vos_punch(daos_handle_t cont, daos_epoch_t epoch, rdb_oid_t oid, int n, d_iov_t akeys[], - rdb_vos_tx_t vtx); +int rdb_vos_update(daos_handle_t cont, daos_epoch_t epoch, rdb_oid_t oid, + bool crit, int n, d_iov_t akeys[], d_iov_t values[]); +int rdb_vos_punch(daos_handle_t cont, daos_epoch_t epoch, rdb_oid_t oid, int n, + d_iov_t akeys[]); int rdb_vos_discard(daos_handle_t cont, daos_epoch_t low, daos_epoch_t high); int rdb_vos_aggregate(daos_handle_t cont, daos_epoch_t high); @@ -378,13 +378,14 @@ int rdb_vos_aggregate(daos_handle_t cont, daos_epoch_t high); /* Update n (<= RDB_VOS_BATCH_MAX) a-keys atomically. */ static inline int -rdb_mc_update(daos_handle_t mc, rdb_oid_t oid, int n, d_iov_t akeys[], d_iov_t values[], - rdb_vos_tx_t vtx) +rdb_mc_update(daos_handle_t mc, rdb_oid_t oid, int n, d_iov_t akeys[], + d_iov_t values[]) { D_DEBUG(DB_TRACE, "mc="DF_X64" oid="DF_X64" n=%d akeys[0]=<%p, %zd> " "values[0]=<%p, %zd>\n", mc.cookie, oid, n, akeys[0].iov_buf, akeys[0].iov_len, values[0].iov_buf, values[0].iov_len); - return rdb_vos_update(mc, RDB_MC_EPOCH, oid, true /* crit */, n, akeys, values, vtx); + return rdb_vos_update(mc, RDB_MC_EPOCH, oid, true /* crit */, n, + akeys, values); } static inline int @@ -399,19 +400,19 @@ rdb_mc_lookup(daos_handle_t mc, rdb_oid_t oid, d_iov_t *akey, } static inline int -rdb_lc_update(daos_handle_t lc, uint64_t index, rdb_oid_t oid, bool crit, int n, d_iov_t akeys[], - d_iov_t values[], rdb_vos_tx_t vtx) +rdb_lc_update(daos_handle_t lc, uint64_t index, rdb_oid_t oid, bool crit, + int n, d_iov_t akeys[], d_iov_t values[]) { D_DEBUG(DB_TRACE, "lc="DF_X64" index="DF_U64" oid="DF_X64 " n=%d akeys[0]=<%p, %zd> values[0]=<%p, %zd>\n", lc.cookie, index, oid, n, akeys[0].iov_buf, akeys[0].iov_len, values[0].iov_buf, values[0].iov_len); - return rdb_vos_update(lc, index, oid, crit, n, akeys, values, vtx); + return rdb_vos_update(lc, index, oid, crit, n, akeys, values); } static inline int -rdb_lc_punch(daos_handle_t lc, uint64_t index, rdb_oid_t oid, int n, d_iov_t akeys[], - rdb_vos_tx_t vtx) +rdb_lc_punch(daos_handle_t lc, uint64_t index, rdb_oid_t oid, int n, + d_iov_t akeys[]) { if (n > 0) D_DEBUG(DB_TRACE, "lc="DF_X64" index="DF_U64" oid="DF_X64 @@ -420,7 +421,7 @@ rdb_lc_punch(daos_handle_t lc, uint64_t index, rdb_oid_t oid, int n, d_iov_t ake else D_DEBUG(DB_TRACE, "lc="DF_X64" index="DF_U64" oid="DF_X64 " n=%d\n", lc.cookie, index, oid, n); - return rdb_vos_punch(lc, index, oid, n, akeys, vtx); + return rdb_vos_punch(lc, index, oid, n, akeys); } /* Discard index range [low, high]. */ @@ -488,12 +489,7 @@ rdb_lc_iterate(daos_handle_t lc, uint64_t index, rdb_oid_t oid, bool backward, return rdb_vos_iterate(lc, index, oid, backward, cb, arg); } -int rdb_scm_left(struct rdb *db, daos_size_t *scm_left_outp); - -/* rdb_tx.c *******************************************************************/ - -int rdb_tx_count_vops(struct rdb *db, const void *buf, size_t len); -int rdb_tx_apply(struct rdb *db, uint64_t index, const void *buf, size_t len, void *result, - bool *critp, rdb_vos_tx_t vtx); +int +rdb_scm_left(struct rdb *db, daos_size_t *scm_left_outp); #endif /* RDB_INTERNAL_H */ diff --git a/src/rdb/rdb_raft.c b/src/rdb/rdb_raft.c index 8056c54da48..44450fdcf8e 100644 --- a/src/rdb/rdb_raft.c +++ b/src/rdb/rdb_raft.c @@ -227,8 +227,7 @@ rdb_raft_cb_send_appendentries(raft_server_t *raft, void *arg, } static int -rdb_raft_store_replicas(daos_handle_t lc, uint64_t index, const d_rank_list_t *replicas, - rdb_vos_tx_t vtx) +rdb_raft_store_replicas(daos_handle_t lc, uint64_t index, const d_rank_list_t *replicas) { d_iov_t keys[2]; d_iov_t vals[2]; @@ -240,8 +239,10 @@ rdb_raft_store_replicas(daos_handle_t lc, uint64_t index, const d_rank_list_t *r keys[0] = rdb_lc_nreplicas; d_iov_set(&vals[0], &nreplicas, sizeof(nreplicas)); keys[1] = rdb_lc_replicas; - d_iov_set(&vals[1], replicas->rl_ranks, sizeof(*replicas->rl_ranks) * nreplicas); - return rdb_lc_update(lc, index, RDB_LC_ATTRS, true /* crit */, 2 /* n */, keys, vals, vtx); + d_iov_set(&vals[1], replicas->rl_ranks, + sizeof(*replicas->rl_ranks) * nreplicas); + return rdb_lc_update(lc, index, RDB_LC_ATTRS, true /* crit */, + 2 /* n */, keys, vals); } int @@ -881,7 +882,8 @@ rdb_raft_cb_recv_installsnapshot(raft_server_t *raft, void *arg, d_iov_set(&values[0], slc_record, sizeof(*slc_record)); keys[1] = rdb_mc_slc; d_iov_set(&values[1], lc_record, sizeof(*lc_record)); - rc = rdb_mc_update(db->d_mc, RDB_MC_ATTRS, 2 /* n */, keys, values, NULL /* vtx */); + rc = rdb_mc_update(db->d_mc, RDB_MC_ATTRS, 2 /* n */, keys, + values); if (rc != 0) { D_ERROR(DF_DB": failed to swap LC records: %d\n", DP_DB(db), rc); @@ -923,8 +925,8 @@ rdb_raft_cb_recv_installsnapshot(raft_server_t *raft, void *arg, DP_DB(db), slc_record->dlr_base, slc_record->dlr_seq); d_iov_set(&values[0], slc_record, sizeof(*slc_record)); - rc = rdb_mc_update(db->d_mc, RDB_MC_ATTRS, 1 /* n */, &rdb_mc_slc, &values[0], - NULL /* vtx */); + rc = rdb_mc_update(db->d_mc, RDB_MC_ATTRS, 1 /* n */, + &rdb_mc_slc, &values[0]); if (rc != 0) { D_ERROR(DF_DB": failed to update SLC record: %d\n", DP_DB(db), rc); @@ -1021,7 +1023,8 @@ rdb_raft_cb_persist_vote(raft_server_t *raft, void *arg, raft_node_id_t vote) return 0; d_iov_set(&value, &vote, sizeof(vote)); - rc = rdb_mc_update(db->d_mc, RDB_MC_ATTRS, 1 /* n */, &rdb_mc_vote, &value, NULL /* vtx */); + rc = rdb_mc_update(db->d_mc, RDB_MC_ATTRS, 1 /* n */, &rdb_mc_vote, + &value); if (rc != 0) D_ERROR(DF_DB": failed to persist vote %d: %d\n", DP_DB(db), vote, rc); @@ -1046,7 +1049,7 @@ rdb_raft_cb_persist_term(raft_server_t *raft, void *arg, raft_term_t term, d_iov_set(&values[0], &term, sizeof(term)); keys[1] = rdb_mc_vote; d_iov_set(&values[1], &vote, sizeof(vote)); - rc = rdb_mc_update(db->d_mc, RDB_MC_ATTRS, 2 /* n */, keys, values, NULL /* vtx */); + rc = rdb_mc_update(db->d_mc, RDB_MC_ATTRS, 2 /* n */, keys, values); if (rc != 0) D_ERROR(DF_DB ": failed to update term %ld and vote %d: " DF_RC "\n", DP_DB(db), term, vote, DP_RC(rc)); @@ -1062,12 +1065,8 @@ rdb_raft_cfg_entry_rank(raft_entry_t *entry) return *((d_rank_t *)entry->data.buf); } -/* See rdb_raft_update_node. */ -#define RDB_RAFT_UPDATE_NODE_NVOPS 1 - -/* Must invoke no more than RDB_RAFT_UPDATE_NODE_NVOPS VOS TX operations. */ static int -rdb_raft_update_node(struct rdb *db, uint64_t index, raft_entry_t *entry, rdb_vos_tx_t vtx) +rdb_raft_update_node(struct rdb *db, uint64_t index, raft_entry_t *entry) { d_rank_list_t *replicas; d_rank_t rank = rdb_raft_cfg_entry_rank(entry); @@ -1102,7 +1101,11 @@ rdb_raft_update_node(struct rdb *db, uint64_t index, raft_entry_t *entry, rdb_vo if (rc != 0) goto out_replicas; - rc = rdb_raft_store_replicas(db->d_lc, index, replicas, vtx); + /* + * Since this is one VOS operation, we don't need to call + * rdb_lc_discard upon an error. + */ + rc = rdb_raft_store_replicas(db->d_lc, index, replicas); out_replicas: d_rank_list_free(replicas); @@ -1116,16 +1119,8 @@ rdb_raft_update_node(struct rdb *db, uint64_t index, raft_entry_t *entry, rdb_vo return rc; } -/* See rdb_raft_log_offer_single. */ -#define RDB_RAFT_ENTRY_NVOPS 2 - -/* - * Must invoke no more than RDB_RAFT_ENTRY_NVOPS VOS TX operations directly - * (i.e., not including those invoked by rdb_tx_apply and - * rdb_raft_update_node). - */ static int -rdb_raft_log_offer_single(struct rdb *db, raft_entry_t *entry, uint64_t index, rdb_vos_tx_t vtx) +rdb_raft_log_offer_single(struct rdb *db, raft_entry_t *entry, uint64_t index) { d_iov_t keys[2]; d_iov_t values[2]; @@ -1133,6 +1128,7 @@ rdb_raft_log_offer_single(struct rdb *db, raft_entry_t *entry, uint64_t index, r int n = 0; bool crit; int rc; + int rc_tmp; D_ASSERTF(index == db->d_lc_record.dlr_tail, DF_U64" == "DF_U64"\n", index, db->d_lc_record.dlr_tail); @@ -1146,21 +1142,24 @@ rdb_raft_log_offer_single(struct rdb *db, raft_entry_t *entry, uint64_t index, r */ if (entry->type == RAFT_LOGTYPE_NORMAL) { rc = rdb_tx_apply(db, index, entry->data.buf, entry->data.len, - rdb_raft_lookup_result(db, index), &crit, vtx); + rdb_raft_lookup_result(db, index), &crit); if (rc != 0) { - DL_ERROR(rc, DF_DB ": failed to apply entry " DF_U64, DP_DB(db), index); - return rc; + D_ERROR(DF_DB ": failed to apply entry " DF_U64 ": " DF_RC "\n", DP_DB(db), + index, DP_RC(rc)); + goto err; } } else if (raft_entry_is_cfg_change(entry)) { crit = true; - rc = rdb_raft_update_node(db, index, entry, vtx); + rc = rdb_raft_update_node(db, index, entry); if (rc != 0) { - DL_ERROR(rc, DF_DB ": failed to update replicas " DF_U64, DP_DB(db), index); - return rc; + D_ERROR(DF_DB": failed to update replicas "DF_U64": %d\n", + DP_DB(db), index, rc); + goto err; } } else { D_ERROR(DF_DB": unknown entry "DF_U64" type: %d\n", DP_DB(db), index, entry->type); - return -DER_IO; + rc = -DER_IO; + goto err; } /* @@ -1178,20 +1177,23 @@ rdb_raft_log_offer_single(struct rdb *db, raft_entry_t *entry, uint64_t index, r d_iov_set(&values[n], entry->data.buf, entry->data.len); n++; } - rc = rdb_lc_update(db->d_lc, index, RDB_LC_ATTRS, crit, n, keys, values, vtx); + rc = rdb_lc_update(db->d_lc, index, RDB_LC_ATTRS, crit, n, + keys, values); if (rc != 0) { - DL_ERROR(rc, DF_DB ": failed to persist entry " DF_U64, DP_DB(db), index); - return rc; + D_ERROR(DF_DB ": failed to persist entry " DF_U64 ": " DF_RC "\n", DP_DB(db), index, + DP_RC(rc)); + goto err_discard; } /* Replace entry->data.buf with the data's persistent memory address. */ if (entry->data.len > 0) { d_iov_set(&values[0], NULL, entry->data.len); - rc = rdb_lc_lookup(db->d_lc, index, RDB_LC_ATTRS, &rdb_lc_entry_data, &values[0]); + rc = rdb_lc_lookup(db->d_lc, index, RDB_LC_ATTRS, + &rdb_lc_entry_data, &values[0]); if (rc != 0) { - DL_ERROR(rc, DF_DB ": failed to look up entry " DF_U64 " data", DP_DB(db), - index); - return rc; + D_ERROR(DF_DB": failed to look up entry "DF_U64 + " data: %d\n", DP_DB(db), index, rc); + goto err_discard; } entry->data.buf = values[0].iov_buf; } else { @@ -1201,44 +1203,27 @@ rdb_raft_log_offer_single(struct rdb *db, raft_entry_t *entry, uint64_t index, r /* Update the log tail. See the log tail assertion above. */ db->d_lc_record.dlr_tail++; d_iov_set(&values[0], &db->d_lc_record, sizeof(db->d_lc_record)); - rc = rdb_mc_update(db->d_mc, RDB_MC_ATTRS, 1 /* n */, &rdb_mc_lc, &values[0], vtx); + rc = rdb_mc_update(db->d_mc, RDB_MC_ATTRS, 1 /* n */, &rdb_mc_lc, + &values[0]); if (rc != 0) { - DL_ERROR(rc, DF_DB ": failed to update log tail " DF_U64, DP_DB(db), - db->d_lc_record.dlr_tail); + D_ERROR(DF_DB ": failed to update log tail " DF_U64 ": " DF_RC "\n", DP_DB(db), + db->d_lc_record.dlr_tail, DP_RC(rc)); db->d_lc_record.dlr_tail--; - return rc; + goto err_discard; } D_DEBUG(DB_TRACE, DF_DB": appended entry "DF_U64": term=%ld type=%s buf=%p len=%u\n", DP_DB(db), index, entry->term, rdb_raft_entry_type_str(entry->type), entry->data.buf, entry->data.len); return 0; -} -static int -rdb_raft_entry_count_vops(struct rdb *db, raft_entry_t *entry) -{ - int count = 0; - - /* Count those that will be invoked when applying the entry. */ - if (entry->type == RAFT_LOGTYPE_NORMAL) { - int rc; - - rc = rdb_tx_count_vops(db, entry->data.buf, entry->data.len); - if (rc < 0) - return rc; - count += rc; - } else if (raft_entry_is_cfg_change(entry)) { - count += RDB_RAFT_UPDATE_NODE_NVOPS; - } else { - D_ERROR(DF_DB ": unknown entry type %d\n", DP_DB(db), entry->type); - return -DER_IO; - } - - /* Count those that will be invoked when storing the entry. */ - count += RDB_RAFT_ENTRY_NVOPS; - - return count; +err_discard: + rc_tmp = rdb_lc_discard(db->d_lc, index, index); + if (rc_tmp != 0) + D_ERROR(DF_DB ": failed to discard entry " DF_U64 ": " DF_RC "\n", DP_DB(db), index, + DP_RC(rc_tmp)); +err: + return rc; } static int @@ -1252,36 +1237,10 @@ rdb_raft_cb_log_offer(raft_server_t *raft, void *arg, raft_entry_t *entries, if (!db->d_raft_loaded) return 0; - /* - * Conservatively employ one VOS TX for each entry for now, so that if - * an entry encounters an error, we still end up making some progress - * by not rolling back prior entries in the batch. Once VOS supports - * batching TXs, we can optimize this process further. - */ - for (i = 0; i < *n_entries; i++) { - rdb_vos_tx_t vtx; - - rc = rdb_raft_entry_count_vops(db, &entries[i]); - if (rc < 0) { - DL_ERROR(rc, DF_DB ": failed to count VOS operations", DP_DB(db)); - break; - } - - rc = rdb_vos_tx_begin(db, rc, &vtx); - if (rc != 0) { - DL_ERROR(rc, DF_DB ": failed to begin VOS TX for entry %ld", DP_DB(db), - index); - break; - } - - rc = rdb_raft_log_offer_single(db, &entries[i], index + i, vtx); - - rc = rdb_vos_tx_end(db, vtx, rc); - if (rc != 0) { - DL_ERROR(rc, DF_DB ": failed to end VOS TX for entry %ld", DP_DB(db), - index); + for (i = 0; i < *n_entries; ++i) { + rc = rdb_raft_log_offer_single(db, &entries[i], index + i); + if (rc != 0) break; - } } *n_entries = i; @@ -1309,7 +1268,8 @@ rdb_raft_cb_log_poll(raft_server_t *raft, void *arg, raft_entry_t *entries, db->d_lc_record.dlr_base = index + *n_entries - 1; db->d_lc_record.dlr_base_term = entries[*n_entries - 1].term; d_iov_set(&value, &db->d_lc_record, sizeof(db->d_lc_record)); - rc = rdb_mc_update(db->d_mc, RDB_MC_ATTRS, 1 /* n */, &rdb_mc_lc, &value, NULL /* vtx */); + rc = rdb_mc_update(db->d_mc, RDB_MC_ATTRS, 1 /* n */, &rdb_mc_lc, + &value); if (rc != 0) { D_ERROR(DF_DB": failed to update log base from "DF_U64" to " DF_U64": %d\n", DP_DB(db), base, @@ -1345,7 +1305,8 @@ rdb_raft_cb_log_pop(raft_server_t *raft, void *arg, raft_entry_t *entry, /* Update the log tail. */ db->d_lc_record.dlr_tail = i; d_iov_set(&value, &db->d_lc_record, sizeof(db->d_lc_record)); - rc = rdb_mc_update(db->d_mc, RDB_MC_ATTRS, 1 /* n */, &rdb_mc_lc, &value, NULL /* vtx */); + rc = rdb_mc_update(db->d_mc, RDB_MC_ATTRS, 1 /* n */, &rdb_mc_lc, + &value); if (rc != 0) { D_ERROR(DF_DB": failed to update log tail "DF_U64": %d\n", DP_DB(db), db->d_lc_record.dlr_tail, rc); @@ -1599,7 +1560,8 @@ rdb_raft_compact(struct rdb *db, uint64_t index) aggregated = db->d_lc_record.dlr_aggregated; db->d_lc_record.dlr_aggregated = index; d_iov_set(&value, &db->d_lc_record, sizeof(db->d_lc_record)); - rc = rdb_mc_update(db->d_mc, RDB_MC_ATTRS, 1 /* n */, &rdb_mc_lc, &value, NULL /* vtx */); + rc = rdb_mc_update(db->d_mc, RDB_MC_ATTRS, 1 /* n */, &rdb_mc_lc, + &value); if (rc != 0) { D_ERROR(DF_DB": failed to update last aggregated index to " DF_U64": %d\n", DP_DB(db), @@ -2199,7 +2161,7 @@ rdb_raft_create_lc(daos_handle_t pool, daos_handle_t mc, d_iov_t *key, .dlr_aggregated = base, .dlr_term = term }; - d_iov_t value; + d_iov_t value; int rc; D_ASSERTF(key == &rdb_mc_lc || key == &rdb_mc_slc, "%p\n", key); @@ -2217,7 +2179,7 @@ rdb_raft_create_lc(daos_handle_t pool, daos_handle_t mc, d_iov_t *key, /* Create the record before creating the container. */ uuid_generate(r.dlr_uuid); d_iov_set(&value, &r, sizeof(r)); - rc = rdb_mc_update(mc, RDB_MC_ATTRS, 1 /* n */, key, &value, NULL /* vtx */); + rc = rdb_mc_update(mc, RDB_MC_ATTRS, 1 /* n */, key, &value); if (rc != 0) { D_ERROR("failed to create %s record: %d\n", key == &rdb_mc_lc ? "LC" : "SLC", rc); @@ -2259,7 +2221,7 @@ rdb_raft_destroy_lc(daos_handle_t pool, daos_handle_t mc, d_iov_t *key, /* Clear the record. We cannot rollback the destroy. */ uuid_clear(r.dlr_uuid); d_iov_set(&value, &r, sizeof(r)); - rc = rdb_mc_update(mc, RDB_MC_ATTRS, 1 /* n */, key, &value, NULL /* vtx */); + rc = rdb_mc_update(mc, RDB_MC_ATTRS, 1 /* n */, key, &value); if (rc != 0) { D_ERROR("failed to clear %s record: %d\n", key == &rdb_mc_lc ? "LC" : "SLC", rc); @@ -2299,7 +2261,7 @@ rdb_raft_init(daos_handle_t pool, daos_handle_t mc, const d_rank_list_t *replica D_ASSERTF(rc == 0, "Open VOS container: "DF_RC"\n", DP_RC(rc)); /* No initial configuration if rank list empty */ - rc = rdb_raft_store_replicas(lc, 1 /* base */, replicas, NULL /* vtx */); + rc = rdb_raft_store_replicas(lc, 1 /* base */, replicas); if (rc != 0) D_ERROR("failed to create list of replicas: "DF_RC"\n", DP_RC(rc)); @@ -2654,14 +2616,14 @@ rdb_raft_dictate(struct rdb *db) */ replicas.rl_ranks = &self; replicas.rl_nr = 1; - rc = rdb_raft_store_replicas(db->d_lc, index, &replicas, NULL /* vtx */); + rc = rdb_raft_store_replicas(db->d_lc, index, &replicas); if (rc != 0) { D_ERROR(DF_DB": failed to reset membership: "DF_RC"\n", DP_DB(db), DP_RC(rc)); return rc; } keys[0] = rdb_lc_entry_header; keys[1] = rdb_lc_entry_data; - rc = rdb_lc_punch(db->d_lc, index, RDB_LC_ATTRS, 2 /* n */, keys, NULL /* vtx */); + rc = rdb_lc_punch(db->d_lc, index, RDB_LC_ATTRS, 2 /* n */, keys); if (rc != 0) { D_ERROR(DF_DB": failed to punch entry: "DF_RC"\n", DP_DB(db), DP_RC(rc)); return rc; @@ -2676,7 +2638,7 @@ rdb_raft_dictate(struct rdb *db) lc_record.dlr_base_term = term; lc_record.dlr_tail = index + 1; d_iov_set(&value, &lc_record, sizeof(lc_record)); - rc = rdb_mc_update(db->d_mc, RDB_MC_ATTRS, 1 /* n */, &rdb_mc_lc, &value, NULL /* vtx */); + rc = rdb_mc_update(db->d_mc, RDB_MC_ATTRS, 1 /* n */, &rdb_mc_lc, &value); if (rc != 0) { D_ERROR(DF_DB": failed to update LC record: "DF_RC"\n", DP_DB(db), DP_RC(rc)); return rc; @@ -2768,8 +2730,7 @@ rdb_raft_open(struct rdb *db, uint64_t caller_term) D_DEBUG(DB_MD, DF_DB": updating term: "DF_X64" -> "DF_X64"\n", DP_DB(db), term, caller_term); d_iov_set(&value, &caller_term, sizeof(caller_term)); - rc = rdb_mc_update(db->d_mc, RDB_MC_ATTRS, 1 /* n */, &rdb_mc_term, &value, - NULL /* vtx */); + rc = rdb_mc_update(db->d_mc, RDB_MC_ATTRS, 1 /* n */, &rdb_mc_term, &value); if (rc != 0) goto err_compacted_cv; } diff --git a/src/rdb/rdb_tx.c b/src/rdb/rdb_tx.c index 3536181fda4..ed4adb0c0d6 100644 --- a/src/rdb/rdb_tx.c +++ b/src/rdb/rdb_tx.c @@ -211,17 +211,18 @@ rdb_tx_hdr_decode(const void *buf, size_t len, struct rdb_tx_hdr *hdr) static bool rdb_tx_is_critical(struct rdb_tx *tx) { - struct rdb_tx_hdr hdr = {.critical = 1}; + struct rdb_tx_hdr hdr; + bool crit = true; D_ASSERT(tx != NULL); - if (tx->dt_entry_len > 0) { - ssize_t nb; + if (tx->dt_entry) { + ssize_t nb; - D_ASSERT(tx->dt_entry != NULL); nb = rdb_tx_hdr_decode(tx->dt_entry, tx->dt_entry_len, &hdr); - D_ASSERTF(nb > 0, "nb=%zd\n", nb); + D_ASSERT(nb == sizeof(struct rdb_tx_hdr)); + crit = hdr.critical; } - return hdr.critical; + return crit; } /* If buf is NULL, then just calculate and return the length required. */ @@ -685,15 +686,11 @@ rdb_oid_class(enum rdb_kvs_class class, rdb_oid_t *oid_class) } } -/* See rdb_tx_apply_create. */ -#define RDB_TX_APPLY_CREATE_NVOPS 2 - -/* Must invoke no more than RDB_TX_APPLY_CREATE_NVOPS VOS TX operations. */ static int -rdb_tx_apply_create(struct rdb *db, uint64_t index, rdb_oid_t parent, d_iov_t *key, - enum rdb_kvs_class class, bool crit, rdb_vos_tx_t vtx) +rdb_tx_apply_create(struct rdb *db, uint64_t index, rdb_oid_t parent, + d_iov_t *key, enum rdb_kvs_class class, bool crit) { - d_iov_t value; + d_iov_t value; rdb_oid_t oid_class; rdb_oid_t oid_number; rdb_oid_t oid; @@ -702,7 +699,8 @@ rdb_tx_apply_create(struct rdb *db, uint64_t index, rdb_oid_t parent, d_iov_t *k /* Convert the KVS class into the object ID class. */ rc = rdb_oid_class(class, &oid_class); if (rc != 0) { - DL_ERROR(rc, DF_DB ": unknown KVS class %x", DP_DB(db), class); + D_ERROR(DF_DB": unknown KVS class %x: %d\n", DP_DB(db), class, + rc); return rc; } @@ -712,7 +710,8 @@ rdb_tx_apply_create(struct rdb *db, uint64_t index, rdb_oid_t parent, d_iov_t *k if (rc == 0) { return -DER_EXIST; } else if (rc != -DER_NONEXIST) { - DL_ERROR(rc, DF_DB ": failed to check KVS existence", DP_DB(db)); + D_ERROR(DF_DB": failed to check KVS existence: %d\n", DP_DB(db), + rc); return rc; } @@ -725,7 +724,8 @@ rdb_tx_apply_create(struct rdb *db, uint64_t index, rdb_oid_t parent, d_iov_t *k D_DEBUG(DB_MD, DF_DB": initialized rdb_lc_oid_next to "DF_U64 "\n", DP_DB(db), oid_number); } else if (rc != 0) { - DL_ERROR(rc, DF_DB ": failed to look up next object number", DP_DB(db)); + D_ERROR(DF_DB": failed to look up next object number: %d\n", + DP_DB(db), rc); return rc; } if ((oid_number & RDB_OID_CLASS_MASK) != 0) { @@ -737,34 +737,32 @@ rdb_tx_apply_create(struct rdb *db, uint64_t index, rdb_oid_t parent, d_iov_t *k oid_number += 1; /* Update the next object number. */ - rc = rdb_lc_update(db->d_lc, index, RDB_LC_ATTRS, crit, 1 /* n */, &rdb_lc_oid_next, &value, - vtx); + rc = rdb_lc_update(db->d_lc, index, RDB_LC_ATTRS, crit, 1 /* n */, + &rdb_lc_oid_next, &value); if (rc != 0) { - DL_ERROR(rc, DF_DB ": failed to update next object number " DF_X64, DP_DB(db), - oid_number); + D_ERROR(DF_DB": failed to update next object number"DF_X64 + ": %d\n", DP_DB(db), oid_number, rc); return rc; } /* Update the key in the parent object. */ d_iov_set(&value, &oid, sizeof(oid)); - rc = rdb_lc_update(db->d_lc, index, parent, crit, 1 /* n */, key, &value, vtx); + rc = rdb_lc_update(db->d_lc, index, parent, crit, 1 /* n */, + key, &value); if (rc != 0) { - DL_ERROR(rc, DF_DB ": failed to update parent KVS", DP_DB(db)); + D_ERROR(DF_DB": failed to update parent KVS: %d\n", DP_DB(db), + rc); return rc; } return 0; } -/* See rdb_tx_apply_destroy. */ -#define RDB_TX_APPLY_DESTROY_NVOPS 2 - -/* Must invoke no more than RDB_TX_APPLY_DESTROY_NVOPS VOS TX operations. */ static int -rdb_tx_apply_destroy(struct rdb *db, uint64_t index, rdb_oid_t parent, d_iov_t *key, - rdb_vos_tx_t vtx) +rdb_tx_apply_destroy(struct rdb *db, uint64_t index, rdb_oid_t parent, + d_iov_t *key) { - d_iov_t value; + d_iov_t value; rdb_oid_t oid; int rc; @@ -779,75 +777,51 @@ rdb_tx_apply_destroy(struct rdb *db, uint64_t index, rdb_oid_t parent, d_iov_t * } /* Punch the key in the parent object. */ - rc = rdb_lc_punch(db->d_lc, index, parent, 1 /* n */, key, vtx); + rc = rdb_lc_punch(db->d_lc, index, parent, 1 /* n */, key); if (rc != 0) { - DL_ERROR(rc, DF_DB ": failed to update parent KVS " DF_X64, DP_DB(db), parent); + D_ERROR(DF_DB": failed to update parent KVS "DF_X64": %d\n", + DP_DB(db), parent, rc); return rc; } /* Punch the KVS object. */ - rc = rdb_lc_punch(db->d_lc, index, oid, 0 /* n */, NULL /* akeys */, vtx); + rc = rdb_lc_punch(db->d_lc, index, oid, 0 /* n */, NULL /* akeys */); if (rc != 0) { - DL_ERROR(rc, DF_DB ": failed to punch KVS " DF_X64, DP_DB(db), oid); + D_ERROR(DF_DB": failed to punch KVS "DF_X64": %d\n", DP_DB(db), + oid, rc); return rc; } return 0; } -/* See rdb_tx_apply_update. */ -#define RDB_TX_APPLY_UPDATE_NVOPS 1 - -/* Must invoke no more than RDB_TX_APPLY_UPDATE_NVOPS VOS TX operations. */ static int -rdb_tx_apply_update(struct rdb *db, uint64_t index, rdb_oid_t kvs, d_iov_t *key, d_iov_t *value, - bool crit, rdb_vos_tx_t vtx) +rdb_tx_apply_update(struct rdb *db, uint64_t index, rdb_oid_t kvs, + d_iov_t *key, d_iov_t *value, bool crit) { int rc; - rc = rdb_lc_update(db->d_lc, index, kvs, crit, 1 /* n */, key, value, vtx); + rc = rdb_lc_update(db->d_lc, index, kvs, crit, 1 /* n */, key, value); if (rc != 0) - DL_ERROR(rc, DF_DB ": failed to update KVS " DF_X64, DP_DB(db), kvs); + D_ERROR(DF_DB ": failed to update KVS " DF_X64 ": " DF_RC "\n", DP_DB(db), kvs, + DP_RC(rc)); return rc; } -/* See rdb_tx_apply_delete. */ -#define RDB_TX_APPLY_DELETE_NVOPS 1 - -/* Must invoke no more than RDB_TX_APPLY_DELETE_NVOPS VOS TX operations. */ static int -rdb_tx_apply_delete(struct rdb *db, uint64_t index, rdb_oid_t kvs, d_iov_t *key, rdb_vos_tx_t vtx) +rdb_tx_apply_delete(struct rdb *db, uint64_t index, rdb_oid_t kvs, + d_iov_t *key) { int rc; - rc = rdb_lc_punch(db->d_lc, index, kvs, 1 /* n */, key, vtx); + rc = rdb_lc_punch(db->d_lc, index, kvs, 1 /* n */, key); if (rc != 0) DL_ERROR(rc, DF_DB ": failed to update KVS " DF_X64, DP_DB(db), kvs); return rc; } static int -rdb_tx_op_count_vops(struct rdb *db, struct rdb_tx_op *op) -{ - switch (op->dto_opc) { - case RDB_TX_CREATE_ROOT: - case RDB_TX_CREATE: - return RDB_TX_APPLY_CREATE_NVOPS; - case RDB_TX_DESTROY_ROOT: - case RDB_TX_DESTROY: - return RDB_TX_APPLY_DESTROY_NVOPS; - case RDB_TX_UPDATE: - return RDB_TX_APPLY_UPDATE_NVOPS; - case RDB_TX_DELETE: - return RDB_TX_APPLY_DELETE_NVOPS; - default: - D_ERROR(DF_DB ": unknown update operation %u\n", DP_DB(db), op->dto_opc); - return -DER_IO; - } -} - -static int -rdb_tx_apply_op(struct rdb *db, uint64_t index, struct rdb_tx_op *op, bool crit, rdb_vos_tx_t vtx) +rdb_tx_apply_op(struct rdb *db, uint64_t index, struct rdb_tx_op *op, bool crit) { struct rdb_kvs *kvs = NULL; rdb_path_t victim_path; @@ -884,24 +858,28 @@ rdb_tx_apply_op(struct rdb *db, uint64_t index, struct rdb_tx_op *op, bool crit, switch (op->dto_opc) { case RDB_TX_CREATE_ROOT: rc = rdb_tx_apply_create(db, index, RDB_LC_ATTRS, &rdb_lc_root, - op->dto_attr->dsa_class, crit, vtx); + op->dto_attr->dsa_class, crit); break; case RDB_TX_CREATE: - rc = rdb_tx_apply_create(db, index, kvs->de_object, &op->dto_key, - op->dto_attr->dsa_class, crit, vtx); + rc = rdb_tx_apply_create(db, index, kvs->de_object, + &op->dto_key, op->dto_attr->dsa_class, + crit); break; case RDB_TX_DESTROY_ROOT: - rc = rdb_tx_apply_destroy(db, index, RDB_LC_ATTRS, &rdb_lc_root, vtx); + rc = rdb_tx_apply_destroy(db, index, RDB_LC_ATTRS, + &rdb_lc_root); break; case RDB_TX_DESTROY: - rc = rdb_tx_apply_destroy(db, index, kvs->de_object, &op->dto_key, vtx); + rc = rdb_tx_apply_destroy(db, index, kvs->de_object, + &op->dto_key); break; case RDB_TX_UPDATE: - rc = rdb_tx_apply_update(db, index, kvs->de_object, &op->dto_key, &op->dto_value, - crit, vtx); + rc = rdb_tx_apply_update(db, index, kvs->de_object, + &op->dto_key, &op->dto_value, crit); break; case RDB_TX_DELETE: - rc = rdb_tx_apply_delete(db, index, kvs->de_object, &op->dto_key, vtx); + rc = rdb_tx_apply_delete(db, index, kvs->de_object, + &op->dto_key); break; default: D_ERROR(DF_DB": unknown update operation %u\n", @@ -924,7 +902,8 @@ rdb_tx_apply_op(struct rdb *db, uint64_t index, struct rdb_tx_op *op, bool crit, * call returns, no other TXs will look up victim_path in the * rdb_kvs cache. */ - rc_tmp = rdb_kvs_lookup(db, &victim_path, index, false /* alloc */, &victim); + rc_tmp = rdb_kvs_lookup(db, &victim_path, index, + false /* alloc */, &victim); if (rc_tmp == 0) { D_DEBUG(DB_TRACE, DF_DB": evicting kvs %p\n", DP_DB(db), victim); @@ -944,48 +923,6 @@ rdb_tx_apply_op(struct rdb *db, uint64_t index, struct rdb_tx_op *op, bool crit, return rc; } -int -rdb_tx_count_vops(struct rdb *db, const void *buf, size_t len) -{ - const void *p = buf; - ssize_t n; - struct rdb_tx_hdr hdr; - int count = 0; - - if (len == 0) - return 0; - - /* Skip the header. */ - n = rdb_tx_hdr_decode(p, len, &hdr); - if (n < 0) { - D_ERROR(DF_DB ": invalid header: buf=%p, len=" DF_U64 "\n", DP_DB(db), buf, len); - return n; - } - p += n; - - /* Count those that will be invoked by each RDB TX operation. */ - while (p < buf + len) { - struct rdb_tx_op op; - int rc; - - n = rdb_tx_op_decode(p, buf + len - p, &op); - if (n < 0) { - D_ERROR(DF_DB ": invalid entry format: buf=%p len=" DF_U64 " p=%p\n", - DP_DB(db), buf, len, p); - return n; - } - - rc = rdb_tx_op_count_vops(db, &op); - if (rc < 0) - return rc; - count += rc; - - p += n; - } - - return count; -} - /* Is "error" deterministic? */ static inline bool rdb_tx_deterministic_error(int error) @@ -1000,19 +937,15 @@ rdb_tx_deterministic_error(int error) * Interpret header to know if ops in the TX are deemed "critical". */ int -rdb_tx_apply(struct rdb *db, uint64_t index, const void *buf, size_t len, void *result, bool *critp, - rdb_vos_tx_t vtx) +rdb_tx_apply(struct rdb *db, uint64_t index, const void *buf, size_t len, + void *result, bool *critp) { const void *p = buf; ssize_t n; + bool crit = true; daos_size_t scm_remaining = 0; - struct rdb_tx_hdr hdr = {.critical = 1}; int rc = 0; - if (len == 0) - goto out; - D_ASSERT(buf != NULL); - rc = rdb_scm_left(db, &scm_remaining); if (rc != 0) { D_ERROR(DF_DB": could not query free space: "DF_RC"\n", @@ -1020,28 +953,33 @@ rdb_tx_apply(struct rdb *db, uint64_t index, const void *buf, size_t len, void * return rc; } - n = rdb_tx_hdr_decode(p, len, &hdr); - if (n < 0) { - D_ERROR(DF_DB ": invalid header: buf=%p, len=" DF_U64 "\n", DP_DB(db), buf, len); - rc = n; - return rc; - } - p += n; + if (buf) { + struct rdb_tx_hdr hdr; - /* - * scm_remaining < RDB_NOAPPEND_FREE_SPACE can happen on - * on follower after leader compacts log first. - * Warn only when critically low on space. - */ - if (!hdr.critical && (scm_remaining < RDB_CRITICAL_FREE_SPACE)) { - D_WARN(DF_DB ": space is tight! index " DF_U64 " buf=%p " - "len=" DF_U64 " crit=%d scm_left=" DF_U64 "\n", - DP_DB(db), index, buf, len, hdr.critical, scm_remaining); + n = rdb_tx_hdr_decode(p, sizeof(struct rdb_tx_hdr), &hdr); + if (n < 0) { + D_ERROR(DF_DB": invalid header: buf=%p, len="DF_U64"\n", + DP_DB(db), buf, sizeof(struct rdb_tx_hdr)); + rc = n; + return rc; + } + p += n; + crit = hdr.critical; + + /* scm_remaining < RDB_NOAPPEND_FREE_SPACE can happen on + * on follower after leader compacts log first. + * Warn only when critically low on space. + */ + if (!crit && (scm_remaining < RDB_CRITICAL_FREE_SPACE)) { + D_WARN(DF_DB": space is tight! index "DF_U64" buf=%p " + "len="DF_U64" crit=%d scm_left="DF_U64"\n", + DP_DB(db), index, buf, len, crit, scm_remaining); + } } D_DEBUG(DB_TRACE, DF_DB": applying index "DF_U64": buf=%p len="DF_U64 " crit=%d, scm_left="DF_U64"\n", DP_DB(db), index, buf, len, - hdr.critical, scm_remaining); + crit, scm_remaining); while (p < buf + len) { struct rdb_tx_op op; @@ -1053,7 +991,7 @@ rdb_tx_apply(struct rdb *db, uint64_t index, const void *buf, size_t len, void * rc = n; break; } - rc = rdb_tx_apply_op(db, index, &op, hdr.critical, vtx); + rc = rdb_tx_apply_op(db, index, &op, crit); if (rc != 0) { if (!rdb_tx_deterministic_error(rc)) D_ERROR(DF_DB ": failed to apply entry " DF_U64 @@ -1066,19 +1004,30 @@ rdb_tx_apply(struct rdb *db, uint64_t index, const void *buf, size_t len, void * /* * If an error occurs after we have potentially made some - * modifications, empty the rdb_kvs cache (to evict any rdb_kvs objects - * corresponding to KVSs created by this TX). Don't bother with undoing - * the exact set of rdb_kvs changes made by this TX, as - * nondeterministic errors must be rare and deterministic errors can be - * easily avoided by rdb callers. + * modifications, empty the rdb_kvs cache (to evict any rdb_kvs + * objects corresponding to KVSs created by this TX) and discard all + * updates in index. Don't bother with undoing the exact set of changes + * made by this TX, as nondeterministic errors must be rare and + * deterministic errors can be easily avoided by rdb callers. */ - if (rc != 0) + if (rc != 0) { + int rc_tmp; + rdb_kvs_cache_evict(db->d_kvss); + rc_tmp = rdb_lc_discard(db->d_lc, index, index); + if (rc_tmp != 0) { + D_ERROR(DF_DB ": failed to discard entry " DF_U64 ": " DF_RC "\n", + DP_DB(db), index, DP_RC(rc_tmp)); + if (rdb_tx_deterministic_error(rc)) + return rc_tmp; + else + return rc; + } + } if (rc != 0 && !rdb_tx_deterministic_error(rc)) return rc; -out: /* * Report the deterministic error to the result buffer, if there is * one, and consider this entry applied. @@ -1086,7 +1035,7 @@ rdb_tx_apply(struct rdb *db, uint64_t index, const void *buf, size_t len, void * if (result != NULL) *(int *)result = rc; - *critp = hdr.critical; + *critp = crit; return 0; } diff --git a/src/rdb/rdb_util.c b/src/rdb/rdb_util.c index 38e35e6f90f..f53ee56de5f 100644 --- a/src/rdb/rdb_util.c +++ b/src/rdb/rdb_util.c @@ -1,5 +1,5 @@ /** - * (C) Copyright 2018-2023 Intel Corporation. + * (C) Copyright 2018-2022 Intel Corporation. * * SPDX-License-Identifier: BSD-2-Clause-Patent */ @@ -14,7 +14,6 @@ #include #include #include -#include #include #include "rdb_internal.h" @@ -229,46 +228,6 @@ rdb_anchor_from_hashes(struct rdb_anchor *anchor, daos_anchor_t *obj_anchor, anchor->da_akey = *akey_anchor; } -/* - * The nvops parameter must be equal to or larger than the number of VOS - * operations that will be executed in vtx. - */ -int -rdb_vos_tx_begin(struct rdb *db, int nvops, rdb_vos_tx_t *vtx) -{ - struct dtx_handle *dth; - int rc; - - rc = dtx_begin(db->d_pool, NULL /* dti */, NULL /* epoch */, nvops, 0 /* pm_ver */, - NULL /* leader_oid */, NULL /* dti_cos */, 0 /* dti_cos_cnt */, DTX_LOCAL, - NULL /* mbs */, &dth); - if (rc != 0) { - DL_ERROR(rc, DF_DB ": failed to begin VOS TX", DP_DB(db)); - return rc; - } - - *vtx = dth; - return 0; -} - -/* Note that if there are two errors, we return the first one. */ -int -rdb_vos_tx_end(struct rdb *db, rdb_vos_tx_t vtx, int err) -{ - struct dtx_handle *dth = vtx; - int rc; - - rc = dtx_end(dth, NULL /* cont */, err); - if (rc != 0) - DL_ERROR(rc, DF_DB ": failed to %s VOS TX", DP_DB(db), - err == 0 ? "commit" : "abort"); - - if (err != 0) - rc = err; - - return rc; -} - enum rdb_vos_op { RDB_VOS_QUERY, RDB_VOS_UPDATE @@ -563,7 +522,7 @@ rdb_vos_iterate(daos_handle_t cont, daos_epoch_t epoch, rdb_oid_t oid, int rdb_vos_update(daos_handle_t cont, daos_epoch_t epoch, rdb_oid_t oid, bool crit, - int n, d_iov_t akeys[], d_iov_t values[], rdb_vos_tx_t vtx) + int n, d_iov_t akeys[], d_iov_t values[]) { daos_unit_oid_t uoid; daos_iod_t iods[n]; @@ -574,19 +533,20 @@ rdb_vos_update(daos_handle_t cont, daos_epoch_t epoch, rdb_oid_t oid, bool crit, rdb_oid_to_uoid(oid, &uoid); rdb_vos_set_iods(RDB_VOS_UPDATE, n, akeys, values, iods); rdb_vos_set_sgls(RDB_VOS_UPDATE, n, values, sgls); - return vos_obj_update_ex(cont, uoid, epoch, RDB_PM_VER, vos_flags, &rdb_dkey, n, iods, - NULL /* iods_csums */, sgls, vtx); + return vos_obj_update(cont, uoid, epoch, RDB_PM_VER, vos_flags, + &rdb_dkey, n, iods, NULL, sgls); } int -rdb_vos_punch(daos_handle_t cont, daos_epoch_t epoch, rdb_oid_t oid, int n, d_iov_t akeys[], - rdb_vos_tx_t vtx) +rdb_vos_punch(daos_handle_t cont, daos_epoch_t epoch, rdb_oid_t oid, int n, + d_iov_t akeys[]) { daos_unit_oid_t uoid; rdb_oid_to_uoid(oid, &uoid); - return vos_obj_punch(cont, uoid, epoch, RDB_PM_VER, 0, n == 0 ? NULL : &rdb_dkey, n, - n == 0 ? NULL : akeys, vtx); + return vos_obj_punch(cont, uoid, epoch, RDB_PM_VER, 0, + n == 0 ? NULL : &rdb_dkey, n, + n == 0 ? NULL : akeys, NULL); } int