X-Git-Url: http://git.ozlabs.org/?a=blobdiff_plain;f=ccan%2Ftdb2%2Ftdb1_lock.c;h=0fba7423a29005cd4dba00651e1875143e0aec28;hb=2b50be90a23893a06e0f1436a31d18b97ad0e11d;hp=e355bfa60caad9dfe0c244f8d63e1f611b67296d;hpb=b929638e3cfe629285af3ecd0813e03eaeaa1133;p=ccan diff --git a/ccan/tdb2/tdb1_lock.c b/ccan/tdb2/tdb1_lock.c index e355bfa6..0fba7423 100644 --- a/ccan/tdb2/tdb1_lock.c +++ b/ccan/tdb2/tdb1_lock.c @@ -130,36 +130,33 @@ 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; - if (tdb->flags & TDB1_NOLOCK) { - return 0; - } - - if (flags & TDB1_LOCK_MARK_ONLY) { + if (tdb->flags & TDB_NOLOCK) { 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); + 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; } @@ -171,7 +168,7 @@ int tdb1_brunlock(struct tdb1_context *tdb, { int ret; - if (tdb->flags & TDB1_NOLOCK) { + if (tdb->flags & TDB_NOLOCK) { return 0; } @@ -180,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; } @@ -197,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; @@ -225,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; } @@ -244,17 +246,18 @@ 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) + if (tdb->flags & TDB_NOLOCK) return 0; new_lck = tdb1_find_nestlock(tdb, offset); @@ -295,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; } @@ -324,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; @@ -336,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. */ @@ -344,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; @@ -360,32 +363,35 @@ 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; } -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; - if (tdb->flags & TDB1_NOLOCK) + if (tdb->flags & TDB_NOLOCK) return 0; /* 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; } @@ -401,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 @@ -422,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; } @@ -436,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); } @@ -457,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; } @@ -477,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; @@ -498,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. */ @@ -533,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: @@ -569,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; } @@ -589,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; } @@ -614,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; } @@ -626,50 +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); + 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); + 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; } -_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); } @@ -680,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; } /* @@ -700,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)