Changeset 740 for vendor/current/lib/tdb/common

Timestamp:

Nov 14, 2012, 12:59:34 PM (13 years ago)

Author:

Silvan Scherrer

Message:

Samba Server: update vendor to 3.6.0

Location:

vendor/current/lib/tdb/common

Files:

• check.c (modified) (8 diffs)
• dump.c (modified) (3 diffs)
• error.c (modified) (3 diffs)
• freelist.c (modified) (5 diffs)
• freelistcheck.c (modified) (1 diff)
• hash.c (added)
• io.c (modified) (2 diffs)
• lock.c (modified) (32 diffs)
• open.c (modified) (27 diffs)
• summary.c (added)
• tdb.c (modified) (31 diffs)
• tdb_private.h (modified) (11 diffs)
• transaction.c (modified) (33 diffs)
• traverse.c (modified) (12 diffs)

vendor/current/lib/tdb/common/check.c

@@ -29 +29 @@
 {
         struct tdb_header hdr;
-
-        if (tdb->methods->tdb_read(tdb, 0, &hdr, sizeof(hdr), DOCONV()) == -1)
+        uint32_t h1, h2;
+
+        if (tdb->methods->tdb_read(tdb, 0, &hdr, sizeof(hdr), 0) == -1)
                 return false;
         if (strcmp(hdr.magic_food, TDB_MAGIC_FOOD) != 0)
@@ -39 +40 @@
                 goto corrupt;
 
-        if (hdr.rwlocks != 0)
+        if (hdr.rwlocks != 0 && hdr.rwlocks != TDB_HASH_RWLOCK_MAGIC)
+                goto corrupt;
+
+        tdb_header_hash(tdb, &h1, &h2);
+        if (hdr.magic1_hash && hdr.magic2_hash &&
+            (hdr.magic1_hash != h1 || hdr.magic2_hash != h2))
                 goto corrupt;
 
@@ -302 +308 @@
 }
 
