X-Git-Url: http://git.ozlabs.org/?p=ccan;a=blobdiff_plain;f=ccan%2Ftdb2%2Ftdb1_lock.c;h=c427804893d465d5e3fbea7cd6a850dd2017f740;hp=a33c851c1721e0c92b10b834b33756bed2c602bc;hb=3004f7e89a5978064b4fb29c1027e6d0d39e9418;hpb=444fade529f68eb2b0aebbc8de442478c5c6f916 diff --git a/ccan/tdb2/tdb1_lock.c b/ccan/tdb2/tdb1_lock.c index a33c851c..c4278048 100644 --- a/ccan/tdb2/tdb1_lock.c +++ b/ccan/tdb2/tdb1_lock.c @@ -130,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; @@ -139,23 +139,24 @@ int tdb1_brlock(struct tdb1_context *tdb, } 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); + 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; } @@ -176,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; } @@ -193,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; @@ -221,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; } @@ -240,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) @@ -291,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; } @@ -320,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; @@ -332,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. */ @@ -356,10 +363,11 @@ 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; } @@ -374,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; } @@ -413,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; } @@ -427,7 +436,7 @@ 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; } @@ -438,7 +447,7 @@ int tdb1_unlock(struct tdb1_context *tdb, int list, int 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); } @@ -453,11 +462,11 @@ int tdb1_transaction_unlock(struct tdb1_context *tdb, int 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; } @@ -468,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; @@ -489,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. */ @@ -524,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: @@ -577,19 +586,19 @@ 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; } @@ -599,7 +608,8 @@ int tdb1_allrecord_unlock(struct tdb1_context *tdb, int ltype) } if (tdb1_brunlock(tdb, ltype, TDB1_FREELIST_TOP, 0)) { - TDB1_LOG((tdb, TDB1_DEBUG_ERROR, "tdb1_unlockall failed (%s)\n", strerror(errno))); + tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR, + "tdb1_unlockall failed (%s)", strerror(errno)); return -1; } @@ -612,7 +622,7 @@ int tdb1_allrecord_unlock(struct tdb1_context *tdb, int ltype) /* lock entire database with write lock */ int tdb1_lockall(struct tdb1_context *tdb) { - return tdb1_allrecord_lock(tdb, F_WRLCK, TDB1_LOCK_WAIT, false); + return tdb1_allrecord_lock(tdb, F_WRLCK, TDB_LOCK_WAIT, false); } /* unlock entire database with write lock */ @@ -624,7 +634,7 @@ int tdb1_unlockall(struct tdb1_context *tdb) /* lock entire database with read lock */ int tdb1_lockall_read(struct tdb1_context *tdb) { - return tdb1_allrecord_lock(tdb, F_RDLCK, TDB1_LOCK_WAIT, false); + return tdb1_allrecord_lock(tdb, F_RDLCK, TDB_LOCK_WAIT, false); } /* unlock entire database with read lock */ @@ -635,25 +645,25 @@ int tdb1_unlockall_read(struct tdb1_context *tdb) /* lock/unlock one hash chain. This is meant to be used to reduce contention - it cannot guarantee how many records will be locked */ -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; } -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); } -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; } -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); } @@ -664,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; } /* @@ -684,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)