X-Git-Url: https://git.ozlabs.org/?a=blobdiff_plain;f=ccan%2Ftdb2%2Ftdb1_lock.c;h=a33c851c1721e0c92b10b834b33756bed2c602bc;hb=0fd5be2955f8e6487c0f4ab711e2a6958bb8f412;hp=bed70ba2ec9031fd5721c115029e97a03c0afba0;hpb=19e6c1a250ade1e7204ada17163294855585e825;p=ccan diff --git a/ccan/tdb2/tdb1_lock.c b/ccan/tdb2/tdb1_lock.c index bed70ba2..a33c851c 100644 --- a/ccan/tdb2/tdb1_lock.c +++ b/ccan/tdb2/tdb1_lock.c @@ -27,11 +27,6 @@ #include "tdb1_private.h" -_PUBLIC_ void tdb1_setalarm_sigptr(struct tdb1_context *tdb, volatile sig_atomic_t *ptr) -{ - tdb->interrupt_sig_ptr = ptr; -} - static int fcntl_lock(struct tdb1_context *tdb, int rw, off_t off, off_t len, bool waitflag) { @@ -143,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; @@ -155,12 +146,6 @@ int tdb1_brlock(struct tdb1_context *tdb, do { ret = fcntl_lock(tdb, rw_type, offset, len, flags & TDB1_LOCK_WAIT); - /* Check for a sigalarm break. */ - if (ret == -1 && errno == EINTR && - tdb->interrupt_sig_ptr && - *tdb->interrupt_sig_ptr) { - break; - } } while (ret == -1 && errno == EINTR); if (ret == -1) { @@ -355,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; @@ -379,15 +364,7 @@ int tdb1_lock(struct tdb1_context *tdb, int list, int ltype) return ret; } -/* lock a list in the database. list -1 is the alloc list. non-blocking lock */ -int tdb1_lock_nonblock(struct tdb1_context *tdb, int list, int ltype) -{ - return tdb1_lock_list(tdb, list, ltype, TDB1_LOCK_NOWAIT); -} - - -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; @@ -419,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 @@ -458,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); } /* @@ -475,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. */ @@ -587,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; } @@ -607,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) { @@ -632,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; } @@ -644,100 +610,50 @@ int tdb1_allrecord_unlock(struct tdb1_context *tdb, int ltype, bool mark_lock) } /* lock entire database with write lock */ -_PUBLIC_ int tdb1_lockall(struct tdb1_context *tdb) +int tdb1_lockall(struct tdb1_context *tdb) { return tdb1_allrecord_lock(tdb, F_WRLCK, TDB1_LOCK_WAIT, false); } -/* lock entire database with write lock - mark only */ -_PUBLIC_ int tdb1_lockall_mark(struct tdb1_context *tdb) -{ - return tdb1_allrecord_lock(tdb, F_WRLCK, TDB1_LOCK_MARK_ONLY, false); -} - -/* unlock entire database with write lock - unmark only */ -_PUBLIC_ int tdb1_lockall_unmark(struct tdb1_context *tdb) -{ - return tdb1_allrecord_unlock(tdb, F_WRLCK, true); -} - -/* lock entire database with write lock - nonblocking varient */ -_PUBLIC_ int tdb1_lockall_nonblock(struct tdb1_context *tdb) -{ - int ret = tdb1_allrecord_lock(tdb, F_WRLCK, TDB1_LOCK_NOWAIT, false); - return ret; -} - /* unlock entire database with write lock */ -_PUBLIC_ int tdb1_unlockall(struct tdb1_context *tdb) +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 */ -_PUBLIC_ int tdb1_lockall_read(struct tdb1_context *tdb) +int tdb1_lockall_read(struct tdb1_context *tdb) { return tdb1_allrecord_lock(tdb, F_RDLCK, TDB1_LOCK_WAIT, false); } -/* lock entire database with read lock - nonblock varient */ -_PUBLIC_ int tdb1_lockall_read_nonblock(struct tdb1_context *tdb) -{ - int ret = tdb1_allrecord_lock(tdb, F_RDLCK, TDB1_LOCK_NOWAIT, false); - return ret; -} - /* unlock entire database with read lock */ -_PUBLIC_ int tdb1_unlockall_read(struct tdb1_context *tdb) +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 contention - it cannot guarantee how many records will be locked */ -_PUBLIC_ int tdb1_chainlock(struct tdb1_context *tdb, TDB1_DATA key) +int tdb1_chainlock(struct tdb1_context *tdb, TDB1_DATA key) { int ret = tdb1_lock(tdb, TDB1_BUCKET(tdb->hash_fn(&key)), F_WRLCK); return ret; } -/* lock/unlock one hash chain, non-blocking. This is meant to be used - to reduce contention - it cannot guarantee how many records will be - locked */ -_PUBLIC_ int tdb1_chainlock_nonblock(struct tdb1_context *tdb, TDB1_DATA key) -{ - int ret = tdb1_lock_nonblock(tdb, TDB1_BUCKET(tdb->hash_fn(&key)), F_WRLCK); - return ret; -} - -/* mark a chain as locked without actually locking it. Warning! use with great caution! */ -_PUBLIC_ int tdb1_chainlock_mark(struct tdb1_context *tdb, TDB1_DATA key) -{ - int ret = tdb1_nest_lock(tdb, lock_offset(TDB1_BUCKET(tdb->hash_fn(&key))), - F_WRLCK, TDB1_LOCK_MARK_ONLY); - return ret; -} - -/* unmark a chain as locked without actually locking it. Warning! use with great caution! */ -_PUBLIC_ int tdb1_chainlock_unmark(struct tdb1_context *tdb, TDB1_DATA key) -{ - return tdb1_nest_unlock(tdb, lock_offset(TDB1_BUCKET(tdb->hash_fn(&key))), - F_WRLCK, true); -} - -_PUBLIC_ int tdb1_chainunlock(struct tdb1_context *tdb, TDB1_DATA key) +int tdb1_chainunlock(struct tdb1_context *tdb, TDB1_DATA key) { return tdb1_unlock(tdb, TDB1_BUCKET(tdb->hash_fn(&key)), F_WRLCK); } -_PUBLIC_ int tdb1_chainlock_read(struct tdb1_context *tdb, TDB1_DATA key) +int tdb1_chainlock_read(struct tdb1_context *tdb, TDB1_DATA key) { int ret; ret = tdb1_lock(tdb, TDB1_BUCKET(tdb->hash_fn(&key)), F_RDLCK); return ret; } -_PUBLIC_ int tdb1_chainunlock_read(struct tdb1_context *tdb, TDB1_DATA key) +int tdb1_chainunlock_read(struct tdb1_context *tdb, TDB1_DATA key) { return tdb1_unlock(tdb, TDB1_BUCKET(tdb->hash_fn(&key)), F_RDLCK); }