From 3b2c10f8955096c5cb28e8ae157e0f08858c001e Mon Sep 17 00:00:00 2001 From: Rusty Russell Date: Wed, 14 Sep 2011 07:27:13 +0930 Subject: tdb2: get rid of TDB1 mark and nonblock functions. We do this using hooks in tdb2. Signed-off-by: Rusty Russell (Imported from CCAN commit 444fade529f68eb2b0aebbc8de442478c5c6f916) --- lib/tdb2/tdb1_lock.c | 36 ++++++++++-------------------------- lib/tdb2/tdb1_open.c | 4 ++-- lib/tdb2/tdb1_private.h | 7 ++----- lib/tdb2/tdb1_tdb.c | 2 +- lib/tdb2/tdb1_transaction.c | 12 ++++-------- 5 files changed, 19 insertions(+), 42 deletions(-) (limited to 'lib') diff --git a/lib/tdb2/tdb1_lock.c b/lib/tdb2/tdb1_lock.c index ee6aaf745e..a33c851c17 100644 --- a/lib/tdb2/tdb1_lock.c +++ b/lib/tdb2/tdb1_lock.c @@ -138,10 +138,6 @@ int tdb1_brlock(struct tdb1_context *tdb, return 0; } - if (flags & TDB1_LOCK_MARK_ONLY) { - return 0; - } - if ((rw_type == F_WRLCK) && (tdb->read_only || tdb->traverse_read)) { tdb->ecode = TDB1_ERR_RDONLY; return -1; @@ -344,7 +340,7 @@ static int tdb1_lock_list(struct tdb1_context *tdb, int list, int ltype, ret = tdb1_nest_lock(tdb, lock_offset(list), ltype, waitflag); if (ret == 0 && check && tdb1_needs_recovery(tdb)) { - tdb1_nest_unlock(tdb, lock_offset(list), ltype, false); + tdb1_nest_unlock(tdb, lock_offset(list), ltype); if (tdb1_lock_and_recover(tdb) == -1) { return -1; @@ -368,8 +364,7 @@ int tdb1_lock(struct tdb1_context *tdb, int list, int ltype) return ret; } -int tdb1_nest_unlock(struct tdb1_context *tdb, uint32_t offset, int ltype, - bool mark_lock) +int tdb1_nest_unlock(struct tdb1_context *tdb, uint32_t offset, int ltype) { int ret = -1; struct tdb1_lock_type *lck; @@ -401,11 +396,7 @@ int tdb1_nest_unlock(struct tdb1_context *tdb, uint32_t offset, int ltype, * anyway. */ - if (mark_lock) { - ret = 0; - } else { - ret = tdb1_brunlock(tdb, ltype, offset, 1); - } + ret = tdb1_brunlock(tdb, ltype, offset, 1); /* * Shrink the array by overwriting the element just unlocked with the @@ -440,7 +431,7 @@ int tdb1_unlock(struct tdb1_context *tdb, int list, int ltype) return -1; } - return tdb1_nest_unlock(tdb, lock_offset(list), ltype, false); + return tdb1_nest_unlock(tdb, lock_offset(list), ltype); } /* @@ -457,7 +448,7 @@ int tdb1_transaction_lock(struct tdb1_context *tdb, int ltype, */ int tdb1_transaction_unlock(struct tdb1_context *tdb, int ltype) { - return tdb1_nest_unlock(tdb, TDB1_TRANSACTION_LOCK, ltype, false); + return tdb1_nest_unlock(tdb, TDB1_TRANSACTION_LOCK, ltype); } /* Returns 0 if all done, -1 if error, 1 if ok. */ @@ -569,14 +560,7 @@ int tdb1_allrecord_lock(struct tdb1_context *tdb, int ltype, tdb->allrecord_lock.off = upgradable; if (tdb1_needs_recovery(tdb)) { - bool mark = flags & TDB1_LOCK_MARK_ONLY; - tdb1_allrecord_unlock(tdb, ltype, mark); - if (mark) { - tdb->ecode = TDB1_ERR_LOCK; - TDB1_LOG((tdb, TDB1_DEBUG_ERROR, - "tdb1_lockall_mark cannot do recovery\n")); - return -1; - } + tdb1_allrecord_unlock(tdb, ltype); if (tdb1_lock_and_recover(tdb) == -1) { return -1; } @@ -589,7 +573,7 @@ int tdb1_allrecord_lock(struct tdb1_context *tdb, int ltype, /* unlock entire db */ -int tdb1_allrecord_unlock(struct tdb1_context *tdb, int ltype, bool mark_lock) +int tdb1_allrecord_unlock(struct tdb1_context *tdb, int ltype) { /* There are no locks on read-only dbs */ if (tdb->read_only || tdb->traverse_read) { @@ -614,7 +598,7 @@ int tdb1_allrecord_unlock(struct tdb1_context *tdb, int ltype, bool mark_lock) return 0; } - if (!mark_lock && tdb1_brunlock(tdb, ltype, TDB1_FREELIST_TOP, 0)) { + if (tdb1_brunlock(tdb, ltype, TDB1_FREELIST_TOP, 0)) { TDB1_LOG((tdb, TDB1_DEBUG_ERROR, "tdb1_unlockall failed (%s)\n", strerror(errno))); return -1; } @@ -634,7 +618,7 @@ int tdb1_lockall(struct tdb1_context *tdb) /* unlock entire database with write lock */ int tdb1_unlockall(struct tdb1_context *tdb) { - return tdb1_allrecord_unlock(tdb, F_WRLCK, false); + return tdb1_allrecord_unlock(tdb, F_WRLCK); } /* lock entire database with read lock */ @@ -646,7 +630,7 @@ int tdb1_lockall_read(struct tdb1_context *tdb) /* unlock entire database with read lock */ int tdb1_unlockall_read(struct tdb1_context *tdb) { - return tdb1_allrecord_unlock(tdb, F_RDLCK, false); + return tdb1_allrecord_unlock(tdb, F_RDLCK); } /* lock/unlock one hash chain. This is meant to be used to reduce diff --git a/lib/tdb2/tdb1_open.c b/lib/tdb2/tdb1_open.c index 7c5100e3d1..65bc2dba14 100644 --- a/lib/tdb2/tdb1_open.c +++ b/lib/tdb2/tdb1_open.c @@ -387,7 +387,7 @@ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int tdb1_flag tdb->inode = st.st_ino; tdb1_mmap(tdb); if (locked) { - if (tdb1_nest_unlock(tdb, TDB1_ACTIVE_LOCK, F_WRLCK, false) == -1) { + if (tdb1_nest_unlock(tdb, TDB1_ACTIVE_LOCK, F_WRLCK) == -1) { TDB1_LOG((tdb, TDB1_DEBUG_ERROR, "tdb1_open_ex: " "failed to release ACTIVE_LOCK on %s: %s\n", name, strerror(errno))); @@ -416,7 +416,7 @@ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int tdb1_flag /* Internal (memory-only) databases skip all the code above to * do with disk files, and resume here by releasing their * open lock and hooking into the active list. */ - if (tdb1_nest_unlock(tdb, TDB1_OPEN_LOCK, F_WRLCK, false) == -1) { + if (tdb1_nest_unlock(tdb, TDB1_OPEN_LOCK, F_WRLCK) == -1) { goto fail; } tdb->next = tdb1s; diff --git a/lib/tdb2/tdb1_private.h b/lib/tdb2/tdb1_private.h index ae2888c0a7..809f135555 100644 --- a/lib/tdb2/tdb1_private.h +++ b/lib/tdb2/tdb1_private.h @@ -180,8 +180,6 @@ enum tdb1_lock_flags { TDB1_LOCK_WAIT = 1, /* If set, don't log an error on failure. */ TDB1_LOCK_PROBE = 2, - /* If set, don't actually lock at all. */ - TDB1_LOCK_MARK_ONLY = 4, }; struct tdb1_context; @@ -229,8 +227,7 @@ void tdb1_mmap(struct tdb1_context *tdb); int tdb1_lock(struct tdb1_context *tdb, int list, int ltype); int tdb1_nest_lock(struct tdb1_context *tdb, uint32_t offset, int ltype, enum tdb1_lock_flags flags); -int tdb1_nest_unlock(struct tdb1_context *tdb, uint32_t offset, int ltype, - bool mark_lock); +int tdb1_nest_unlock(struct tdb1_context *tdb, uint32_t offset, int ltype); int tdb1_unlock(struct tdb1_context *tdb, int list, int ltype); int tdb1_brlock(struct tdb1_context *tdb, int rw_type, tdb1_off_t offset, size_t len, @@ -248,7 +245,7 @@ int tdb1_recovery_area(struct tdb1_context *tdb, struct tdb1_record *rec); int tdb1_allrecord_lock(struct tdb1_context *tdb, int ltype, enum tdb1_lock_flags flags, bool upgradable); -int tdb1_allrecord_unlock(struct tdb1_context *tdb, int ltype, bool mark_lock); +int tdb1_allrecord_unlock(struct tdb1_context *tdb, int ltype); int tdb1_allrecord_upgrade(struct tdb1_context *tdb); int tdb1_write_lock_record(struct tdb1_context *tdb, tdb1_off_t off); int tdb1_write_unlock_record(struct tdb1_context *tdb, tdb1_off_t off); diff --git a/lib/tdb2/tdb1_tdb.c b/lib/tdb2/tdb1_tdb.c index cc7e580f2c..113ebc0b6d 100644 --- a/lib/tdb2/tdb1_tdb.c +++ b/lib/tdb2/tdb1_tdb.c @@ -66,7 +66,7 @@ static void tdb1_increment_seqnum(struct tdb1_context *tdb) tdb1_increment_seqnum_nonblock(tdb); - tdb1_nest_unlock(tdb, TDB1_SEQNUM_OFS, F_WRLCK, false); + tdb1_nest_unlock(tdb, TDB1_SEQNUM_OFS, F_WRLCK); } static int tdb1_key_compare(TDB1_DATA key, TDB1_DATA data, void *private_data) diff --git a/lib/tdb2/tdb1_transaction.c b/lib/tdb2/tdb1_transaction.c index 43e99024ce..b09a2b3c10 100644 --- a/lib/tdb2/tdb1_transaction.c +++ b/lib/tdb2/tdb1_transaction.c @@ -421,8 +421,7 @@ static const struct tdb1_methods transaction1_methods = { start a tdb transaction. No token is returned, as only a single transaction is allowed to be pending per tdb1_context */ -static int _tdb1_transaction_start(struct tdb1_context *tdb, - enum tdb1_lock_flags lockflags) +static int _tdb1_transaction_start(struct tdb1_context *tdb) { /* some sanity checks */ if (tdb->read_only || (tdb->flags & TDB1_INTERNAL) || tdb->traverse_read) { @@ -474,12 +473,9 @@ static int _tdb1_transaction_start(struct tdb1_context *tdb, /* get the transaction write lock. This is a blocking lock. As discussed with Volker, there are a number of ways we could make this async, which we will probably do in the future */ - if (tdb1_transaction_lock(tdb, F_WRLCK, lockflags) == -1) { + if (tdb1_transaction_lock(tdb, F_WRLCK, TDB1_LOCK_WAIT) == -1) { SAFE_FREE(tdb->transaction->blocks); SAFE_FREE(tdb->transaction); - if ((lockflags & TDB1_LOCK_WAIT) == 0) { - tdb->ecode = TDB1_ERR_NOLOCK; - } return -1; } @@ -518,7 +514,7 @@ static int _tdb1_transaction_start(struct tdb1_context *tdb, return 0; fail: - tdb1_allrecord_unlock(tdb, F_RDLCK, false); + tdb1_allrecord_unlock(tdb, F_RDLCK); fail_allrecord_lock: tdb1_transaction_unlock(tdb, F_WRLCK); SAFE_FREE(tdb->transaction->blocks); @@ -529,7 +525,7 @@ fail_allrecord_lock: int tdb1_transaction_start(struct tdb1_context *tdb) { - return _tdb1_transaction_start(tdb, TDB1_LOCK_WAIT); + return _tdb1_transaction_start(tdb); } /* -- cgit