tdb2: add TDB_RDONLY flag, allow setting/unsetting it.

[ccan] / ccan / tdb2 / lock.c

diff --git a/ccan/tdb2/lock.c b/ccan/tdb2/lock.c
index 8a338cbe188c1f954ada8f701c2f7de6aeec5257..957adf83358057d458d09320d1ce546feb62bffe 100644 (file)
--- a/ccan/tdb2/lock.c
+++ b/ccan/tdb2/lock.c
@@ -37,7 +37,7 @@ static enum TDB_ERROR owner_conflict(struct tdb_context *tdb, const char *call)
                          call);
 }
 
-/* If we fork, we no longer really own locks: preserves errno */
+/* If we fork, we no longer really own locks. */
 static bool check_lock_pid(struct tdb_context *tdb,
                           const char *call, bool log)
 {
@@ -99,16 +99,21 @@ int tdb_fcntl_unlock(int fd, int rw, off_t off, off_t len, void *unused)
 static int lock(struct tdb_context *tdb,
                      int rw, off_t off, off_t len, bool waitflag)
 {
+       int ret;
        if (tdb->file->allrecord_lock.count == 0
            && tdb->file->num_lockrecs == 0) {
                tdb->file->locker = getpid();
        }
 
        tdb->stats.lock_lowlevel++;
-       if (!waitflag)
+       ret = tdb->lock_fn(tdb->file->fd, rw, off, len, waitflag,
+                          tdb->lock_data);
+       if (!waitflag) {
                tdb->stats.lock_nonblock++;
-       return tdb->lock_fn(tdb->file->fd, rw, off, len, waitflag,
-                           tdb->lock_data);
+               if (ret != 0)
+                       tdb->stats.lock_nonblock_fail++;
+       }
+       return ret;
 }
 
 static int unlock(struct tdb_context *tdb, int rw, off_t off, off_t len)
@@ -189,7 +194,7 @@ static enum TDB_ERROR tdb_brlock(struct tdb_context *tdb,
                return TDB_SUCCESS;
        }
 
-       if (rw_type == F_WRLCK && tdb->read_only) {
+       if (rw_type == F_WRLCK && (tdb->flags & TDB_RDONLY)) {
                return tdb_logerr(tdb, TDB_ERR_RDONLY, TDB_LOG_USE_ERROR,
                                  "Write lock attempted on read-only database");
        }
@@ -224,16 +229,14 @@ static enum TDB_ERROR tdb_brlock(struct tdb_context *tdb,
 static enum TDB_ERROR tdb_brunlock(struct tdb_context *tdb,
                                   int rw_type, tdb_off_t offset, size_t len)
 {
-       int ret;
-
        if (tdb->flags & TDB_NOLOCK) {
                return TDB_SUCCESS;
        }
 
-       ret = unlock(tdb, rw_type, offset, len);
+       if (!check_lock_pid(tdb, "tdb_brunlock", true))
+               return TDB_ERR_LOCK;
 
-       /* If we fail, *then* we verify that we owned the lock.  If not, ok. */
-       if (ret == -1 && check_lock_pid(tdb, "tdb_brunlock", false)) {
+       if (unlock(tdb, rw_type, offset, len) == -1) {
                return tdb_logerr(tdb, TDB_ERR_LOCK, TDB_LOG_ERROR,
                                  "tdb_brunlock failed (fd=%d) at offset %zu"
                                  " rw_type=%d len=%zu: %s",
@@ -325,13 +328,13 @@ enum TDB_ERROR tdb_lock_and_recover(struct tdb_context *tdb)
                return ecode;
        }
 
-       ecode = tdb_lock_open(tdb, TDB_LOCK_WAIT|TDB_LOCK_NOCHECK);
+       ecode = tdb_lock_open(tdb, F_WRLCK, TDB_LOCK_WAIT|TDB_LOCK_NOCHECK);
        if (ecode != TDB_SUCCESS) {
                tdb_allrecord_unlock(tdb, F_WRLCK);
                return ecode;
        }
        ecode = tdb_transaction_recover(tdb);
-       tdb_unlock_open(tdb);
+       tdb_unlock_open(tdb, F_WRLCK);
        tdb_allrecord_unlock(tdb, F_WRLCK);
 
        return ecode;
@@ -378,12 +381,14 @@ static enum TDB_ERROR tdb_nest_lock(struct tdb_context *tdb,
                return TDB_SUCCESS;
        }
 
+#if 0
        if (tdb->file->num_lockrecs
            && offset >= TDB_HASH_LOCK_START
            && offset < TDB_HASH_LOCK_START + TDB_HASH_LOCK_RANGE) {
                return tdb_logerr(tdb, TDB_ERR_LOCK, TDB_LOG_ERROR,
                                  "tdb_nest_lock: already have a hash lock?");
        }
+#endif
 
        new_lck = (struct tdb_lock *)realloc(
                tdb->file->lockrecs,
@@ -503,8 +508,9 @@ static enum TDB_ERROR tdb_lock_gradual(struct tdb_context *tdb,
        }
 
        /* First we try non-blocking. */
-       if (tdb_brlock(tdb, ltype, off, len, nb_flags) == TDB_SUCCESS) {
-               return TDB_SUCCESS;
+       ecode = tdb_brlock(tdb, ltype, off, len, nb_flags);
+       if (ecode != TDB_ERR_LOCK) {
+               return ecode;
        }
 
        /* Try locking first half, then second. */
@@ -610,14 +616,15 @@ again:
        goto again;
 }
 
-enum TDB_ERROR tdb_lock_open(struct tdb_context *tdb, enum tdb_lock_flags flags)
+enum TDB_ERROR tdb_lock_open(struct tdb_context *tdb,
+                            int ltype, enum tdb_lock_flags flags)
 {
-       return tdb_nest_lock(tdb, TDB_OPEN_LOCK, F_WRLCK, flags);
+       return tdb_nest_lock(tdb, TDB_OPEN_LOCK, ltype, flags);
 }
 
-void tdb_unlock_open(struct tdb_context *tdb)
+void tdb_unlock_open(struct tdb_context *tdb, int ltype)
 {
-       tdb_nest_unlock(tdb, TDB_OPEN_LOCK, F_WRLCK);
+       tdb_nest_unlock(tdb, TDB_OPEN_LOCK, ltype);
 }
 
 bool tdb_has_open_lock(struct tdb_context *tdb)
@@ -849,6 +856,10 @@ void tdb_lock_cleanup(struct tdb_context *tdb)
 {
        unsigned int i;
 
+       /* We don't want to warn: they're allowed to close tdb after fork. */
+       if (!check_lock_pid(tdb, "tdb_close", false))
+               return;
+
        while (tdb->file->allrecord_lock.count
               && tdb->file->allrecord_lock.owner == tdb) {
                tdb_allrecord_unlock(tdb, tdb->file->allrecord_lock.ltype);