-int tdb_check(struct tdb_context *tdb,
+/* Slow, but should be very rare. */
+size_t tdb_dead_space(struct tdb_context *tdb, tdb_off_t off)
+{
+        size_t len;
+
+        for (len = 0; off + len < tdb->map_size; len++) {
+                char c;
+                if (tdb->methods->tdb_read(tdb, off, &c, 1, 0))
+                        return 0;
+                if (c != 0 && c != 0x42)
+                        break;
+        }
+        return len;
+}
+
+_PUBLIC_ int tdb_check(struct tdb_context *tdb,
               int (*check)(TDB_DATA key, TDB_DATA data, void *private_data),
               void *private_data)
@@ -311 +332 @@
         struct tdb_record rec;
         bool found_recovery = false;
-
-        if (tdb_lockall(tdb) == -1)
-                return -1;
+        tdb_len_t dead;
+        bool locked;
+
+        /* Read-only databases use no locking at all: it's best-effort.
+         * We may have a write lock already, so skip that case too. */
+        if (tdb->read_only || tdb->allrecord_lock.count != 0) {
+                locked = false;
+        } else {
+                if (tdb_lockall_read(tdb) == -1)
+                        return -1;
+                locked = true;
+        }
 
         /* Make sure we know true size of the underlying file. */
@@ -370 +400 @@
                                 goto free;
                         break;
+                /* If we crash after ftruncate, we can get zeroes or fill. */
+                case TDB_RECOVERY_INVALID_MAGIC:
+                case 0x42424242:
+                        if (recovery_start == off) {
+                                found_recovery = true;
+                                break;
+                        }
+                        dead = tdb_dead_space(tdb, off);
+                        if (dead < sizeof(rec))
+                                goto corrupt;
+
+                        TDB_LOG((tdb, TDB_DEBUG_ERROR,
+                                 "Dead space at %d-%d (of %u)\n",
+                                 off, off + dead, tdb->map_size));
+                        rec.rec_len = dead - sizeof(rec);
+                        break;
                 case TDB_RECOVERY_MAGIC:
-                case 0: /* Used for invalid (or in-progress) recovery area. */
                         if (recovery_start != off) {
                                 TDB_LOG((tdb, TDB_DEBUG_ERROR,
@@ -380 +425 @@
                         found_recovery = true;
                         break;
-                default:
+                default: ;
+                corrupt:
                         tdb->ecode = TDB_ERR_CORRUPT;
                         TDB_LOG((tdb, TDB_DEBUG_ERROR,
@@ -406 +452 @@
         if (recovery_start != 0 && !found_recovery) {
                 TDB_LOG((tdb, TDB_DEBUG_ERROR,
-                         "Expected %s recovery area, got %s\n",
-                         recovery_start ? "a" : "no",
-                         found_recovery ? "one" : "none"));
+                         "Expected a recovery area at %u\n",
+                         recovery_start));
                 goto free;
         }
 
         free(hashes);
-        tdb_unlockall(tdb);
+        if (locked) {
+                tdb_unlockall_read(tdb);
+        }
         return 0;
 
@@ -419 +466 @@
         free(hashes);
 unlock:
-        tdb_unlockall(tdb);
+        if (locked) {
+                tdb_unlockall_read(tdb);
+        }
         return -1;
 }

vendor/current/lib/tdb/common/dump.c

@@ -7 +7 @@
    Copyright (C) Paul `Rusty' Russell              2000
    Copyright (C) Jeremy Allison                    2000-2003
-   
+
      ** NOTE! The following LGPL license applies to the tdb
      ** library. This does NOT imply that all of Samba is released
      ** under the LGPL
-   
+
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
@@ -81 +81 @@
 }
 
-void tdb_dump_all(struct tdb_context *tdb)
+_PUBLIC_ void tdb_dump_all(struct tdb_context *tdb)
 {
         int i;
@@ -91 +91 @@
 }
 
-int tdb_printfreelist(struct tdb_context *tdb)
+_PUBLIC_ int tdb_printfreelist(struct tdb_context *tdb)
 {
         int ret;

vendor/current/lib/tdb/common/error.c

@@ -7 +7 @@
    Copyright (C) Paul `Rusty' Russell              2000
    Copyright (C) Jeremy Allison                    2000-2003
-   
+
      ** NOTE! The following LGPL license applies to the tdb
      ** library. This does NOT imply that all of Samba is released
      ** under the LGPL
-   
+
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
@@ -28 +28 @@
 #include "tdb_private.h"
 
-enum TDB_ERROR tdb_error(struct tdb_context *tdb)
+_PUBLIC_ enum TDB_ERROR tdb_error(struct tdb_context *tdb)
 {
         return tdb->ecode;
@@ -47 +47 @@
 
 /* Error string for the last tdb error */
-const char *tdb_errorstr(struct tdb_context *tdb)
+_PUBLIC_ const char *tdb_errorstr(struct tdb_context *tdb)
 {
         uint32_t i;

vendor/current/lib/tdb/common/freelist.c

@@ -7 +7 @@
    Copyright (C) Paul `Rusty' Russell              2000
    Copyright (C) Jeremy Allison                    2000-2003
-   
+
      ** NOTE! The following LGPL license applies to the tdb
      ** library. This does NOT imply that all of Samba is released
      ** under the LGPL
-   
+
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
@@ -99 +99 @@
 
 /* Add an element into the freelist. Merge adjacent records if
-   neccessary. */
+   necessary. */
 int tdb_free(struct tdb_context *tdb, tdb_off_t offset, struct tdb_record *rec)
 {
@@ -144 +144 @@
                 struct tdb_record l;
                 tdb_off_t leftsize;
-                
+
                 /* Read in tailer and jump back to header */
                 if (tdb_ofs_read(tdb, left, &leftsize) == -1) {
@@ -335 +335 @@
                         break;
                 }
-                
+
                 /* this multiplier means we only extremely rarely
                    search more than 50 or so records. At 50 records we
@@ -368 +368 @@
    return the size of the freelist - used to decide if we should repack 
 */
-int tdb_freelist_size(struct tdb_context *tdb)
+_PUBLIC_ int tdb_freelist_size(struct tdb_context *tdb)
 {
         tdb_off_t ptr;

vendor/current/lib/tdb/common/freelistcheck.c

@@ -44 +44 @@
 }
 
-int tdb_validate_freelist(struct tdb_context *tdb, int *pnum_entries)
+_PUBLIC_ int tdb_validate_freelist(struct tdb_context *tdb, int *pnum_entries)
 {
         struct tdb_context *mem_tdb = NULL;

vendor/current/lib/tdb/common/io.c

@@ -7 +7 @@
    Copyright (C) Paul `Rusty' Russell              2000
    Copyright (C) Jeremy Allison                    2000-2003
-   
+
      ** NOTE! The following LGPL license applies to the tdb
      ** library. This does NOT imply that all of Samba is released
      ** under the LGPL
-   
+
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
@@ -477 +477 @@
         tdb_oob,
         tdb_expand_file,
-        tdb_brlock
 };
 

vendor/current/lib/tdb/common/lock.c

@@ -7 +7 @@
    Copyright (C) Paul `Rusty' Russell              2000
    Copyright (C) Jeremy Allison                    2000-2003
-   
+
      ** NOTE! The following LGPL license applies to the tdb
      ** library. This does NOT imply that all of Samba is released
      ** under the LGPL
-   
+
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
@@ -28 +28 @@
 #include "tdb_private.h"
 
-#define TDB_MARK_LOCK 0x80000000
-
-void tdb_setalarm_sigptr(struct tdb_context *tdb, volatile sig_atomic_t *ptr)
+_PUBLIC_ void tdb_setalarm_sigptr(struct tdb_context *tdb, volatile sig_atomic_t *ptr)
 {
         tdb->interrupt_sig_ptr = ptr;
+}
+
+static int fcntl_lock(struct tdb_context *tdb,
+                      int rw, off_t off, off_t len, bool waitflag)
+{
+        struct flock fl;
+
+        fl.l_type = rw;
+        fl.l_whence = SEEK_SET;
+        fl.l_start = off;
+        fl.l_len = len;
+        fl.l_pid = 0;
+
+        if (waitflag)
+                return fcntl(tdb->fd, F_SETLKW, &fl);
+        else
+                return fcntl(tdb->fd, F_SETLK, &fl);
+}
+
+static int fcntl_unlock(struct tdb_context *tdb, int rw, off_t off, off_t len)
+{
+        struct flock fl;
+#if 0 /* Check they matched up locks and unlocks correctly. */
+        char line[80];
+        FILE *locks;
+        bool found = false;
+
+        locks = fopen("/proc/locks", "r");
+
+        while (fgets(line, 80, locks)) {
+                char *p;
+                int type, start, l;
+
+                /* eg. 1: FLOCK  ADVISORY  WRITE 2440 08:01:2180826 0 EOF */
+                p = strchr(line, ':') + 1;
+                if (strncmp(p, " POSIX  ADVISORY  ", strlen(" POSIX  ADVISORY  ")))
+                        continue;
+                p += strlen(" FLOCK  ADVISORY  ");
+                if (strncmp(p, "READ  ", strlen("READ  ")) == 0)
+                        type = F_RDLCK;
+                else if (strncmp(p, "WRITE ", strlen("WRITE ")) == 0)
+                        type = F_WRLCK;
+                else
+                        abort();
+                p += 6;
+                if (atoi(p) != getpid())
+                        continue;
+                p = strchr(strchr(p, ' ') + 1, ' ') + 1;
+                start = atoi(p);
+                p = strchr(p, ' ') + 1;
+                if (strncmp(p, "EOF", 3) == 0)
+                        l = 0;
+                else
+                        l = atoi(p) - start + 1;
+
+                if (off == start) {
+                        if (len != l) {
+                                fprintf(stderr, "Len %u should be %u: %s",
+                                        (int)len, l, line);
+                                abort();
+                        }
+                        if (type != rw) {
+                                fprintf(stderr, "Type %s wrong: %s",
+                                        rw == F_RDLCK ? "READ" : "WRITE", line);
+                                abort();
+                        }
+                        found = true;
+                        break;
+                }
+        }
+
+        if (!found) {
+                fprintf(stderr, "Unlock on %u@%u not found!\n",
+                        (int)off, (int)len);
+                abort();
+        }
+
+        fclose(locks);
+#endif
+
+        fl.l_type = F_UNLCK;
+        fl.l_whence = SEEK_SET;
+        fl.l_start = off;
+        fl.l_len = len;
+        fl.l_pid = 0;
+
+        return fcntl(tdb->fd, F_SETLKW, &fl);
+}
+
+/* list -1 is the alloc list, otherwise a hash chain. */
+static tdb_off_t lock_offset(int list)
+{
+        return FREELIST_TOP + 4*list;
 }
 
@@ -43 +134 @@
    note that a len of zero means lock to end of file
 */
-int tdb_brlock(struct tdb_context *tdb, tdb_off_t offset, 
-               int rw_type, int lck_type, int probe, size_t len)
-{
-        struct flock fl;
+int tdb_brlock(struct tdb_context *tdb,
+               int rw_type, tdb_off_t offset, size_t len,
+               enum tdb_lock_flags flags)
+{
         int ret;
 
         if (tdb->flags & TDB_NOLOCK) {
+                return 0;
+        }
+
+        if (flags & TDB_LOCK_MARK_ONLY) {
                 return 0;
         }
@@ -58 +153 @@
         }
 
-        fl.l_type = rw_type;
-        fl.l_whence = SEEK_SET;
-        fl.l_start = offset;
-        fl.l_len = len;
-        fl.l_pid = 0;
-
         do {
-                ret = fcntl(tdb->fd,lck_type,&fl);
-
+                ret = fcntl_lock(tdb, rw_type, offset, len,
+                                 flags & TDB_LOCK_WAIT);
                 /* Check for a sigalarm break. */
                 if (ret == -1 && errno == EINTR &&
@@ -80 +169 @@
                  * EAGAIN is an expected return from non-blocking
                  * locks. */
-                if (!probe && lck_type != F_SETLK) {
-                        TDB_LOG((tdb, TDB_DEBUG_TRACE,"tdb_brlock failed (fd=%d) at offset %d rw_type=%d lck_type=%d len=%d\n", 
-                                 tdb->fd, offset, rw_type, lck_type, (int)len));
+                if (!(flags & TDB_LOCK_PROBE) && errno != EAGAIN) {
+                        TDB_LOG((tdb, TDB_DEBUG_TRACE,"tdb_brlock failed (fd=%d) at offset %d rw_type=%d flags=%d len=%d\n",
+                                 tdb->fd, offset, rw_type, flags, (int)len));
                 }
                 return -1;
@@ -89 +178 @@
 }
 
+int tdb_brunlock(struct tdb_context *tdb,
+                 int rw_type, tdb_off_t offset, size_t len)
+{
+        int ret;
+
+        if (tdb->flags & TDB_NOLOCK) {
+                return 0;
+        }
+
+        do {
+                ret = fcntl_unlock(tdb, rw_type, offset, len);
+        } while (ret == -1 && errno == EINTR);
+
+        if (ret == -1) {
+                TDB_LOG((tdb, TDB_DEBUG_TRACE,"tdb_brunlock failed (fd=%d) at offset %d rw_type=%d len=%d\n",
+                         tdb->fd, offset, rw_type, (int)len));
+        }
+        return ret;
+}
 
 /*
@@ -96 +204 @@
   made. For those OSes we may loop for a while.  
 */
-int tdb_brlock_upgrade(struct tdb_context *tdb, tdb_off_t offset, size_t len)
+int tdb_allrecord_upgrade(struct tdb_context *tdb)
 {
         int count = 1000;
+
+        if (tdb->allrecord_lock.count != 1) {
+                TDB_LOG((tdb, TDB_DEBUG_ERROR,
+                         "tdb_allrecord_upgrade failed: count %u too high\n",
+                         tdb->allrecord_lock.count));
+                return -1;
+        }
+
+        if (tdb->allrecord_lock.off != 1) {
+                TDB_LOG((tdb, TDB_DEBUG_ERROR,
+                         "tdb_allrecord_upgrade failed: already upgraded?\n"));
+                return -1;
+        }
+
         while (count--) {
                 struct timeval tv;
-                if (tdb_brlock(tdb, offset, F_WRLCK, F_SETLKW, 1, len) == 0) {
+                if (tdb_brlock(tdb, F_WRLCK, FREELIST_TOP, 0,
+                               TDB_LOCK_WAIT|TDB_LOCK_PROBE) == 0) {
+                        tdb->allrecord_lock.ltype = F_WRLCK;
+                        tdb->allrecord_lock.off = 0;
                         return 0;
                 }
@@ -112 +237 @@
                 select(0, NULL, NULL, NULL, &tv);
         }
-        TDB_LOG((tdb, TDB_DEBUG_TRACE,"tdb_brlock_upgrade failed at offset %d\n", offset));
+        TDB_LOG((tdb, TDB_DEBUG_TRACE,"tdb_allrecord_upgrade failed\n"));
         return -1;
 }
 
-
-/* lock a list in the database. list -1 is the alloc list */
-static int _tdb_lock(struct tdb_context *tdb, int list, int ltype, int op)
+static struct tdb_lock_type *find_nestlock(struct tdb_context *tdb,
+                                           tdb_off_t offset)
+{
+        unsigned int i;
+
+        for (i=0; i<tdb->num_lockrecs; i++) {
+                if (tdb->lockrecs[i].off == offset) {
+                        return &tdb->lockrecs[i];
+                }
+        }
+        return NULL;
+}
+
+/* lock an offset in the database. */
+int tdb_nest_lock(struct tdb_context *tdb, uint32_t offset, int ltype,
+                  enum tdb_lock_flags flags)
 {
         struct tdb_lock_type *new_lck;
-        int i;
-        bool mark_lock = ((ltype & TDB_MARK_LOCK) == TDB_MARK_LOCK);
-
-        ltype &= ~TDB_MARK_LOCK;
-
-        /* a global lock allows us to avoid per chain locks */
-        if (tdb->global_lock.count && 
-            (ltype == tdb->global_lock.ltype || ltype == F_RDLCK)) {
-                return 0;
-        }
-
-        if (tdb->global_lock.count) {
-                tdb->ecode = TDB_ERR_LOCK;
-                return -1;
-        }
-
-        if (list < -1 || list >= (int)tdb->header.hash_size) {
-                tdb->ecode = TDB_ERR_LOCK;
-                TDB_LOG((tdb, TDB_DEBUG_ERROR,"tdb_lock: invalid list %d for ltype=%d\n", 
-                           list, ltype));
+
+        if (offset >= lock_offset(tdb->header.hash_size)) {
+                tdb->ecode = TDB_ERR_LOCK;
+                TDB_LOG((tdb, TDB_DEBUG_ERROR,"tdb_lock: invalid offset %u for ltype=%d\n",
+                         offset, ltype));
                 return -1;
         }
@@ -146 +269 @@
                 return 0;
 
-        for (i=0; i<tdb->num_lockrecs; i++) {
-                if (tdb->lockrecs[i].list == list) {
-                        if (tdb->lockrecs[i].count == 0) {
-                                /*
-                                 * Can't happen, see tdb_unlock(). It should
-                                 * be an assert.
-                                 */
-                                TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_lock: "
-                                         "lck->count == 0 for list %d", list));
-                        }
-                        /*
-                         * Just increment the in-memory struct, posix locks
-                         * don't stack.
-                         */
-                        tdb->lockrecs[i].count++;
-                        return 0;
-                }
+        new_lck = find_nestlock(tdb, offset);
+        if (new_lck) {
+                /*
+                 * Just increment the in-memory struct, posix locks
+                 * don't stack.
+                 */
+                new_lck->count++;
+                return 0;
         }
 
@@ -176 +290 @@
         /* Since fcntl locks don't nest, we do a lock for the first one,
            and simply bump the count for future ones */
-        if (!mark_lock &&
-            tdb->methods->tdb_brlock(tdb,FREELIST_TOP+4*list, ltype, op,
-                                     0, 1)) {
-                return -1;
-        }
-
-        tdb->num_locks++;
-
-        tdb->lockrecs[tdb->num_lockrecs].list = list;
+        if (tdb_brlock(tdb, ltype, offset, 1, flags)) {
+                return -1;
+        }
+
+        tdb->lockrecs[tdb->num_lockrecs].off = offset;
         tdb->lockrecs[tdb->num_lockrecs].count = 1;
         tdb->lockrecs[tdb->num_lockrecs].ltype = ltype;
-        tdb->num_lockrecs += 1;
+        tdb->num_lockrecs++;
 
         return 0;
+}
+
+static int tdb_lock_and_recover(struct tdb_context *tdb)
+{
+        int ret;
+
+        /* We need to match locking order in transaction commit. */
+        if (tdb_brlock(tdb, F_WRLCK, FREELIST_TOP, 0, TDB_LOCK_WAIT)) {
+                return -1;
+        }
+
+        if (tdb_brlock(tdb, F_WRLCK, OPEN_LOCK, 1, TDB_LOCK_WAIT)) {
+                tdb_brunlock(tdb, F_WRLCK, FREELIST_TOP, 0);
+                return -1;
+        }
+
+        ret = tdb_transaction_recover(tdb);
+
+        tdb_brunlock(tdb, F_WRLCK, OPEN_LOCK, 1);
+        tdb_brunlock(tdb, F_WRLCK, FREELIST_TOP, 0);
+
+        return ret;
+}
+
+static bool have_data_locks(const struct tdb_context *tdb)
+{
+        unsigned int i;
+
+        for (i = 0; i < tdb->num_lockrecs; i++) {
+                if (tdb->lockrecs[i].off >= lock_offset(-1))
+                        return true;
+        }
+        return false;
+}
+
+static int tdb_lock_list(struct tdb_context *tdb, int list, int ltype,
+                         enum tdb_lock_flags waitflag)
+{
+        int ret;
+        bool check = false;
+
+        /* a allrecord lock allows us to avoid per chain locks */
+        if (tdb->allrecord_lock.count &&
+            (ltype == tdb->allrecord_lock.ltype || ltype == F_RDLCK)) {
+                return 0;
+        }
+
+        if (tdb->allrecord_lock.count) {
+                tdb->ecode = TDB_ERR_LOCK;
+                ret = -1;
+        } else {
+                /* Only check when we grab first data lock. */
+                check = !have_data_locks(tdb);
+                ret = tdb_nest_lock(tdb, lock_offset(list), ltype, waitflag);
+
+                if (ret == 0 && check && tdb_needs_recovery(tdb)) {
+                        tdb_nest_unlock(tdb, lock_offset(list), ltype, false);
+
+                        if (tdb_lock_and_recover(tdb) == -1) {
+                                return -1;
+                        }
+                        return tdb_lock_list(tdb, list, ltype, waitflag);
+                }
+        }
+        return ret;
 }
 
@@ -196 +371 @@
 {
         int ret;
-        ret = _tdb_lock(tdb, list, ltype, F_SETLKW);
+
+        ret = tdb_lock_list(tdb, list, ltype, TDB_LOCK_WAIT);
         if (ret) {
                 TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_lock failed on list %d "
@@ -207 +383 @@
 int tdb_lock_nonblock(struct tdb_context *tdb, int list, int ltype)
 {
-        return _tdb_lock(tdb, list, ltype, F_SETLK);
-}
-
-
-/* unlock the database: returns void because it's too late for errors. */
-        /* changed to return int it may be interesting to know there
-           has been an error  --simo */
-int tdb_unlock(struct tdb_context *tdb, int list, int ltype)
+        return tdb_lock_list(tdb, list, ltype, TDB_LOCK_NOWAIT);
+}
+
+
+int tdb_nest_unlock(struct tdb_context *tdb, uint32_t offset, int ltype,
+                    bool mark_lock)
 {
         int ret = -1;
-        int i;
-        struct tdb_lock_type *lck = NULL;
-        bool mark_lock = ((ltype & TDB_MARK_LOCK) == TDB_MARK_LOCK);
-
-        ltype &= ~TDB_MARK_LOCK;
-
-        /* a global lock allows us to avoid per chain locks */
-        if (tdb->global_lock.count && 
-            (ltype == tdb->global_lock.ltype || ltype == F_RDLCK)) {
-                return 0;
-        }
-
-        if (tdb->global_lock.count) {
-                tdb->ecode = TDB_ERR_LOCK;
-                return -1;
-        }
+        struct tdb_lock_type *lck;
 
         if (tdb->flags & TDB_NOLOCK)
@@ -238 +397 @@
 
         /* Sanity checks */
-        if (list < -1 || list >= (int)tdb->header.hash_size) {
-                TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_unlock: list %d invalid (%d)\n", list, tdb->header.hash_size));
+        if (offset >= lock_offset(tdb->header.hash_size)) {
+                TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_unlock: offset %u invalid (%d)\n", offset, tdb->header.hash_size));
                 return ret;
         }
 
-        for (i=0; i<tdb->num_lockrecs; i++) {
-                if (tdb->lockrecs[i].list == list) {
-                        lck = &tdb->lockrecs[i];
-                        break;
-                }
-        }
-
+        lck = find_nestlock(tdb, offset);
         if ((lck == NULL) || (lck->count == 0)) {
                 TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_unlock: count is 0\n"));
@@ -270 +423 @@
                 ret = 0;
         } else {
-                ret = tdb->methods->tdb_brlock(tdb, FREELIST_TOP+4*list, F_UNLCK,
-                                               F_SETLKW, 0, 1);
-        }
-        tdb->num_locks--;
+                ret = tdb_brunlock(tdb, ltype, offset, 1);
+        }
 
         /*
@@ -279 +430 @@
          * last array element.
          */
-
-        if (tdb->num_lockrecs > 1) {
-                *lck = tdb->lockrecs[tdb->num_lockrecs-1];
-        }
-        tdb->num_lockrecs -= 1;
+        *lck = tdb->lockrecs[--tdb->num_lockrecs];
 
         /*
@@ -299 +446 @@
 }
 
+int tdb_unlock(struct tdb_context *tdb, int list, int ltype)
+{
+        /* a global lock allows us to avoid per chain locks */
+        if (tdb->allrecord_lock.count &&
+            (ltype == tdb->allrecord_lock.ltype || ltype == F_RDLCK)) {
+                return 0;
+        }
+
+        if (tdb->allrecord_lock.count) {
+                tdb->ecode = TDB_ERR_LOCK;
+                return -1;
+        }
+
+        return tdb_nest_unlock(tdb, lock_offset(list), ltype, false);
+}
+
 /*
   get the transaction lock
  */
-int tdb_transaction_lock(struct tdb_context *tdb, int ltype)
-{
-        if (tdb->global_lock.count) {
-                return 0;
-        }
-        if (tdb->transaction_lock_count > 0) {
-                tdb->transaction_lock_count++;
-                return 0;
-        }
-
-        if (tdb->methods->tdb_brlock(tdb, TRANSACTION_LOCK, ltype, 
-                                     F_SETLKW, 0, 1) == -1) {
-                TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_transaction_lock: failed to get transaction lock\n"));
-                tdb->ecode = TDB_ERR_LOCK;
-                return -1;
-        }
-        tdb->transaction_lock_count++;
-        return 0;
+int tdb_transaction_lock(struct tdb_context *tdb, int ltype,
+                         enum tdb_lock_flags lockflags)
+{
+        return tdb_nest_lock(tdb, TRANSACTION_LOCK, ltype, lockflags);
 }
 
@@ -325 +474 @@
   release the transaction lock
  */
-int tdb_transaction_unlock(struct tdb_context *tdb)
-{
-        int ret;
-        if (tdb->global_lock.count) {
-                return 0;
-        }
-        if (tdb->transaction_lock_count > 1) {
-                tdb->transaction_lock_count--;
-                return 0;
-        }
-        ret = tdb->methods->tdb_brlock(tdb, TRANSACTION_LOCK, F_UNLCK, F_SETLKW, 0, 1);
-        if (ret == 0) {
-                tdb->transaction_lock_count = 0;
-        }
-        return ret;
-}
-
-
-
-
-/* lock/unlock entire database */
-static int _tdb_lockall(struct tdb_context *tdb, int ltype, int op)
-{
-        bool mark_lock = ((ltype & TDB_MARK_LOCK) == TDB_MARK_LOCK);
-
-        ltype &= ~TDB_MARK_LOCK;
-
+int tdb_transaction_unlock(struct tdb_context *tdb, int ltype)
+{
+        return tdb_nest_unlock(tdb, TRANSACTION_LOCK, ltype, false);
+}
+
+/* Returns 0 if all done, -1 if error, 1 if ok. */
+static int tdb_allrecord_check(struct tdb_context *tdb, int ltype,
+                               enum tdb_lock_flags flags, bool upgradable)
+{
         /* There are no locks on read-only dbs */
         if (tdb->read_only || tdb->traverse_read) {
@@ -358 +489 @@
         }
 
-        if (tdb->global_lock.count && tdb->global_lock.ltype == ltype) {
-                tdb->global_lock.count++;
-                return 0;
-        }
-
-        if (tdb->global_lock.count) {
+        if (tdb->allrecord_lock.count && tdb->allrecord_lock.ltype == ltype) {
+                tdb->allrecord_lock.count++;
+                return 0;
+        }
+
+        if (tdb->allrecord_lock.count) {
                 /* a global lock of a different type exists */
                 tdb->ecode = TDB_ERR_LOCK;
                 return -1;
         }
-        
-        if (tdb->num_locks != 0) {
+
+        if (tdb_have_extra_locks(tdb)) {
                 /* can't combine global and chain locks */
                 tdb->ecode = TDB_ERR_LOCK;
@@ -375 +506 @@
         }
 
-        if (!mark_lock &&
-            tdb->methods->tdb_brlock(tdb, FREELIST_TOP, ltype, op,
-                                     0, 4*tdb->header.hash_size)) {
-                if (op == F_SETLKW) {
-                        TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_lockall failed (%s)\n", strerror(errno)));
-                }
-                return -1;
-        }
-
-        tdb->global_lock.count = 1;
-        tdb->global_lock.ltype = ltype;
-
+        if (upgradable && ltype != F_RDLCK) {
+                /* tdb error: you can't upgrade a write lock! */
+                tdb->ecode = TDB_ERR_LOCK;
+                return -1;
+        }
+        return 1;
+}
+
+/* We only need to lock individual bytes, but Linux merges consecutive locks
+ * so we lock in contiguous ranges. */
+static int tdb_chainlock_gradual(struct tdb_context *tdb,
+                                 int ltype, enum tdb_lock_flags flags,
+                                 size_t off, size_t len)
+{
+        int ret;
+        enum tdb_lock_flags nb_flags = (flags & ~TDB_LOCK_WAIT);
+
+        if (len <= 4) {
+                /* Single record.  Just do blocking lock. */
+                return tdb_brlock(tdb, ltype, off, len, flags);
+        }
+
+        /* First we try non-blocking. */
+        ret = tdb_brlock(tdb, ltype, off, len, nb_flags);
+        if (ret == 0) {
+                return 0;
+        }
+
+        /* Try locking first half, then second. */
+        ret = tdb_chainlock_gradual(tdb, ltype, flags, off, len / 2);
+        if (ret == -1)
+                return -1;
+
+        ret = tdb_chainlock_gradual(tdb, ltype, flags,
+                                    off + len / 2, len - len / 2);
+        if (ret == -1) {
+                tdb_brunlock(tdb, ltype, off, len / 2);
+                return -1;
+        }
         return 0;
 }
 
+/* lock/unlock entire database.  It can only be upgradable if you have some
+ * other way of guaranteeing exclusivity (ie. transaction write lock).
+ * We do the locking gradually to avoid being starved by smaller locks. */
+int tdb_allrecord_lock(struct tdb_context *tdb, int ltype,
+                       enum tdb_lock_flags flags, bool upgradable)
+{
+        switch (tdb_allrecord_check(tdb, ltype, flags, upgradable)) {
+        case -1:
+                return -1;
+        case 0:
+                return 0;
+        }
+
+        /* We cover two kinds of locks:
+         * 1) Normal chain locks.  Taken for almost all operations.
+         * 3) Individual records locks.  Taken after normal or free
+         *    chain locks.
+         *
+         * It is (1) which cause the starvation problem, so we're only
+         * gradual for that. */
+        if (tdb_chainlock_gradual(tdb, ltype, flags, FREELIST_TOP,
+                                  tdb->header.hash_size * 4) == -1) {
+                return -1;
+        }
+
+        /* Grab individual record locks. */
+        if (tdb_brlock(tdb, ltype, lock_offset(tdb->header.hash_size), 0,
+                       flags) == -1) {
+                tdb_brunlock(tdb, ltype, FREELIST_TOP,
+                             tdb->header.hash_size * 4);
+                return -1;
+        }
+
+        tdb->allrecord_lock.count = 1;
+        /* If it's upgradable, it's actually exclusive so we can treat
+         * it as a write lock. */
+        tdb->allrecord_lock.ltype = upgradable ? F_WRLCK : ltype;
+        tdb->allrecord_lock.off = upgradable;
+
+        if (tdb_needs_recovery(tdb)) {
+                bool mark = flags & TDB_LOCK_MARK_ONLY;
+                tdb_allrecord_unlock(tdb, ltype, mark);
+                if (mark) {
+                        tdb->ecode = TDB_ERR_LOCK;
+                        TDB_LOG((tdb, TDB_DEBUG_ERROR,
+                                 "tdb_lockall_mark cannot do recovery\n"));
+                        return -1;
+                }
+                if (tdb_lock_and_recover(tdb) == -1) {
+                        return -1;
+                }
+                return tdb_allrecord_lock(tdb, ltype, flags, upgradable);
+        }
+
+        return 0;
+}
+
 
 
 /* unlock entire db */
-static int _tdb_unlockall(struct tdb_context *tdb, int ltype)
-{
-        bool mark_lock = ((ltype & TDB_MARK_LOCK) == TDB_MARK_LOCK);
-
-        ltype &= ~TDB_MARK_LOCK;
-
+int tdb_allrecord_unlock(struct tdb_context *tdb, int ltype, bool mark_lock)
+{
         /* There are no locks on read-only dbs */
         if (tdb->read_only || tdb->traverse_read) {
@@ -405 +616 @@
         }
 
-        if (tdb->global_lock.ltype != ltype || tdb->global_lock.count == 0) {
-                tdb->ecode = TDB_ERR_LOCK;
-                return -1;
-        }
-
-        if (tdb->global_lock.count > 1) {
-                tdb->global_lock.count--;
-                return 0;
-        }
-
-        if (!mark_lock &&
-            tdb->methods->tdb_brlock(tdb, FREELIST_TOP, F_UNLCK, F_SETLKW, 
-                                     0, 4*tdb->header.hash_size)) {
+        if (tdb->allrecord_lock.count == 0) {
+                tdb->ecode = 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 = TDB_ERR_LOCK;
+                return -1;
+        }
+
+        if (tdb->allrecord_lock.count > 1) {
+                tdb->allrecord_lock.count--;
+                return 0;
+        }
+
+        if (!mark_lock && tdb_brunlock(tdb, ltype, FREELIST_TOP, 0)) {
                 TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_unlockall failed (%s)\n", strerror(errno)));
                 return -1;
         }
 
-        tdb->global_lock.count = 0;
-        tdb->global_lock.ltype = 0;
+        tdb->allrecord_lock.count = 0;
+        tdb->allrecord_lock.ltype = 0;
 
         return 0;
@@ -429 +645 @@
 
 /* lock entire database with write lock */
-int tdb_lockall(struct tdb_context *tdb)
+_PUBLIC_ int tdb_lockall(struct tdb_context *tdb)
 {
         tdb_trace(tdb, "tdb_lockall");
-        return _tdb_lockall(tdb, F_WRLCK, F_SETLKW);
+        return tdb_allrecord_lock(tdb, F_WRLCK, TDB_LOCK_WAIT, false);
 }
 
 /* lock entire database with write lock - mark only */
-int tdb_lockall_mark(struct tdb_context *tdb)
+_PUBLIC_ int tdb_lockall_mark(struct tdb_context *tdb)
 {
         tdb_trace(tdb, "tdb_lockall_mark");
-        return _tdb_lockall(tdb, F_WRLCK | TDB_MARK_LOCK, F_SETLKW);
+        return tdb_allrecord_lock(tdb, F_WRLCK, TDB_LOCK_MARK_ONLY, false);
 }
 
 /* unlock entire database with write lock - unmark only */
-int tdb_lockall_unmark(struct tdb_context *tdb)
+_PUBLIC_ int tdb_lockall_unmark(struct tdb_context *tdb)
 {
         tdb_trace(tdb, "tdb_lockall_unmark");
-        return _tdb_unlockall(tdb, F_WRLCK | TDB_MARK_LOCK);
+        return tdb_allrecord_unlock(tdb, F_WRLCK, true);
 }
 
 /* lock entire database with write lock - nonblocking varient */
-int tdb_lockall_nonblock(struct tdb_context *tdb)
-{
-        int ret = _tdb_lockall(tdb, F_WRLCK, F_SETLK);
+_PUBLIC_ int tdb_lockall_nonblock(struct tdb_context *tdb)
+{
+        int ret = tdb_allrecord_lock(tdb, F_WRLCK, TDB_LOCK_NOWAIT, false);
         tdb_trace_ret(tdb, "tdb_lockall_nonblock", ret);
         return ret;
@@ -458 +674 @@
 
 /* unlock entire database with write lock */
-int tdb_unlockall(struct tdb_context *tdb)
+_PUBLIC_ int tdb_unlockall(struct tdb_context *tdb)
 {
         tdb_trace(tdb, "tdb_unlockall");
-        return _tdb_unlockall(tdb, F_WRLCK);
+        return tdb_allrecord_unlock(tdb, F_WRLCK, false);
 }
 
 /* lock entire database with read lock */
-int tdb_lockall_read(struct tdb_context *tdb)
+_PUBLIC_ int tdb_lockall_read(struct tdb_context *tdb)
 {
         tdb_trace(tdb, "tdb_lockall_read");
-        return _tdb_lockall(tdb, F_RDLCK, F_SETLKW);
+        return tdb_allrecord_lock(tdb, F_RDLCK, TDB_LOCK_WAIT, false);
 }
 
 /* lock entire database with read lock - nonblock varient */
-int tdb_lockall_read_nonblock(struct tdb_context *tdb)
-{
-        int ret = _tdb_lockall(tdb, F_RDLCK, F_SETLK);
+_PUBLIC_ int tdb_lockall_read_nonblock(struct tdb_context *tdb)
+{
+        int ret = tdb_allrecord_lock(tdb, F_RDLCK, TDB_LOCK_NOWAIT, false);
         tdb_trace_ret(tdb, "tdb_lockall_read_nonblock", ret);
         return ret;
@@ -480 +696 @@
 
 /* unlock entire database with read lock */
-int tdb_unlockall_read(struct tdb_context *tdb)
+_PUBLIC_ int tdb_unlockall_read(struct tdb_context *tdb)
 {
         tdb_trace(tdb, "tdb_unlockall_read");
-        return _tdb_unlockall(tdb, F_RDLCK);
+        return tdb_allrecord_unlock(tdb, F_RDLCK, false);
 }
 
 /* lock/unlock one hash chain. This is meant to be used to reduce
    contention - it cannot guarantee how many records will be locked */
-int tdb_chainlock(struct tdb_context *tdb, TDB_DATA key)
+_PUBLIC_ int tdb_chainlock(struct tdb_context *tdb, TDB_DATA key)
 {
         int ret = tdb_lock(tdb, BUCKET(tdb->hash_fn(&key)), F_WRLCK);
@@ -498 +714 @@
    to reduce contention - it cannot guarantee how many records will be
    locked */
-int tdb_chainlock_nonblock(struct tdb_context *tdb, TDB_DATA key)
+_PUBLIC_ int tdb_chainlock_nonblock(struct tdb_context *tdb, TDB_DATA key)
 {
         int ret = tdb_lock_nonblock(tdb, BUCKET(tdb->hash_fn(&key)), F_WRLCK);
@@ -506 +722 @@
 
 /* mark a chain as locked without actually locking it. Warning! use with great caution! */
-int tdb_chainlock_mark(struct tdb_context *tdb, TDB_DATA key)
-{
-        int ret = tdb_lock(tdb, BUCKET(tdb->hash_fn(&key)), F_WRLCK | TDB_MARK_LOCK);
+_PUBLIC_ int tdb_chainlock_mark(struct tdb_context *tdb, TDB_DATA key)
+{
+        int ret = tdb_nest_lock(tdb, lock_offset(BUCKET(tdb->hash_fn(&key))),
+                                F_WRLCK, TDB_LOCK_MARK_ONLY);
         tdb_trace_1rec(tdb, "tdb_chainlock_mark", key);
         return ret;
@@ -514 +731 @@
 
 /* unmark a chain as locked without actually locking it. Warning! use with great caution! */
-int tdb_chainlock_unmark(struct tdb_context *tdb, TDB_DATA key)
+_PUBLIC_ int tdb_chainlock_unmark(struct tdb_context *tdb, TDB_DATA key)
 {
         tdb_trace_1rec(tdb, "tdb_chainlock_unmark", key);
-        return tdb_unlock(tdb, BUCKET(tdb->hash_fn(&key)), F_WRLCK | TDB_MARK_LOCK);
-}
-
-int tdb_chainunlock(struct tdb_context *tdb, TDB_DATA key)
+        return tdb_nest_unlock(tdb, lock_offset(BUCKET(tdb->hash_fn(&key))),
+                               F_WRLCK, true);
+}
+
+_PUBLIC_ int tdb_chainunlock(struct tdb_context *tdb, TDB_DATA key)
 {
         tdb_trace_1rec(tdb, "tdb_chainunlock", key);
@@ -526 +744 @@
 }
 
-int tdb_chainlock_read(struct tdb_context *tdb, TDB_DATA key)
+_PUBLIC_ int tdb_chainlock_read(struct tdb_context *tdb, TDB_DATA key)
 {
         int ret;
@@ -534 +752 @@
 }
 
-int tdb_chainunlock_read(struct tdb_context *tdb, TDB_DATA key)
+_PUBLIC_ int tdb_chainunlock_read(struct tdb_context *tdb, TDB_DATA key)
 {
         tdb_trace_1rec(tdb, "tdb_chainunlock_read", key);
@@ -540 +758 @@
 }
 
-
-
 /* record lock stops delete underneath */
 int tdb_lock_record(struct tdb_context *tdb, tdb_off_t off)
 {
-        if (tdb->global_lock.count) {
-                return 0;
-        }
-        return off ? tdb->methods->tdb_brlock(tdb, off, F_RDLCK, F_SETLKW, 0, 1) : 0;
+        if (tdb->allrecord_lock.count) {
+                return 0;
+        }
+        return off ? tdb_brlock(tdb, F_RDLCK, off, 1, TDB_LOCK_WAIT) : 0;
 }
 
@@ -562 +778 @@
                 if (i->off == off)
                         return -1;
-        return tdb->methods->tdb_brlock(tdb, off, F_WRLCK, F_SETLK, 1, 1);
-}
-
-/*
-  Note this is meant to be F_SETLK, *not* F_SETLKW, as it's not
-  an error to fail to get the lock here.
-*/
+        if (tdb->allrecord_lock.count) {
+                if (tdb->allrecord_lock.ltype == F_WRLCK) {
+                        return 0;
+                }
+                return -1;
+        }
+        return tdb_brlock(tdb, F_WRLCK, off, 1, TDB_LOCK_NOWAIT|TDB_LOCK_PROBE);
+}
+
 int tdb_write_unlock_record(struct tdb_context *tdb, tdb_off_t off)
 {
-        return tdb->methods->tdb_brlock(tdb, off, F_UNLCK, F_SETLK, 0, 1);
+        if (tdb->allrecord_lock.count) {
+                return 0;
+        }
+        return tdb_brunlock(tdb, F_WRLCK, off, 1);
 }
 
@@ -580 +801 @@
         uint32_t count = 0;
 
-        if (tdb->global_lock.count) {
+        if (tdb->allrecord_lock.count) {
                 return 0;
         }
@@ -589 +810 @@
                 if (i->off == off)
                         count++;
-        return (count == 1 ? tdb->methods->tdb_brlock(tdb, off, F_UNLCK, F_SETLKW, 0, 1) : 0);
-}
+        return (count == 1 ? tdb_brunlock(tdb, F_RDLCK, off, 1) : 0);
+}
+
+bool tdb_have_extra_locks(struct tdb_context *tdb)
+{
+        unsigned int extra = tdb->num_lockrecs;
+
+        /* A transaction holds the lock for all records. */
+        if (!tdb->transaction && tdb->allrecord_lock.count) {
+                return true;
+        }
+
+        /* We always hold the active lock if CLEAR_IF_FIRST. */
+        if (find_nestlock(tdb, ACTIVE_LOCK)) {
+                extra--;
+        }
+
+        /* In a transaction, we expect to hold the transaction lock */
+        if (tdb->transaction && find_nestlock(tdb, TRANSACTION_LOCK)) {
+                extra--;
+        }
+
+        return extra;
+}
+
+/* The transaction code uses this to remove all locks. */
+void tdb_release_transaction_locks(struct tdb_context *tdb)
+{
+        unsigned int i, active = 0;
+
+        if (tdb->allrecord_lock.count != 0) {
+                tdb_brunlock(tdb, tdb->allrecord_lock.ltype, FREELIST_TOP, 0);
+                tdb->allrecord_lock.count = 0;
+        }
+
+        for (i=0;i<tdb->num_lockrecs;i++) {
+                struct tdb_lock_type *lck = &tdb->lockrecs[i];
+
+                /* Don't release the active lock!  Copy it to first entry. */
+                if (lck->off == ACTIVE_LOCK) {
+                        tdb->lockrecs[active++] = *lck;
+                } else {
+                        tdb_brunlock(tdb, lck->ltype, lck->off, 1);
+                }
+        }
+        tdb->num_lockrecs = active;
+        if (tdb->num_lockrecs == 0) {
+                SAFE_FREE(tdb->lockrecs);
+        }
+}

vendor/current/lib/tdb/common/open.c

@@ -7 +7 @@
    Copyright (C) Paul `Rusty' Russell              2000
    Copyright (C) Jeremy Allison                    2000-2003
-   
+
      ** NOTE! The following LGPL license applies to the tdb
      ** library. This does NOT imply that all of Samba is released
      ** under the LGPL
-   
+
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
@@ -31 +31 @@
 static struct tdb_context *tdbs = NULL;
 
-
-/* This is based on the hash algorithm from gdbm */
-static unsigned int default_tdb_hash(TDB_DATA *key)
-{
-        uint32_t value; /* Used to compute the hash value.  */
-        uint32_t   i;   /* Used to cycle through random values. */
-
-        /* Set the initial value from the key size. */
-        for (value = 0x238F13AF * key->dsize, i=0; i < key->dsize; i++)
-                value = (value + (key->dptr[i] << (i*5 % 24)));
-
-        return (1103515243 * value + 12345);  
-}
-
+/* We use two hashes to double-check they're using the right hash function. */
+void tdb_header_hash(struct tdb_context *tdb,
+                     uint32_t *magic1_hash, uint32_t *magic2_hash)
+{
+        TDB_DATA hash_key;
+        uint32_t tdb_magic = TDB_MAGIC;
+
+        hash_key.dptr = discard_const_p(unsigned char, TDB_MAGIC_FOOD);
+        hash_key.dsize = sizeof(TDB_MAGIC_FOOD);
+        *magic1_hash = tdb->hash_fn(&hash_key);
+
+        hash_key.dptr = (unsigned char *)CONVERT(tdb_magic);
+        hash_key.dsize = sizeof(tdb_magic);
+        *magic2_hash = tdb->hash_fn(&hash_key);
+
+        /* Make sure at least one hash is non-zero! */
+        if (*magic1_hash == 0 && *magic2_hash == 0)
+                *magic1_hash = 1;
+}
 
 /* initialise a new database with a specified hash size */
@@ -52 +57 @@
         size_t size;
         int ret = -1;
-        ssize_t written;
 
         /* We make it up in memory, then write it out if not internal */
@@ -64 +68 @@
         newdb->version = TDB_VERSION;
         newdb->hash_size = hash_size;
+
+        tdb_header_hash(tdb, &newdb->magic1_hash, &newdb->magic2_hash);
+
+        /* Make sure older tdbs (which don't check the magic hash fields)
+         * will refuse to open this TDB. */
+        if (tdb->flags & TDB_INCOMPATIBLE_HASH)
+                newdb->rwlocks = TDB_HASH_RWLOCK_MAGIC;
+
         if (tdb->flags & TDB_INTERNAL) {
                 tdb->map_size = size;
@@ -84 +96 @@
         memcpy(newdb->magic_food, TDB_MAGIC_FOOD, strlen(TDB_MAGIC_FOOD)+1);
         /* we still have "ret == -1" here */
-        written = write(tdb->fd, newdb, size);
-        if (written == size) {
+        if (tdb_write_all(tdb->fd, newdb, size))
                 ret = 0;
-        } else if (written != -1) {
-                /* call write once again, this usually should return -1 and
-                 * set errno appropriately */
-                size -= written;
-                written = write(tdb->fd, newdb+written, size);
-                if (written == size) {
-                ret = 0;
-                } else if (written >= 0) {
-                        /* a second incomplete write - we give up.
-                         * guessing the errno... */
-                        errno = ENOSPC;
-                }
-        }
 
   fail:
@@ -112 +110 @@
 {
         struct tdb_context *i;
-        
+
         for (i = tdbs; i; i = i->next) {
                 if (i->device == device && i->inode == ino) {
@@ -132 +130 @@
 
    @param name may be NULL for internal databases. */
-struct tdb_context *tdb_open(const char *name, int hash_size, int tdb_flags,
+_PUBLIC_ struct tdb_context *tdb_open(const char *name, int hash_size, int tdb_flags,
                       int open_flags, mode_t mode)
 {
@@ -144 +142 @@
 }
 
-
-struct tdb_context *tdb_open_ex(const char *name, int hash_size, int tdb_flags,
+static bool check_header_hash(struct tdb_context *tdb,
+                              bool default_hash, uint32_t *m1, uint32_t *m2)
+{
+        tdb_header_hash(tdb, m1, m2);
+        if (tdb->header.magic1_hash == *m1 &&
+            tdb->header.magic2_hash == *m2) {
+                return true;
+        }
+
+        /* If they explicitly set a hash, always respect it. */
+        if (!default_hash)
+                return false;
+
+        /* Otherwise, try the other inbuilt hash. */
+        if (tdb->hash_fn == tdb_old_hash)
+                tdb->hash_fn = tdb_jenkins_hash;
+        else
+                tdb->hash_fn = tdb_old_hash;
+        return check_header_hash(tdb, false, m1, m2);
+}
+
+_PUBLIC_ struct tdb_context *tdb_open_ex(const char *name, int hash_size, int tdb_flags,
                                 int open_flags, mode_t mode,
                                 const struct tdb_logging_context *log_ctx,
@@ -156 +174 @@
         uint32_t vertest;
         unsigned v;
+        const char *hash_alg;
+        uint32_t magic1, magic2;
 
         if (!(tdb = (struct tdb_context *)calloc(1, sizeof *tdb))) {
@@ -177 +197 @@
                 tdb->log.log_private = NULL;
         }
-        tdb->hash_fn = hash_fn ? hash_fn : default_tdb_hash;
+
+        if (name == NULL && (tdb_flags & TDB_INTERNAL)) {
+                name = "__TDB_INTERNAL__";
+        }
+
+        if (name == NULL) {
+                tdb->name = discard_const_p(char, "__NULL__");
+                TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_open_ex: called with name == NULL\n"));
+                tdb->name = NULL;
+                errno = EINVAL;
+                goto fail;
+        }
+
+        /* now make a copy of the name, as the caller memory might went away */
+        if (!(tdb->name = (char *)strdup(name))) {
+                /*
+                 * set the name as the given string, so that tdb_name() will
+                 * work in case of an error.
+                 */
+                tdb->name = discard_const_p(char, name);
+                TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_open_ex: can't strdup(%s)\n",
+                         name));
+                tdb->name = NULL;
+                errno = ENOMEM;
+                goto fail;
+        }
+
+        if (hash_fn) {
+                tdb->hash_fn = hash_fn;
+                hash_alg = "the user defined";
+        } else {
+                /* This controls what we use when creating a tdb. */
+                if (tdb->flags & TDB_INCOMPATIBLE_HASH) {
+                        tdb->hash_fn = tdb_jenkins_hash;
+                } else {
+                        tdb->hash_fn = tdb_old_hash;
+                }
+                hash_alg = "either default";
+        }
 
         /* cache the page size */
@@ -193 +251 @@
                 goto fail;
         }
-        
+
         if (hash_size == 0)
                 hash_size = DEFAULT_HASH_SIZE;
@@ -212 +270 @@
         }
 
+        if (getenv("TDB_NO_FSYNC")) {
+                tdb->flags |= TDB_NOSYNC;
+        }
+
         /*
          * TDB_ALLOW_NESTING is the default behavior.
@@ -242 +304 @@
 
         /* ensure there is only one process initialising at once */
-        if (tdb->methods->tdb_brlock(tdb, GLOBAL_LOCK, F_WRLCK, F_SETLKW, 0, 1) == -1) {
-                TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_open_ex: failed to get global lock on %s: %s\n",
+        if (tdb_nest_lock(tdb, OPEN_LOCK, F_WRLCK, TDB_LOCK_WAIT) == -1) {
+                TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_open_ex: failed to get open lock on %s: %s\n",
                          name, strerror(errno)));
                 goto fail;      /* errno set by tdb_brlock */
@@ -251 +313 @@
         if ((tdb_flags & TDB_CLEAR_IF_FIRST) &&
             (!tdb->read_only) &&
-            (locked = (tdb->methods->tdb_brlock(tdb, ACTIVE_LOCK, F_WRLCK, F_SETLK, 0, 1) == 0))) {
+            (locked = (tdb_nest_lock(tdb, ACTIVE_LOCK, F_WRLCK, TDB_LOCK_NOWAIT|TDB_LOCK_PROBE) == 0))) {
                 open_flags |= O_CREAT;
                 if (ftruncate(tdb->fd, 0) == -1) {
@@ -290 +352 @@
                 goto fail;
 
-        if (tdb->header.rwlocks != 0) {
+        if (tdb->header.rwlocks != 0 &&
+            tdb->header.rwlocks != TDB_HASH_RWLOCK_MAGIC) {
                 TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_open_ex: spinlocks no longer supported\n"));
+                goto fail;
+        }
+
+        if ((tdb->header.magic1_hash == 0) && (tdb->header.magic2_hash == 0)) {
+                /* older TDB without magic hash references */
+                tdb->hash_fn = tdb_old_hash;
+        } else if (!check_header_hash(tdb, !hash_fn, &magic1, &magic2)) {
+                TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_open_ex: "
+                         "%s was not created with %s hash function we are using\n"
+                         "magic1_hash[0x%08X %s 0x%08X] "
+                         "magic2_hash[0x%08X %s 0x%08X]\n",
+                         name, hash_alg,
+                         tdb->header.magic1_hash,
+                         (tdb->header.magic1_hash == magic1) ? "==" : "!=",
+                         magic1,
+                         tdb->header.magic2_hash,
+                         (tdb->header.magic2_hash == magic2) ? "==" : "!=",
+                         magic2));
+                errno = EINVAL;
                 goto fail;
         }
@@ -304 +386 @@
         }
 
-        if (!(tdb->name = (char *)strdup(name))) {
-                errno = ENOMEM;
-                goto fail;
-        }
-
         tdb->map_size = st.st_size;
         tdb->device = st.st_dev;
@@ -314 +391 @@
         tdb_mmap(tdb);
         if (locked) {
-                if (tdb->methods->tdb_brlock(tdb, ACTIVE_LOCK, F_UNLCK, F_SETLK, 0, 1) == -1) {
+                if (tdb_nest_unlock(tdb, ACTIVE_LOCK, F_WRLCK, false) == -1) {
                         TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_open_ex: "
-                                 "failed to take ACTIVE_LOCK on %s: %s\n",
+                                 "failed to release ACTIVE_LOCK on %s: %s\n",
                                  name, strerror(errno)));
                         goto fail;
@@ -329 +406 @@
         if (tdb_flags & TDB_CLEAR_IF_FIRST) {
                 /* leave this lock in place to indicate it's in use */
-                if (tdb->methods->tdb_brlock(tdb, ACTIVE_LOCK, F_RDLCK, F_SETLKW, 0, 1) == -1)
+                if (tdb_nest_lock(tdb, ACTIVE_LOCK, F_RDLCK, TDB_LOCK_WAIT) == -1) {
                         goto fail;
+                }
         }
 
@@ -357 +435 @@
         /* Internal (memory-only) databases skip all the code above to
          * do with disk files, and resume here by releasing their
-         * global lock and hooking into the active list. */
-        if (tdb->methods->tdb_brlock(tdb, GLOBAL_LOCK, F_UNLCK, F_SETLKW, 0, 1) == -1)
-                goto fail;
+         * open lock and hooking into the active list. */
+        if (tdb_nest_unlock(tdb, OPEN_LOCK, F_WRLCK, false) == -1) {
+                goto fail;
+        }
         tdb->next = tdbs;
         tdbs = tdb;
@@ -379 +458 @@
                         tdb_munmap(tdb);
         }
-        SAFE_FREE(tdb->name);
         if (tdb->fd != -1)
                 if (close(tdb->fd) != 0)
                         TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_open_ex: failed to close tdb->fd on error!\n"));
+        SAFE_FREE(tdb->lockrecs);
+        SAFE_FREE(tdb->name);
         SAFE_FREE(tdb);
         errno = save_errno;
@@ -393 +473 @@
  */
 
-void tdb_set_max_dead(struct tdb_context *tdb, int max_dead)
+_PUBLIC_ void tdb_set_max_dead(struct tdb_context *tdb, int max_dead)
 {
         tdb->max_dead_records = max_dead;
@@ -403 +483 @@
  * @returns -1 for error; 0 for success.
  **/
-int tdb_close(struct tdb_context *tdb)
+_PUBLIC_ int tdb_close(struct tdb_context *tdb)
 {
         struct tdb_context **i;
         int ret = 0;
 
+        if (tdb->transaction) {
+                tdb_transaction_cancel(tdb);
+        }
         tdb_trace(tdb, "tdb_close");
-        if (tdb->transaction) {
-                _tdb_transaction_cancel(tdb);
-        }
 
         if (tdb->map_ptr) {
@@ -444 +524 @@
 
 /* register a loging function */
-void tdb_set_logging_function(struct tdb_context *tdb,
-                              const struct tdb_logging_context *log_ctx)
+_PUBLIC_ void tdb_set_logging_function(struct tdb_context *tdb,
+                                       const struct tdb_logging_context *log_ctx)
 {
         tdb->log = *log_ctx;
 }
 
-void *tdb_get_logging_private(struct tdb_context *tdb)
+_PUBLIC_ void *tdb_get_logging_private(struct tdb_context *tdb)
 {
         return tdb->log.log_private;
@@ -466 +546 @@
         }
 
-        if (tdb->num_locks != 0 || tdb->global_lock.count) {
+        if (tdb_have_extra_locks(tdb)) {
                 TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_reopen: reopen not allowed with locks held\n"));
                 goto fail;
@@ -501 +581 @@
 #endif /* fake pread or pwrite */
 
-        if (active_lock &&
-            (tdb->methods->tdb_brlock(tdb, ACTIVE_LOCK, F_RDLCK, F_SETLKW, 0, 1) == -1)) {
+        /* We may still think we hold the active lock. */
+        tdb->num_lockrecs = 0;
+        SAFE_FREE(tdb->lockrecs);
+
+        if (active_lock && tdb_nest_lock(tdb, ACTIVE_LOCK, F_RDLCK, TDB_LOCK_WAIT) == -1) {
                 TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_reopen: failed to obtain active lock\n"));
                 goto fail;
@@ -516 +599 @@
 /* reopen a tdb - this can be used after a fork to ensure that we have an independent
    seek pointer from our parent and to re-establish locks */
-int tdb_reopen(struct tdb_context *tdb)
+_PUBLIC_ int tdb_reopen(struct tdb_context *tdb)
 {
         return tdb_reopen_internal(tdb, tdb->flags & TDB_CLEAR_IF_FIRST);
@@ -522 +605 @@
 
 /* reopen all tdb's */
-int tdb_reopen_all(int parent_longlived)
+_PUBLIC_ int tdb_reopen_all(int parent_longlived)
 {
         struct tdb_context *tdb;

vendor/current/lib/tdb/common/tdb.c

@@ -7 +7 @@
    Copyright (C) Paul `Rusty' Russell              2000
    Copyright (C) Jeremy Allison                    2000-2003
-   
+
      ** NOTE! The following LGPL license applies to the tdb
      ** library. This does NOT imply that all of Samba is released
      ** under the LGPL
-   
+
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
@@ -28 +28 @@
 #include "tdb_private.h"
 
-TDB_DATA tdb_null;
+_PUBLIC_ TDB_DATA tdb_null;
 
 /*
@@ -34 +34 @@
   the TDB_SEQNUM flag
 */
-void tdb_increment_seqnum_nonblock(struct tdb_context *tdb)
+_PUBLIC_ void tdb_increment_seqnum_nonblock(struct tdb_context *tdb)
 {
         tdb_off_t seqnum=0;
-        
+
         if (!(tdb->flags & TDB_SEQNUM)) {
                 return;
@@ -60 +60 @@
         }
 
-        if (tdb_brlock(tdb, TDB_SEQNUM_OFS, F_WRLCK, F_SETLKW, 1, 1) != 0) {
+        if (tdb_nest_lock(tdb, TDB_SEQNUM_OFS, F_WRLCK,
+                          TDB_LOCK_WAIT|TDB_LOCK_PROBE) != 0) {
                 return;
         }
@@ -66 +67 @@
         tdb_increment_seqnum_nonblock(tdb);
 
-        tdb_brlock(tdb, TDB_SEQNUM_OFS, F_UNLCK, F_SETLKW, 1, 1);
+        tdb_nest_unlock(tdb, TDB_SEQNUM_OFS, F_WRLCK, false);
 }
 
@@ -80 +81 @@
 {
         tdb_off_t rec_ptr;
-        
+
         /* read in the hash top */
         if (tdb_ofs_read(tdb, TDB_HASH_TOP(hash), &rec_ptr) == -1)
@@ -154 +155 @@
                 }
         }
-         
 
         /* must be long enough key, data and tailer */
@@ -171 +171 @@
                 return tdb_rec_write(tdb, rec_ptr, &rec);
         }
- 
+
         return 0;
 }
@@ -200 +200 @@
 }
 
-TDB_DATA tdb_fetch(struct tdb_context *tdb, TDB_DATA key)
+_PUBLIC_ TDB_DATA tdb_fetch(struct tdb_context *tdb, TDB_DATA key)
 {
         TDB_DATA ret = _tdb_fetch(tdb, key);
@@ -213 +213 @@
  * should be fast and should not block on other syscalls.
  *
- * DONT CALL OTHER TDB CALLS FROM THE PARSER, THIS MIGHT LEAD TO SEGFAULTS.
+ * DON'T CALL OTHER TDB CALLS FROM THE PARSER, THIS MIGHT LEAD TO SEGFAULTS.
  *
  * For mmapped tdb's that do not have a transaction open it points the parsing
@@ -222 +222 @@
  * This is interesting for all readers of potentially large data structures in
  * the tdb records, ldb indexes being one example.
+ *
+ * Return -1 if the record was not found.
  */
 
-int tdb_parse_record(struct tdb_context *tdb, TDB_DATA key,
+_PUBLIC_ int tdb_parse_record(struct tdb_context *tdb, TDB_DATA key,
                      int (*parser)(TDB_DATA key, TDB_DATA data,
                                    void *private_data),
@@ -238 +240 @@
 
         if (!(rec_ptr = tdb_find_lock_hash(tdb,key,hash,F_RDLCK,&rec))) {
+                /* record not found */
                 tdb_trace_1rec_ret(tdb, "tdb_parse_record", key, -1);
                 tdb->ecode = TDB_ERR_NOEXIST;
-                return 0;
+                return -1;
         }
         tdb_trace_1rec_ret(tdb, "tdb_parse_record", key, 0);
@@ -261 +264 @@
 {
         struct tdb_record rec;
-        
+
         if (tdb_find_lock_hash(tdb, key, hash, F_RDLCK, &rec) == 0)
                 return 0;
@@ -268 +271 @@
 }
 
-int tdb_exists(struct tdb_context *tdb, TDB_DATA key)
+_PUBLIC_ int tdb_exists(struct tdb_context *tdb, TDB_DATA key)
 {
         uint32_t hash = tdb->hash_fn(&key);
@@ -319 +322 @@
         tdb_off_t rec_ptr;
         struct tdb_record rec;
-        
+
         /* read in the hash top */
         if (tdb_ofs_read(tdb, TDB_HASH_TOP(hash), &rec_ptr) == -1)
@@ -348 +351 @@
                 return -1;
         }
-        
+
         /* read in the hash top */
         if (tdb_ofs_read(tdb, TDB_HASH_TOP(hash), &rec_ptr) == -1)
@@ -427 +430 @@
 }
 
-int tdb_delete(struct tdb_context *tdb, TDB_DATA key)
+_PUBLIC_ int tdb_delete(struct tdb_context *tdb, TDB_DATA key)
 {
         uint32_t hash = tdb->hash_fn(&key);
@@ -444 +447 @@
 {
         tdb_off_t rec_ptr;
-        
+
         /* read in the hash top */
         if (tdb_ofs_read(tdb, TDB_HASH_TOP(hash), &rec_ptr) == -1)
@@ -597 +600 @@
    return 0 on success, -1 on failure
 */
-int tdb_store(struct tdb_context *tdb, TDB_DATA key, TDB_DATA dbuf, int flag)
+_PUBLIC_ int tdb_store(struct tdb_context *tdb, TDB_DATA key, TDB_DATA dbuf, int flag)
 {
         uint32_t hash;
@@ -620 +623 @@
 
 /* Append to an entry. Create if not exist. */
-int tdb_append(struct tdb_context *tdb, TDB_DATA key, TDB_DATA new_dbuf)
+_PUBLIC_ int tdb_append(struct tdb_context *tdb, TDB_DATA key, TDB_DATA new_dbuf)
 {
         uint32_t hash;
@@ -659 +662 @@
         ret = _tdb_store(tdb, key, dbuf, 0, hash);
         tdb_trace_2rec_retrec(tdb, "tdb_append", key, new_dbuf, dbuf);
-        
+
 failed:
         tdb_unlock(tdb, BUCKET(hash), F_WRLCK);
@@ -671 +674 @@
   useful for external logging functions
 */
-const char *tdb_name(struct tdb_context *tdb)
+_PUBLIC_ const char *tdb_name(struct tdb_context *tdb)
 {
         return tdb->name;
@@ -681 +684 @@
   of the fd
 */
-int tdb_fd(struct tdb_context *tdb)
+_PUBLIC_ int tdb_fd(struct tdb_context *tdb)
 {
         return tdb->fd;
@@ -690 +693 @@
   useful for external tdb routines that wish to log tdb errors
 */
-tdb_log_func tdb_log_fn(struct tdb_context *tdb)
+_PUBLIC_ tdb_log_func tdb_log_fn(struct tdb_context *tdb)
 {
         return tdb->log.log_fn;
@@ -706 +709 @@
   test of a possible tdb change.
 */
-int tdb_get_seqnum(struct tdb_context *tdb)
+_PUBLIC_ int tdb_get_seqnum(struct tdb_context *tdb)
 {
         tdb_off_t seqnum=0;
@@ -714 +717 @@
 }
 
-int tdb_hash_size(struct tdb_context *tdb)
+_PUBLIC_ int tdb_hash_size(struct tdb_context *tdb)
 {
         return tdb->header.hash_size;
 }
 
-size_t tdb_map_size(struct tdb_context *tdb)
+_PUBLIC_ size_t tdb_map_size(struct tdb_context *tdb)
 {
         return tdb->map_size;
 }
 
-int tdb_get_flags(struct tdb_context *tdb)
+_PUBLIC_ int tdb_get_flags(struct tdb_context *tdb)
 {
         return tdb->flags;
 }
 
-void tdb_add_flags(struct tdb_context *tdb, unsigned flags)
+_PUBLIC_ void tdb_add_flags(struct tdb_context *tdb, unsigned flags)
 {
         if ((flags & TDB_ALLOW_NESTING) &&
@@ -749 +752 @@
 }
 
-void tdb_remove_flags(struct tdb_context *tdb, unsigned flags)
+_PUBLIC_ void tdb_remove_flags(struct tdb_context *tdb, unsigned flags)
 {
         if ((flags & TDB_ALLOW_NESTING) &&
@@ -773 +776 @@
   enable sequence number handling on an open tdb
 */
-void tdb_enable_seqnum(struct tdb_context *tdb)
+_PUBLIC_ void tdb_enable_seqnum(struct tdb_context *tdb)
 {
         tdb->flags |= TDB_SEQNUM;
@@ -805 +808 @@
 /*
   wipe the entire database, deleting all records. This can be done
-  very fast by using a global lock. The entire data portion of the
+  very fast by using a allrecord lock. The entire data portion of the
   file becomes a single entry in the freelist.
 
   This code carefully steps around the recovery area, leaving it alone
  */
-int tdb_wipe_all(struct tdb_context *tdb)
+_PUBLIC_ int tdb_wipe_all(struct tdb_context *tdb)
 {
         int i;
@@ -917 +920 @@
   repack a tdb
  */
-int tdb_repack(struct tdb_context *tdb)
+_PUBLIC_ int tdb_repack(struct tdb_context *tdb)
 {
         struct tdb_context *tmp_db;
@@ -987 +990 @@
 }
 
+/* Even on files, we can get partial writes due to signals. */
+bool tdb_write_all(int fd, const void *buf, size_t count)
+{
+        while (count) {
+                ssize_t ret;
+                ret = write(fd, buf, count);
+                if (ret < 0)
+                        return false;
+                buf = (const char *)buf + ret;
+                count -= ret;
+        }
+        return true;
+}
+
 #ifdef TDB_TRACE
 static void tdb_trace_write(struct tdb_context *tdb, const char *str)
 {
-        if (write(tdb->tracefd, str, strlen(str)) != strlen(str)) {
+        if (!tdb_write_alltdb->tracefd, str, strlen(str)) {
                 close(tdb->tracefd);
                 tdb->tracefd = -1;

vendor/current/lib/tdb/common/tdb_private.h

@@ -5 +5 @@
 
    Copyright (C) Andrew Tridgell              2005
-   
+
      ** NOTE! The following LGPL license applies to the tdb
      ** library. This does NOT imply that all of Samba is released
      ** under the LGPL
-   
+
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
@@ -50 +50 @@
 #define TDB_DEAD_MAGIC (0xFEE1DEAD)
 #define TDB_RECOVERY_MAGIC (0xf53bc0e7U)
+#define TDB_RECOVERY_INVALID_MAGIC (0x0)
+#define TDB_HASH_RWLOCK_MAGIC (0xbad1a51U)
 #define TDB_ALIGNMENT 4
 #define DEFAULT_HASH_SIZE 131
@@ -102 +104 @@
 
 /* lock offsets */
-#define GLOBAL_LOCK      0
+#define OPEN_LOCK        0
 #define ACTIVE_LOCK      4
 #define TRANSACTION_LOCK 8
@@ -147 +149 @@
         tdb_off_t recovery_start; /* offset of transaction recovery region */
         tdb_off_t sequence_number; /* used when TDB_SEQNUM is set */
-        tdb_off_t reserved[29];
+        uint32_t magic1_hash; /* hash of TDB_MAGIC_FOOD. */
+        uint32_t magic2_hash; /* hash of TDB_MAGIC. */
+        tdb_off_t reserved[27];
 };
 
 struct tdb_lock_type {
-        int list;
+        uint32_t off;
         uint32_t count;
         uint32_t ltype;
@@ -163 +167 @@
 };
 
+enum tdb_lock_flags {
+        /* WAIT == F_SETLKW, NOWAIT == F_SETLK */
+        TDB_LOCK_NOWAIT = 0,
+        TDB_LOCK_WAIT = 1,
+        /* If set, don't log an error on failure. */
+        TDB_LOCK_PROBE = 2,
+        /* If set, don't actually lock at all. */
+        TDB_LOCK_MARK_ONLY = 4,
+};
 
 struct tdb_methods {
@@ -170 +183 @@
         int (*tdb_oob)(struct tdb_context *, tdb_off_t , int );
         int (*tdb_expand_file)(struct tdb_context *, tdb_off_t , tdb_off_t );
-        int (*tdb_brlock)(struct tdb_context *, tdb_off_t , int, int, int, size_t);
 };
 
@@ -181 +193 @@
         int traverse_read; /* read-only traversal */
         int traverse_write; /* read-write traversal */
-        struct tdb_lock_type global_lock;
+        struct tdb_lock_type allrecord_lock; /* .offset == upgradable */
         int num_lockrecs;
         struct tdb_lock_type *lockrecs; /* only real locks, all with count>0 */
@@ -194 +206 @@
         unsigned int (*hash_fn)(TDB_DATA *key);
         int open_flags; /* flags used in the open - needed by reopen */
-        unsigned int num_locks; /* number of chain locks held */
         const struct tdb_methods *methods;
         struct tdb_transaction *transaction;
         int page_size;
         int max_dead_records;
-        int transaction_lock_count;
 #ifdef TDB_TRACE
         int tracefd;
@@ -214 +224 @@
 int tdb_lock(struct tdb_context *tdb, int list, int ltype);
 int tdb_lock_nonblock(struct tdb_context *tdb, int list, int ltype);
+int tdb_nest_lock(struct tdb_context *tdb, uint32_t offset, int ltype,
+                  enum tdb_lock_flags flags);
+int tdb_nest_unlock(struct tdb_context *tdb, uint32_t offset, int ltype,
+                    bool mark_lock);
 int tdb_unlock(struct tdb_context *tdb, int list, int ltype);
-int tdb_brlock(struct tdb_context *tdb, tdb_off_t offset, int rw_type, int lck_type, int probe, size_t len);
-int tdb_transaction_lock(struct tdb_context *tdb, int ltype);
-int tdb_transaction_unlock(struct tdb_context *tdb);
-int tdb_brlock_upgrade(struct tdb_context *tdb, tdb_off_t offset, size_t len);
+int tdb_brlock(struct tdb_context *tdb,
+               int rw_type, tdb_off_t offset, size_t len,
+               enum tdb_lock_flags flags);
+int tdb_brunlock(struct tdb_context *tdb,
+                 int rw_type, tdb_off_t offset, size_t len);
+bool tdb_have_extra_locks(struct tdb_context *tdb);
+void tdb_release_transaction_locks(struct tdb_context *tdb);
+int tdb_transaction_lock(struct tdb_context *tdb, int ltype,
+                         enum tdb_lock_flags lockflags);
+int tdb_transaction_unlock(struct tdb_context *tdb, int ltype);
+int tdb_recovery_area(struct tdb_context *tdb,
+                      const struct tdb_methods *methods,
+                      tdb_off_t *recovery_offset,
+                      struct tdb_record *rec);
+int tdb_allrecord_lock(struct tdb_context *tdb, int ltype,
+                       enum tdb_lock_flags flags, bool upgradable);
+int tdb_allrecord_unlock(struct tdb_context *tdb, int ltype, bool mark_lock);
+int tdb_allrecord_upgrade(struct tdb_context *tdb);
 int tdb_write_lock_record(struct tdb_context *tdb, tdb_off_t off);
 int tdb_write_unlock_record(struct tdb_context *tdb, tdb_off_t off);
@@ -230 +258 @@
 int tdb_lock_record(struct tdb_context *tdb, tdb_off_t off);
 int tdb_unlock_record(struct tdb_context *tdb, tdb_off_t off);
-int _tdb_transaction_cancel(struct tdb_context *tdb);
+bool tdb_needs_recovery(struct tdb_context *tdb);
 int tdb_rec_read(struct tdb_context *tdb, tdb_off_t offset, struct tdb_record *rec);
 int tdb_rec_write(struct tdb_context *tdb, tdb_off_t offset, struct tdb_record *rec);
@@ -246 +274 @@
 int tdb_rec_free_read(struct tdb_context *tdb, tdb_off_t off,
                       struct tdb_record *rec);
-
-
+bool tdb_write_all(int fd, const void *buf, size_t count);
+int tdb_transaction_recover(struct tdb_context *tdb);
+void tdb_header_hash(struct tdb_context *tdb,
+                     uint32_t *magic1_hash, uint32_t *magic2_hash);
+unsigned int tdb_old_hash(TDB_DATA *key);
+size_t tdb_dead_space(struct tdb_context *tdb, tdb_off_t off);

vendor/current/lib/tdb/common/transaction.c

@@ -9 +9 @@
      ** library. This does NOT imply that all of Samba is released
      ** under the LGPL
-   
+
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
@@ -60 +60 @@
     existing transaction record. If the inner transaction is cancelled
     then a subsequent commit will fail
- 
+
   - keep a mirrored copy of the tdb hash chain heads to allow for the
     fast hash heads scan on traverse, updating the mirrored copy in
@@ -77 +77 @@
 
   - check for a valid recovery record on open of the tdb, while the
-    global lock is held. Automatically recover from the transaction
+    open lock is held. Automatically recover from the transaction
     recovery area if needed, then continue with the open as
     usual. This allows for smooth crash recovery with no administrator
@@ -136 +136 @@
         tdb_off_t magic_offset;
 
-        /* set when the GLOBAL_LOCK has been taken */
-        bool global_lock_taken;
-
         /* old file size before transaction */
         tdb_len_t old_map_size;
 
-        /* we should re-pack on commit */
-        bool need_repack;
+        /* did we expand in this transaction */
+        bool expanded;
 };
 
@@ -189 +186 @@
                 }
         }
-        
+
         /* now copy it out of this block */
         memcpy(buf, tdb->transaction->blocks[blk] + (off % tdb->transaction->block_size), len);
@@ -296 +293 @@
                 }
         }
-        
+
         /* overwrite part of an existing block */
         if (buf == NULL) {
@@ -407 +404 @@
         }
 
-        tdb->transaction->need_repack = true;
-
-        return 0;
-}
-
-/*
-  brlock during a transaction - ignore them
-*/
-static int transaction_brlock(struct tdb_context *tdb, tdb_off_t offset, 
-                              int rw_type, int lck_type, int probe, size_t len)
-{
+        tdb->transaction->expanded = true;
+
         return 0;
 }
@@ -427 +415 @@
         transaction_oob,
         transaction_expand_file,
-        transaction_brlock
 };
 
@@ -435 +422 @@
   transaction is allowed to be pending per tdb_context
 */
-int tdb_transaction_start(struct tdb_context *tdb)
+static int _tdb_transaction_start(struct tdb_context *tdb,
+                                  enum tdb_lock_flags lockflags)
 {
         /* some sanity checks */
@@ -456 +444 @@
         }
 
-        if (tdb->num_locks != 0 || tdb->global_lock.count) {
+        if (tdb_have_extra_locks(tdb)) {
                 /* the caller must not have any locks when starting a
                    transaction as otherwise we'll be screwed by lack
@@ -487 +475 @@
            discussed with Volker, there are a number of ways we could
            make this async, which we will probably do in the future */
-        if (tdb_transaction_lock(tdb, F_WRLCK) == -1) {
+        if (tdb_transaction_lock(tdb, F_WRLCK, lockflags) == -1) {
                 SAFE_FREE(tdb->transaction->blocks);
                 SAFE_FREE(tdb->transaction);
-                return -1;
-        }
-        
+                if ((lockflags & TDB_LOCK_WAIT) == 0) {
+                        tdb->ecode = TDB_ERR_NOLOCK;
+                }
+                return -1;
+        }
+
         /* get a read lock from the freelist to the end of file. This
            is upgraded to a write lock during the commit */
-        if (tdb_brlock(tdb, FREELIST_TOP, F_RDLCK, F_SETLKW, 0, 0) == -1) {
+        if (tdb_allrecord_lock(tdb, F_RDLCK, TDB_LOCK_WAIT, true) == -1) {
                 TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_transaction_start: failed to get hash locks\n"));
-                tdb->ecode = TDB_ERR_LOCK;
-                goto fail;
+                goto fail_allrecord_lock;
         }
 
@@ -529 +519 @@
         tdb_trace(tdb, "tdb_transaction_start");
         return 0;
-        
+
 fail:
-        tdb_brlock(tdb, FREELIST_TOP, F_UNLCK, F_SETLKW, 0, 0);
-        tdb_transaction_unlock(tdb);
+        tdb_allrecord_unlock(tdb, F_RDLCK, false);
+fail_allrecord_lock:
+        tdb_transaction_unlock(tdb, F_WRLCK);
         SAFE_FREE(tdb->transaction->blocks);
         SAFE_FREE(tdb->transaction->hash_heads);
@@ -539 +530 @@
 }
 
+_PUBLIC_ int tdb_transaction_start(struct tdb_context *tdb)
+{
+        return _tdb_transaction_start(tdb, TDB_LOCK_WAIT);
+}
+
+_PUBLIC_ int tdb_transaction_start_nonblock(struct tdb_context *tdb)
+{
+        return _tdb_transaction_start(tdb, TDB_LOCK_NOWAIT|TDB_LOCK_PROBE);
+}
 
 /*
@@ -549 +549 @@
         }
 
+#ifdef HAVE_FDATASYNC
+        if (fdatasync(tdb->fd) != 0) {
+#else
         if (fsync(tdb->fd) != 0) {
+#endif
                 tdb->ecode = TDB_ERR_IO;
                 TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_transaction: fsync failed\n"));
@@ -570 +574 @@
 
 
-int _tdb_transaction_cancel(struct tdb_context *tdb)
+static int _tdb_transaction_cancel(struct tdb_context *tdb)
 {       
         int i, ret = 0;
@@ -597 +601 @@
         if (tdb->transaction->magic_offset) {
                 const struct tdb_methods *methods = tdb->transaction->io_methods;
-                uint32_t zero = 0;
+                const uint32_t invalid = TDB_RECOVERY_INVALID_MAGIC;
 
                 /* remove the recovery marker */
-                if (methods->tdb_write(tdb, tdb->transaction->magic_offset, &zero, 4) == -1 ||
+                if (methods->tdb_write(tdb, tdb->transaction->magic_offset, &invalid, 4) == -1 ||
                 transaction_sync(tdb, tdb->transaction->magic_offset, 4) == -1) {
                         TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_transaction_cancel: failed to remove recovery magic\n"));
@@ -607 +611 @@
         }
 
-        if (tdb->transaction->global_lock_taken) {
-                tdb_brlock(tdb, GLOBAL_LOCK, F_UNLCK, F_SETLKW, 0, 1);
-                tdb->transaction->global_lock_taken = false;
-        }
-
-        /* remove any global lock created during the transaction */
-        if (tdb->global_lock.count != 0) {
-                tdb_brlock(tdb, FREELIST_TOP, F_UNLCK, F_SETLKW, 0, 4*tdb->header.hash_size);
-                tdb->global_lock.count = 0;
-        }
-
-        /* remove any locks created during the transaction */
-        if (tdb->num_locks != 0) {
-                for (i=0;i<tdb->num_lockrecs;i++) {
-                        tdb_brlock(tdb,FREELIST_TOP+4*tdb->lockrecs[i].list,
-                                   F_UNLCK,F_SETLKW, 0, 1);
-                }
-                tdb->num_locks = 0;
-                tdb->num_lockrecs = 0;
-                SAFE_FREE(tdb->lockrecs);
-        }
+        /* This also removes the OPEN_LOCK, if we have it. */
+        tdb_release_transaction_locks(tdb);
 
         /* restore the normal io methods */
         tdb->methods = tdb->transaction->io_methods;
 
-        tdb_brlock(tdb, FREELIST_TOP, F_UNLCK, F_SETLKW, 0, 0);
-        tdb_transaction_unlock(tdb);
         SAFE_FREE(tdb->transaction->hash_heads);
         SAFE_FREE(tdb->transaction);
-        
+
         return ret;
 }
@@ -643 +626 @@
   cancel the current transaction
 */
-int tdb_transaction_cancel(struct tdb_context *tdb)
+_PUBLIC_ int tdb_transaction_cancel(struct tdb_context *tdb)
 {
         tdb_trace(tdb, "tdb_transaction_cancel");
@@ -676 +659 @@
 }
 
+int tdb_recovery_area(struct tdb_context *tdb,
+                      const struct tdb_methods *methods,
+                      tdb_off_t *recovery_offset,
+                      struct tdb_record *rec)
+{
+        if (tdb_ofs_read(tdb, TDB_RECOVERY_HEAD, recovery_offset) == -1) {
+                return -1;
+        }
+
+        if (*recovery_offset == 0) {
+                rec->rec_len = 0;
+                return 0;
+        }
+
+        if (methods->tdb_read(tdb, *recovery_offset, rec, sizeof(*rec),
+                              DOCONV()) == -1) {
+                return -1;
+        }
+
+        /* ignore invalid recovery regions: can happen in crash */
+        if (rec->magic != TDB_RECOVERY_MAGIC &&
+            rec->magic != TDB_RECOVERY_INVALID_MAGIC) {
+                *recovery_offset = 0;
+                rec->rec_len = 0;
+        }
+        return 0;
+}
+
 /*
   allocate the recovery area, or use an existing recovery area if it is
@@ -689 +700 @@
         tdb_off_t recovery_head;
 
-        if (tdb_ofs_read(tdb, TDB_RECOVERY_HEAD, &recovery_head) == -1) {
+        if (tdb_recovery_area(tdb, methods, &recovery_head, &rec) == -1) {
                 TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_recovery_allocate: failed to read recovery head\n"));
-                return -1;
-        }
-
-        rec.rec_len = 0;
-
-        if (recovery_head != 0 && 
-            methods->tdb_read(tdb, recovery_head, &rec, sizeof(rec), DOCONV()) == -1) {
-                TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_recovery_allocate: failed to read recovery record\n"));
                 return -1;
         }
@@ -794 +797 @@
         memset(rec, 0, sizeof(*rec));
 
-        rec->magic    = 0;
+        rec->magic    = TDB_RECOVERY_INVALID_MAGIC;
         rec->data_len = recovery_size;
         rec->rec_len  = recovery_max_size;
         rec->key_len  = old_map_size;
-        CONVERT(rec);
+        CONVERT(*rec);
 
         /* build the recovery data into a single blob to allow us to do a single
@@ -816 +819 @@
                         length = tdb->transaction->last_block_size;
                 }
-                
+
                 if (offset >= old_map_size) {
                         continue;
@@ -845 +848 @@
         tailer = sizeof(*rec) + recovery_max_size;
         memcpy(p, &tailer, 4);
-        CONVERT(p);
+        if (DOCONV()) {
+                tdb_convert(p, 4);
+        }
 
         /* write the recovery data to the recovery area */
@@ -929 +934 @@
 
         methods = tdb->transaction->io_methods;
-        
+
         /* if there are any locks pending then the caller has not
            nested their locks properly, so fail the transaction */
-        if (tdb->num_locks || tdb->global_lock.count) {
+        if (tdb_have_extra_locks(tdb)) {
                 tdb->ecode = TDB_ERR_LOCK;
                 TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_transaction_prepare_commit: locks pending on commit\n"));
@@ -940 +945 @@
 
         /* upgrade the main transaction lock region to a write lock */
-        if (tdb_brlock_upgrade(tdb, FREELIST_TOP, 0) == -1) {
+        if (tdb_allrecord_upgrade(tdb) == -1) {
                 TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_transaction_prepare_commit: failed to upgrade hash locks\n"));
-                tdb->ecode = TDB_ERR_LOCK;
                 _tdb_transaction_cancel(tdb);
                 return -1;
         }
 
-        /* get the global lock - this prevents new users attaching to the database
+        /* get the open lock - this prevents new users attaching to the database
            during the commit */
-        if (tdb_brlock(tdb, GLOBAL_LOCK, F_WRLCK, F_SETLKW, 0, 1) == -1) {
-                TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_transaction_prepare_commit: failed to get global lock\n"));
-                tdb->ecode = TDB_ERR_LOCK;
+        if (tdb_nest_lock(tdb, OPEN_LOCK, F_WRLCK, TDB_LOCK_WAIT) == -1) {
+                TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_transaction_prepare_commit: failed to get open lock\n"));
                 _tdb_transaction_cancel(tdb);
                 return -1;
         }
-
-        tdb->transaction->global_lock_taken = true;
 
         if (!(tdb->flags & TDB_NOSYNC)) {
@@ -983 +984 @@
         }
 
-        /* Keep the global lock until the actual commit */
+        /* Keep the open lock until the actual commit */
 
         return 0;
@@ -991 +992 @@
    prepare to commit the current transaction
 */
-int tdb_transaction_prepare_commit(struct tdb_context *tdb)
-{       
+_PUBLIC_ int tdb_transaction_prepare_commit(struct tdb_context *tdb)
+{
         tdb_trace(tdb, "tdb_transaction_prepare_commit");
         return _tdb_transaction_prepare_commit(tdb);
 }
 
+/* A repack is worthwhile if the largest is less than half total free. */
+static bool repack_worthwhile(struct tdb_context *tdb)
+{
+        tdb_off_t ptr;
+        struct tdb_record rec;
+        tdb_len_t total = 0, largest = 0;
+
+        if (tdb_ofs_read(tdb, FREELIST_TOP, &ptr) == -1) {
+                return false;
+        }
+
+        while (ptr != 0 && tdb_rec_free_read(tdb, ptr, &rec) == 0) {
+                total += rec.rec_len;
+                if (rec.rec_len > largest) {
+                        largest = rec.rec_len;
+                }
+                ptr = rec.next;
+        }
+
+        return total > largest * 2;
+}
+
 /*
   commit the current transaction
 */
-int tdb_transaction_commit(struct tdb_context *tdb)
-{       
+_PUBLIC_ int tdb_transaction_commit(struct tdb_context *tdb)
+{
         const struct tdb_methods *methods;
         int i;
-        bool need_repack;
+        bool need_repack = false;
 
         if (tdb->transaction == NULL) {
@@ -1057 +1080 @@
                 if (methods->tdb_write(tdb, offset, tdb->transaction->blocks[i], length) == -1) {
                         TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_transaction_commit: write failed during commit\n"));
-                        
+
                         /* we've overwritten part of the data and
                            possibly expanded the file, so we need to
@@ -1071 +1094 @@
                 SAFE_FREE(tdb->transaction->blocks[i]);
         } 
+
+        /* Do this before we drop lock or blocks. */
+        if (tdb->transaction->expanded) {
+                need_repack = repack_worthwhile(tdb);
+        }
 
         SAFE_FREE(tdb->transaction->blocks);
@@ -1095 +1123 @@
 #endif
 
-        need_repack = tdb->transaction->need_repack;
-
         /* use a transaction cancel to free memory and remove the
            transaction locks */
@@ -1111 +1137 @@
 /*
   recover from an aborted transaction. Must be called with exclusive
-  database write access already established (including the global
+  database write access already established (including the open
   lock to prevent new processes attaching)
 */
@@ -1212 +1238 @@
                 return -1;                      
         }
-        
-        /* reduce the file size to the old size */
-        tdb_munmap(tdb);
-        if (ftruncate(tdb->fd, recovery_eof) != 0) {
-                TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_transaction_recover: failed to reduce to recovery size\n"));
-                tdb->ecode = TDB_ERR_IO;
-                return -1;                      
-        }
-        tdb->map_size = recovery_eof;
-        tdb_mmap(tdb);
 
         if (transaction_sync(tdb, 0, recovery_eof) == -1) {
@@ -1235 +1251 @@
         return 0;
 }
+
+/* Any I/O failures we say "needs recovery". */
+bool tdb_needs_recovery(struct tdb_context *tdb)
+{
+        tdb_off_t recovery_head;
+        struct tdb_record rec;
+
+        /* find the recovery area */
+        if (tdb_ofs_read(tdb, TDB_RECOVERY_HEAD, &recovery_head) == -1) {
+                return true;
+        }
+
+        if (recovery_head == 0) {
+                /* we have never allocated a recovery record */
+                return false;
+        }
+
+        /* read the recovery record */
+        if (tdb->methods->tdb_read(tdb, recovery_head, &rec,
+                                   sizeof(rec), DOCONV()) == -1) {
+                return true;
+        }
+
+        return (rec.magic == TDB_RECOVERY_MAGIC);
+}

vendor/current/lib/tdb/common/traverse.c

@@ -7 +7 @@
    Copyright (C) Paul `Rusty' Russell              2000
    Copyright (C) Jeremy Allison                    2000-2003
-   
+
      ** NOTE! The following LGPL license applies to the tdb
      ** library. This does NOT imply that all of Samba is released
      ** under the LGPL
-   
+
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
@@ -45 +45 @@
                            hashes are used. In that case we spend most of our
                            time in tdb_brlock(), locking empty hash chains.
-                           
+
                            To avoid this, we do an unlocked pre-check to see
                            if the hash chain is empty before starting to look
@@ -53 +53 @@
                            lock, so instead we get the lock and re-fetch the
                            value below.
-                           
+
                            Notice that not doing this optimisation on the
                            first hash chain is critical. We must guarantee
@@ -63 +63 @@
                            could miss them anyway without this trick, so the
                            semantics don't change.
-                           
+
                            With a non-indexed ldb search this trick gains us a
                            factor of around 80 in speed on a linux 2.6.x
@@ -213 +213 @@
   a write style traverse - temporarily marks the db read only
 */
-int tdb_traverse_read(struct tdb_context *tdb, 
+_PUBLIC_ int tdb_traverse_read(struct tdb_context *tdb, 
                       tdb_traverse_func fn, void *private_data)
 {
@@ -221 +221 @@
         /* we need to get a read lock on the transaction lock here to
            cope with the lock ordering semantics of solaris10 */
-        if (tdb_transaction_lock(tdb, F_RDLCK)) {
+        if (tdb_transaction_lock(tdb, F_RDLCK, TDB_LOCK_WAIT)) {
                 return -1;
         }
@@ -230 +230 @@
         tdb->traverse_read--;
 
-        tdb_transaction_unlock(tdb);
+        tdb_transaction_unlock(tdb, F_RDLCK);
 
         return ret;
@@ -242 +242 @@
   alignment restrictions malloc gives you.
 */
-int tdb_traverse(struct tdb_context *tdb, 
+_PUBLIC_ int tdb_traverse(struct tdb_context *tdb, 
                  tdb_traverse_func fn, void *private_data)
 {
@@ -252 +252 @@
         }
 
-        if (tdb_transaction_lock(tdb, F_WRLCK)) {
+        if (tdb_transaction_lock(tdb, F_WRLCK, TDB_LOCK_WAIT)) {
                 return -1;
         }
@@ -261 +261 @@
         tdb->traverse_write--;
 
-        tdb_transaction_unlock(tdb);
+        tdb_transaction_unlock(tdb, F_WRLCK);
 
         return ret;
@@ -268 +268 @@
 
 /* find the first entry in the database and return its key */
-TDB_DATA tdb_firstkey(struct tdb_context *tdb)
+_PUBLIC_ TDB_DATA tdb_firstkey(struct tdb_context *tdb)
 {
         TDB_DATA key;
@@ -299 +299 @@
 
 /* find the next entry in the database, returning its key */
-TDB_DATA tdb_nextkey(struct tdb_context *tdb, TDB_DATA oldkey)
+_PUBLIC_ TDB_DATA tdb_nextkey(struct tdb_context *tdb, TDB_DATA oldkey)
 {
         uint32_t oldhash;