X-Git-Url: https://git.ozlabs.org/?a=blobdiff_plain;f=ccan%2Ftdb2%2Ftdb1_lock.c;h=c427804893d465d5e3fbea7cd6a850dd2017f740;hb=8a47d50d72ea62e378dc92b150c92c1317c73fa3;hp=bed70ba2ec9031fd5721c115029e97a03c0afba0;hpb=19e6c1a250ade1e7204ada17163294855585e825;p=ccan diff --git a/ccan/tdb2/tdb1_lock.c b/ccan/tdb2/tdb1_lock.c index bed70ba2..c4278048 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) { @@ -135,7 +130,7 @@ static tdb1_off_t lock_offset(int list) */ int tdb1_brlock(struct tdb1_context *tdb, int rw_type, tdb1_off_t offset, size_t len, - enum tdb1_lock_flags flags) + enum tdb_lock_flags flags) { int ret; @@ -143,34 +138,25 @@ 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; + tdb->last_error = TDB_ERR_RDONLY; return -1; } 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; - } + flags & TDB_LOCK_WAIT); } while (ret == -1 && errno == EINTR); if (ret == -1) { - tdb->ecode = TDB1_ERR_LOCK; + tdb->last_error = TDB_ERR_LOCK; /* Generic lock error. errno set by fcntl. * EAGAIN is an expected return from non-blocking * locks. */ - if (!(flags & TDB1_LOCK_PROBE) && errno != EAGAIN) { - TDB1_LOG((tdb, TDB1_DEBUG_TRACE,"tdb1_brlock failed (fd=%d) at offset %d rw_type=%d flags=%d len=%d\n", - tdb->fd, offset, rw_type, flags, (int)len)); + if (!(flags & TDB_LOCK_PROBE) && errno != EAGAIN) { + tdb_logerr(tdb, TDB_ERR_LOCK, TDB_LOG_ERROR, + "tdb1_brlock failed (fd=%d) at offset %d rw_type=%d flags=%d len=%d", + tdb->fd, offset, rw_type, flags, (int)len); } return -1; } @@ -191,8 +177,10 @@ int tdb1_brunlock(struct tdb1_context *tdb, } while (ret == -1 && errno == EINTR); if (ret == -1) { - TDB1_LOG((tdb, TDB1_DEBUG_TRACE,"tdb1_brunlock failed (fd=%d) at offset %d rw_type=%d len=%d\n", - tdb->fd, offset, rw_type, (int)len)); + tdb->last_error = tdb_logerr(tdb, TDB_ERR_LOCK, TDB_LOG_ERROR, + "tdb1_brunlock failed (fd=%d) at offset" + " %d rw_type=%d len=%d", + tdb->fd, offset, rw_type, (int)len); } return ret; } @@ -208,22 +196,24 @@ int tdb1_allrecord_upgrade(struct tdb1_context *tdb) int count = 1000; if (tdb->allrecord_lock.count != 1) { - TDB1_LOG((tdb, TDB1_DEBUG_ERROR, - "tdb1_allrecord_upgrade failed: count %u too high\n", - tdb->allrecord_lock.count)); + tdb->last_error = tdb_logerr(tdb, TDB_ERR_LOCK, TDB_LOG_ERROR, + "tdb1_allrecord_upgrade failed: " + "count %u too high", + tdb->allrecord_lock.count); return -1; } if (tdb->allrecord_lock.off != 1) { - TDB1_LOG((tdb, TDB1_DEBUG_ERROR, - "tdb1_allrecord_upgrade failed: already upgraded?\n")); + tdb->last_error = tdb_logerr(tdb, TDB_ERR_LOCK, TDB_LOG_ERROR, + "tdb1_allrecord_upgrade failed:" + " already upgraded?"); return -1; } while (count--) { struct timeval tv; if (tdb1_brlock(tdb, F_WRLCK, TDB1_FREELIST_TOP, 0, - TDB1_LOCK_WAIT|TDB1_LOCK_PROBE) == 0) { + TDB_LOCK_WAIT|TDB_LOCK_PROBE) == 0) { tdb->allrecord_lock.ltype = F_WRLCK; tdb->allrecord_lock.off = 0; return 0; @@ -236,7 +226,8 @@ int tdb1_allrecord_upgrade(struct tdb1_context *tdb) tv.tv_usec = 1; select(0, NULL, NULL, NULL, &tv); } - TDB1_LOG((tdb, TDB1_DEBUG_TRACE,"tdb1_allrecord_upgrade failed\n")); + tdb->last_error = tdb_logerr(tdb, TDB_ERR_LOCK, TDB_LOG_ERROR, + "tdb1_allrecord_upgrade failed"); return -1; } @@ -255,14 +246,15 @@ static struct tdb1_lock_type *tdb1_find_nestlock(struct tdb1_context *tdb, /* lock an offset in the database. */ int tdb1_nest_lock(struct tdb1_context *tdb, uint32_t offset, int ltype, - enum tdb1_lock_flags flags) + enum tdb_lock_flags flags) { struct tdb1_lock_type *new_lck; if (offset >= lock_offset(tdb->header.hash_size)) { - tdb->ecode = TDB1_ERR_LOCK; - TDB1_LOG((tdb, TDB1_DEBUG_ERROR,"tdb1_lock: invalid offset %u for ltype=%d\n", - offset, ltype)); + tdb->last_error = tdb_logerr(tdb, TDB_ERR_LOCK, TDB_LOG_ERROR, + "tdb1_lock: invalid offset %u for" + " ltype=%d", + offset, ltype); return -1; } if (tdb->flags & TDB1_NOLOCK) @@ -306,11 +298,11 @@ static int tdb1_lock_and_recover(struct tdb1_context *tdb) int ret; /* We need to match locking order in transaction commit. */ - if (tdb1_brlock(tdb, F_WRLCK, TDB1_FREELIST_TOP, 0, TDB1_LOCK_WAIT)) { + if (tdb1_brlock(tdb, F_WRLCK, TDB1_FREELIST_TOP, 0, TDB_LOCK_WAIT)) { return -1; } - if (tdb1_brlock(tdb, F_WRLCK, TDB1_OPEN_LOCK, 1, TDB1_LOCK_WAIT)) { + if (tdb1_brlock(tdb, F_WRLCK, TDB1_OPEN_LOCK, 1, TDB_LOCK_WAIT)) { tdb1_brunlock(tdb, F_WRLCK, TDB1_FREELIST_TOP, 0); return -1; } @@ -335,7 +327,7 @@ static bool have_data_locks(const struct tdb1_context *tdb) } static int tdb1_lock_list(struct tdb1_context *tdb, int list, int ltype, - enum tdb1_lock_flags waitflag) + enum tdb_lock_flags waitflag) { int ret; bool check = false; @@ -347,7 +339,7 @@ static int tdb1_lock_list(struct tdb1_context *tdb, int list, int ltype, } if (tdb->allrecord_lock.count) { - tdb->ecode = TDB1_ERR_LOCK; + tdb->last_error = TDB_ERR_LOCK; ret = -1; } else { /* Only check when we grab first data lock. */ @@ -355,7 +347,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; @@ -371,23 +363,16 @@ int tdb1_lock(struct tdb1_context *tdb, int list, int ltype) { int ret; - ret = tdb1_lock_list(tdb, list, ltype, TDB1_LOCK_WAIT); + ret = tdb1_lock_list(tdb, list, ltype, TDB_LOCK_WAIT); if (ret) { - TDB1_LOG((tdb, TDB1_DEBUG_ERROR, "tdb1_lock failed on list %d " - "ltype=%d (%s)\n", list, ltype, strerror(errno))); + tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR, + "tdb1_lock failed on list %d " + "ltype=%d (%s)", list, ltype, strerror(errno)); } 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; @@ -397,13 +382,16 @@ int tdb1_nest_unlock(struct tdb1_context *tdb, uint32_t offset, int ltype, /* Sanity checks */ if (offset >= lock_offset(tdb->header.hash_size)) { - TDB1_LOG((tdb, TDB1_DEBUG_ERROR, "tdb1_unlock: offset %u invalid (%d)\n", offset, tdb->header.hash_size)); + tdb->last_error = tdb_logerr(tdb, TDB_ERR_LOCK, TDB_LOG_ERROR, + "tdb1_unlock: offset %u invalid (%d)", + offset, tdb->header.hash_size); return ret; } lck = tdb1_find_nestlock(tdb, offset); if ((lck == NULL) || (lck->count == 0)) { - TDB1_LOG((tdb, TDB1_DEBUG_ERROR, "tdb1_unlock: count is 0\n")); + tdb->last_error = tdb_logerr(tdb, TDB_ERR_LOCK, TDB_LOG_ERROR, + "tdb1_unlock: count is 0"); return -1; } @@ -419,11 +407,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,8 +424,6 @@ int tdb1_nest_unlock(struct tdb1_context *tdb, uint32_t offset, int ltype, SAFE_FREE(tdb->lockrecs); } - if (ret) - TDB1_LOG((tdb, TDB1_DEBUG_ERROR, "tdb1_unlock: An error occurred unlocking!\n")); return ret; } @@ -454,18 +436,18 @@ int tdb1_unlock(struct tdb1_context *tdb, int list, int ltype) } if (tdb->allrecord_lock.count) { - tdb->ecode = TDB1_ERR_LOCK; + tdb->last_error = TDB_ERR_LOCK; return -1; } - return tdb1_nest_unlock(tdb, lock_offset(list), ltype, false); + return tdb1_nest_unlock(tdb, lock_offset(list), ltype); } /* get the transaction lock */ int tdb1_transaction_lock(struct tdb1_context *tdb, int ltype, - enum tdb1_lock_flags lockflags) + enum tdb_lock_flags lockflags) { return tdb1_nest_lock(tdb, TDB1_TRANSACTION_LOCK, ltype, lockflags); } @@ -475,16 +457,16 @@ 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. */ static int tdb1_allrecord_check(struct tdb1_context *tdb, int ltype, - enum tdb1_lock_flags flags, bool upgradable) + enum tdb_lock_flags flags, bool upgradable) { /* There are no locks on read-only dbs */ if (tdb->read_only || tdb->traverse_read) { - tdb->ecode = TDB1_ERR_LOCK; + tdb->last_error = TDB_ERR_LOCK; return -1; } @@ -495,19 +477,19 @@ static int tdb1_allrecord_check(struct tdb1_context *tdb, int ltype, if (tdb->allrecord_lock.count) { /* a global lock of a different type exists */ - tdb->ecode = TDB1_ERR_LOCK; + tdb->last_error = TDB_ERR_LOCK; return -1; } if (tdb1_have_extra_locks(tdb)) { /* can't combine global and chain locks */ - tdb->ecode = TDB1_ERR_LOCK; + tdb->last_error = TDB_ERR_LOCK; return -1; } if (upgradable && ltype != F_RDLCK) { /* tdb error: you can't upgrade a write lock! */ - tdb->ecode = TDB1_ERR_LOCK; + tdb->last_error = TDB_ERR_LOCK; return -1; } return 1; @@ -516,11 +498,11 @@ static int tdb1_allrecord_check(struct tdb1_context *tdb, int ltype, /* We only need to lock individual bytes, but Linux merges consecutive locks * so we lock in contiguous ranges. */ static int tdb1_chainlock_gradual(struct tdb1_context *tdb, - int ltype, enum tdb1_lock_flags flags, + int ltype, enum tdb_lock_flags flags, size_t off, size_t len) { int ret; - enum tdb1_lock_flags nb_flags = (flags & ~TDB1_LOCK_WAIT); + enum tdb_lock_flags nb_flags = (flags & ~TDB_LOCK_WAIT); if (len <= 4) { /* Single record. Just do blocking lock. */ @@ -551,7 +533,7 @@ static int tdb1_chainlock_gradual(struct tdb1_context *tdb, * other way of guaranteeing exclusivity (ie. transaction write lock). * We do the locking gradually to avoid being starved by smaller locks. */ int tdb1_allrecord_lock(struct tdb1_context *tdb, int ltype, - enum tdb1_lock_flags flags, bool upgradable) + enum tdb_lock_flags flags, bool upgradable) { switch (tdb1_allrecord_check(tdb, ltype, flags, upgradable)) { case -1: @@ -587,14 +569,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,23 +582,23 @@ 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) { - tdb->ecode = TDB1_ERR_LOCK; + tdb->last_error = TDB_ERR_LOCK; return -1; } if (tdb->allrecord_lock.count == 0) { - tdb->ecode = TDB1_ERR_LOCK; + tdb->last_error = TDB_ERR_LOCK; return -1; } /* Upgradable locks are marked as write locks. */ if (tdb->allrecord_lock.ltype != ltype && (!tdb->allrecord_lock.off || ltype != F_RDLCK)) { - tdb->ecode = TDB1_ERR_LOCK; + tdb->last_error = TDB_ERR_LOCK; return -1; } @@ -632,8 +607,9 @@ 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)) { - TDB1_LOG((tdb, TDB1_DEBUG_ERROR, "tdb1_unlockall failed (%s)\n", strerror(errno))); + if (tdb1_brunlock(tdb, ltype, TDB1_FREELIST_TOP, 0)) { + tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR, + "tdb1_unlockall failed (%s)", strerror(errno)); return -1; } @@ -644,100 +620,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; + return tdb1_allrecord_lock(tdb, F_WRLCK, TDB_LOCK_WAIT, false); } /* 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; + return tdb1_allrecord_lock(tdb, F_RDLCK, TDB_LOCK_WAIT, false); } /* 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, TDB_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, TDB_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, TDB_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, TDB_DATA key) { return tdb1_unlock(tdb, TDB1_BUCKET(tdb->hash_fn(&key)), F_RDLCK); } @@ -748,7 +674,7 @@ int tdb1_lock_record(struct tdb1_context *tdb, tdb1_off_t off) if (tdb->allrecord_lock.count) { return 0; } - return off ? tdb1_brlock(tdb, F_RDLCK, off, 1, TDB1_LOCK_WAIT) : 0; + return off ? tdb1_brlock(tdb, F_RDLCK, off, 1, TDB_LOCK_WAIT) : 0; } /* @@ -768,7 +694,7 @@ int tdb1_write_lock_record(struct tdb1_context *tdb, tdb1_off_t off) } return -1; } - return tdb1_brlock(tdb, F_WRLCK, off, 1, TDB1_LOCK_NOWAIT|TDB1_LOCK_PROBE); + return tdb1_brlock(tdb, F_WRLCK, off, 1, TDB_LOCK_NOWAIT|TDB_LOCK_PROBE); } int tdb1_write_unlock_record(struct tdb1_context *tdb, tdb1_off_t off)