tdb: Vectorize _tdb_store
[samba.git] / lib / tdb / common / tdb.c
index 7acc111cd86ac116a586dc8b15c662165f2a1fe6..6d4ad6d005c41720e06a10711c08a486b1313f38 100644 (file)
@@ -1,4 +1,4 @@
- /* 
+ /*
    Unix SMB/CIFS implementation.
 
    trivial database library
@@ -6,11 +6,11 @@
    Copyright (C) Andrew Tridgell              1999-2005
    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
    License as published by the Free Software Foundation; either
 
 #include "tdb_private.h"
 
-TDB_DATA tdb_null;
+_PUBLIC_ TDB_DATA tdb_null;
 
 /*
   non-blocking increment of the tdb sequence number if the tdb has been opened using
   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;
        }
@@ -59,13 +59,19 @@ static void tdb_increment_seqnum(struct tdb_context *tdb)
                return;
        }
 
-       if (tdb_brlock(tdb, TDB_SEQNUM_OFS, F_WRLCK, F_SETLKW, 1, 1) != 0) {
+       if (tdb->transaction != NULL) {
+               tdb_increment_seqnum_nonblock(tdb);
+               return;
+       }
+
+       if (tdb_nest_lock(tdb, TDB_SEQNUM_OFS, F_WRLCK,
+                         TDB_LOCK_WAIT|TDB_LOCK_PROBE) != 0) {
                return;
        }
 
        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);
 }
 
 static int tdb_key_compare(TDB_DATA key, TDB_DATA data, void *private_data)
@@ -76,10 +82,10 @@ static int tdb_key_compare(TDB_DATA key, TDB_DATA data, void *private_data)
 /* Returns 0 on fail.  On success, return offset of record, and fills
    in rec */
 static tdb_off_t tdb_find(struct tdb_context *tdb, TDB_DATA key, uint32_t hash,
-                       struct list_struct *r)
+                       struct tdb_record *r)
 {
        tdb_off_t rec_ptr;
-       
+
        /* read in the hash top */
        if (tdb_ofs_read(tdb, TDB_HASH_TOP(hash), &rec_ptr) == -1)
                return 0;
@@ -98,17 +104,19 @@ static tdb_off_t tdb_find(struct tdb_context *tdb, TDB_DATA key, uint32_t hash,
                }
                /* detect tight infinite loop */
                if (rec_ptr == r->next) {
+                       tdb->ecode = TDB_ERR_CORRUPT;
                        TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_find: loop detected.\n"));
-                       return TDB_ERRCODE(TDB_ERR_CORRUPT, 0);
+                       return 0;
                }
                rec_ptr = r->next;
        }
-       return TDB_ERRCODE(TDB_ERR_NOEXIST, 0);
+       tdb->ecode = TDB_ERR_NOEXIST;
+       return 0;
 }
 
 /* As tdb_find, but if you succeed, keep the lock */
 tdb_off_t tdb_find_lock_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash, int locktype,
-                          struct list_struct *rec)
+                          struct tdb_record *rec)
 {
        uint32_t rec_ptr;
 
@@ -119,36 +127,94 @@ tdb_off_t tdb_find_lock_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t has
        return rec_ptr;
 }
 
+static TDB_DATA _tdb_fetch(struct tdb_context *tdb, TDB_DATA key);
+
+struct tdb_update_hash_state {
+       const TDB_DATA *dbufs;
+       int num_dbufs;
+       tdb_len_t dbufs_len;
+};
+
+static int tdb_update_hash_cmp(TDB_DATA key, TDB_DATA data, void *private_data)
+{
+       struct tdb_update_hash_state *state = private_data;
+       unsigned char *dptr = data.dptr;
+       int i;
+
+       if (state->dbufs_len != data.dsize) {
+               return -1;
+       }
+
+       for (i=0; i<state->num_dbufs; i++) {
+               TDB_DATA dbuf = state->dbufs[i];
+               int ret;
+               ret = memcmp(dptr, dbuf.dptr, dbuf.dsize);
+               if (ret != 0) {
+                       return -1;
+               }
+               dptr += dbuf.dsize;
+       }
+
+       return 0;
+}
 
 /* update an entry in place - this only works if the new data size
    is <= the old data size and the key exists.
    on failure return -1.
 */
-static int tdb_update_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash, TDB_DATA dbuf)
+static int tdb_update_hash(struct tdb_context *tdb, TDB_DATA key,
+                          uint32_t hash,
+                          const TDB_DATA *dbufs, int num_dbufs,
+                          tdb_len_t dbufs_len)
 {
-       struct list_struct rec;
-       tdb_off_t rec_ptr;
+       struct tdb_record rec;
+       tdb_off_t rec_ptr, ofs;
+       int i;
 
        /* find entry */
        if (!(rec_ptr = tdb_find(tdb, key, hash, &rec)))
                return -1;
 
+       /* it could be an exact duplicate of what is there - this is
+        * surprisingly common (eg. with a ldb re-index). */
+       if (rec.data_len == dbufs_len) {
+               struct tdb_update_hash_state state = {
+                       .dbufs = dbufs, .num_dbufs = num_dbufs,
+                       .dbufs_len = dbufs_len
+               };
+               int ret;
+
+               ret = tdb_parse_record(tdb, key, tdb_update_hash_cmp, &state);
+               if (ret == 0) {
+                       return 0;
+               }
+       }
+
        /* must be long enough key, data and tailer */
-       if (rec.rec_len < key.dsize + dbuf.dsize + sizeof(tdb_off_t)) {
+       if (rec.rec_len < key.dsize + dbufs_len + sizeof(tdb_off_t)) {
                tdb->ecode = TDB_SUCCESS; /* Not really an error */
                return -1;
        }
 
-       if (tdb->methods->tdb_write(tdb, rec_ptr + sizeof(rec) + rec.key_len,
-                     dbuf.dptr, dbuf.dsize) == -1)
-               return -1;
+       ofs = rec_ptr + sizeof(rec) + rec.key_len;
+
+       for (i=0; i<num_dbufs; i++) {
+               TDB_DATA dbuf = dbufs[i];
+               int ret;
 
-       if (dbuf.dsize != rec.data_len) {
+               ret = tdb->methods->tdb_write(tdb, ofs, dbuf.dptr, dbuf.dsize);
+               if (ret == -1) {
+                       return -1;
+               }
+               ofs += dbuf.dsize;
+       }
+
+       if (dbufs_len != rec.data_len) {
                /* update size */
-               rec.data_len = dbuf.dsize;
+               rec.data_len = dbufs_len;
                return tdb_rec_write(tdb, rec_ptr, &rec);
        }
+
        return 0;
 }
 
@@ -161,7 +227,7 @@ static int tdb_update_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash,
 static TDB_DATA _tdb_fetch(struct tdb_context *tdb, TDB_DATA key)
 {
        tdb_off_t rec_ptr;
-       struct list_struct rec;
+       struct tdb_record rec;
        TDB_DATA ret;
        uint32_t hash;
 
@@ -177,7 +243,7 @@ static TDB_DATA _tdb_fetch(struct tdb_context *tdb, TDB_DATA key)
        return ret;
 }
 
-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);
 
@@ -190,7 +256,7 @@ TDB_DATA tdb_fetch(struct tdb_context *tdb, TDB_DATA key)
  * function. The parsing function is executed under the chain read lock, so it
  * 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
  * function directly at the mmap area, it avoids the malloc/memcpy in this
@@ -199,15 +265,17 @@ TDB_DATA tdb_fetch(struct tdb_context *tdb, TDB_DATA key)
  *
  * 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),
                     void *private_data)
 {
        tdb_off_t rec_ptr;
-       struct list_struct rec;
+       struct tdb_record rec;
        int ret;
        uint32_t hash;
 
@@ -215,8 +283,10 @@ int tdb_parse_record(struct tdb_context *tdb, TDB_DATA key,
        hash = tdb->hash_fn(&key);
 
        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);
-               return TDB_ERRCODE(TDB_ERR_NOEXIST, 0);
+               tdb->ecode = TDB_ERR_NOEXIST;
+               return -1;
        }
        tdb_trace_1rec_ret(tdb, "tdb_parse_record", key, 0);
 
@@ -228,7 +298,7 @@ int tdb_parse_record(struct tdb_context *tdb, TDB_DATA key,
        return ret;
 }
 
-/* check if an entry in the database exists 
+/* check if an entry in the database exists
 
    note that 1 is returned if the key is found and 0 is returned if not found
    this doesn't match the conventions in the rest of this module, but is
@@ -236,15 +306,15 @@ int tdb_parse_record(struct tdb_context *tdb, TDB_DATA key,
 */
 static int tdb_exists_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash)
 {
-       struct list_struct rec;
-       
+       struct tdb_record rec;
+
        if (tdb_find_lock_hash(tdb, key, hash, F_RDLCK, &rec) == 0)
                return 0;
        tdb_unlock(tdb, BUCKET(rec.full_hash), F_RDLCK);
        return 1;
 }
 
-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);
        int ret;
@@ -255,10 +325,10 @@ int tdb_exists(struct tdb_context *tdb, TDB_DATA key)
 }
 
 /* actually delete an entry in the database given the offset */
-int tdb_do_delete(struct tdb_context *tdb, tdb_off_t rec_ptr, struct list_struct *rec)
+int tdb_do_delete(struct tdb_context *tdb, tdb_off_t rec_ptr, struct tdb_record *rec)
 {
        tdb_off_t last_ptr, i;
-       struct list_struct lastrec;
+       struct tdb_record lastrec;
 
        if (tdb->read_only || tdb->traverse_read) return -1;
 
@@ -294,8 +364,8 @@ static int tdb_count_dead(struct tdb_context *tdb, uint32_t hash)
 {
        int res = 0;
        tdb_off_t rec_ptr;
-       struct list_struct rec;
-       
+       struct tdb_record rec;
+
        /* read in the hash top */
        if (tdb_ofs_read(tdb, TDB_HASH_TOP(hash), &rec_ptr) == -1)
                return 0;
@@ -315,16 +385,19 @@ static int tdb_count_dead(struct tdb_context *tdb, uint32_t hash)
 /*
  * Purge all DEAD records from a hash chain
  */
-static int tdb_purge_dead(struct tdb_context *tdb, uint32_t hash)
+int tdb_purge_dead(struct tdb_context *tdb, uint32_t hash)
 {
        int res = -1;
-       struct list_struct rec;
+       struct tdb_record rec;
        tdb_off_t rec_ptr;
 
-       if (tdb_lock(tdb, -1, F_WRLCK) == -1) {
+       if (tdb_lock_nonblock(tdb, -1, F_WRLCK) == -1) {
+               /*
+                * Don't block the freelist if not strictly necessary
+                */
                return -1;
        }
-       
+
        /* read in the hash top */
        if (tdb_ofs_read(tdb, TDB_HASH_TOP(hash), &rec_ptr) == -1)
                goto fail;
@@ -354,19 +427,23 @@ static int tdb_purge_dead(struct tdb_context *tdb, uint32_t hash)
 static int tdb_delete_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash)
 {
        tdb_off_t rec_ptr;
-       struct list_struct rec;
+       struct tdb_record rec;
        int ret;
 
+       rec_ptr = tdb_find_lock_hash(tdb, key, hash, F_WRLCK, &rec);
+       if (rec_ptr == 0) {
+               return -1;
+       }
+
        if (tdb->max_dead_records != 0) {
 
+               uint32_t magic = TDB_DEAD_MAGIC;
+
                /*
                 * Allow for some dead records per hash chain, mainly for
                 * tdb's with a very high create/delete rate like locking.tdb.
                 */
 
-               if (tdb_lock(tdb, BUCKET(hash), F_WRLCK) == -1)
-                       return -1;
-
                if (tdb_count_dead(tdb, hash) >= tdb->max_dead_records) {
                        /*
                         * Don't let the per-chain freelist grow too large,
@@ -375,22 +452,14 @@ static int tdb_delete_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash)
                        tdb_purge_dead(tdb, hash);
                }
 
-               if (!(rec_ptr = tdb_find(tdb, key, hash, &rec))) {
-                       tdb_unlock(tdb, BUCKET(hash), F_WRLCK);
-                       return -1;
-               }
-
                /*
                 * Just mark the record as dead.
                 */
-               rec.magic = TDB_DEAD_MAGIC;
-               ret = tdb_rec_write(tdb, rec_ptr, &rec);
+               ret = tdb_ofs_write(
+                       tdb, rec_ptr + offsetof(struct tdb_record, magic),
+                       &magic);
        }
        else {
-               if (!(rec_ptr = tdb_find_lock_hash(tdb, key, hash, F_WRLCK,
-                                                  &rec)))
-                       return -1;
-
                ret = tdb_do_delete(tdb, rec_ptr, &rec);
        }
 
@@ -398,12 +467,12 @@ static int tdb_delete_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash)
                tdb_increment_seqnum(tdb);
        }
 
-       if (tdb_unlock(tdb, BUCKET(rec.full_hash), F_WRLCK) != 0)
+       if (tdb_unlock(tdb, BUCKET(hash), F_WRLCK) != 0)
                TDB_LOG((tdb, TDB_DEBUG_WARNING, "tdb_delete: WARNING tdb_unlock failed!\n"));
        return ret;
 }
 
-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);
        int ret;
@@ -416,13 +485,21 @@ int tdb_delete(struct tdb_context *tdb, TDB_DATA key)
 /*
  * See if we have a dead record around with enough space
  */
-static tdb_off_t tdb_find_dead(struct tdb_context *tdb, uint32_t hash,
-                              struct list_struct *r, tdb_len_t length)
+tdb_off_t tdb_find_dead(struct tdb_context *tdb, uint32_t hash,
+                       struct tdb_record *r, tdb_len_t length,
+                       tdb_off_t *p_last_ptr)
 {
-       tdb_off_t rec_ptr;
-       
+       tdb_off_t rec_ptr, last_ptr;
+       tdb_off_t best_rec_ptr = 0;
+       tdb_off_t best_last_ptr = 0;
+       struct tdb_record best = { .rec_len = UINT32_MAX };
+
+       length += sizeof(tdb_off_t); /* tailer */
+
+       last_ptr = TDB_HASH_TOP(hash);
+
        /* read in the hash top */
-       if (tdb_ofs_read(tdb, TDB_HASH_TOP(hash), &rec_ptr) == -1)
+       if (tdb_ofs_read(tdb, last_ptr, &rec_ptr) == -1)
                return 0;
 
        /* keep looking until we find the right record */
@@ -430,26 +507,53 @@ static tdb_off_t tdb_find_dead(struct tdb_context *tdb, uint32_t hash,
                if (tdb_rec_read(tdb, rec_ptr, r) == -1)
                        return 0;
 
-               if (TDB_DEAD(r) && r->rec_len >= length) {
-                       /*
-                        * First fit for simple coding, TODO: change to best
-                        * fit
-                        */
-                       return rec_ptr;
+               if (TDB_DEAD(r) && (r->rec_len >= length) &&
+                   (r->rec_len < best.rec_len)) {
+                       best_rec_ptr = rec_ptr;
+                       best_last_ptr = last_ptr;
+                       best = *r;
                }
+               last_ptr = rec_ptr;
                rec_ptr = r->next;
        }
-       return 0;
+
+       if (best.rec_len == UINT32_MAX) {
+               return 0;
+       }
+
+       *r = best;
+       *p_last_ptr = best_last_ptr;
+       return best_rec_ptr;
 }
 
-static int _tdb_store(struct tdb_context *tdb, TDB_DATA key,
-                      TDB_DATA dbuf, int flag, uint32_t hash)
+static int _tdb_storev(struct tdb_context *tdb, TDB_DATA key,
+                      const TDB_DATA *dbufs, int num_dbufs,
+                      int flag, uint32_t hash)
 {
-       struct list_struct rec;
-       tdb_off_t rec_ptr;
-       char *p = NULL;
+       struct tdb_record rec;
+       tdb_off_t rec_ptr, ofs;
+       tdb_len_t rec_len, dbufs_len;
+       int i;
        int ret = -1;
 
+       dbufs_len = 0;
+
+       for (i=0; i<num_dbufs; i++) {
+               size_t dsize = dbufs[i].dsize;
+
+               dbufs_len += dsize;
+               if (dbufs_len < dsize) {
+                       tdb->ecode = TDB_ERR_OOM;
+                       goto fail;
+               }
+       }
+
+       rec_len = key.dsize + dbufs_len;
+       if ((rec_len < key.dsize) || (rec_len < dbufs_len)) {
+               tdb->ecode = TDB_ERR_OOM;
+               goto fail;
+       }
+
        /* check for it existing, on insert. */
        if (flag == TDB_INSERT) {
                if (tdb_exists_hash(tdb, key, hash)) {
@@ -458,7 +562,8 @@ static int _tdb_store(struct tdb_context *tdb, TDB_DATA key,
                }
        } else {
                /* first try in-place update, on modify or replace. */
-               if (tdb_update_hash(tdb, key, hash, dbuf) == 0) {
+               if (tdb_update_hash(tdb, key, hash, dbufs, num_dbufs,
+                                   dbufs_len) == 0) {
                        goto done;
                }
                if (tdb->ecode == TDB_ERR_NOEXIST &&
@@ -468,7 +573,7 @@ static int _tdb_store(struct tdb_context *tdb, TDB_DATA key,
                        goto fail;
                }
        }
-       /* reset the error code potentially set by the tdb_update() */
+       /* reset the error code potentially set by the tdb_update_hash() */
        tdb->ecode = TDB_SUCCESS;
 
        /* delete any existing record - if it doesn't exist we don't
@@ -477,64 +582,8 @@ static int _tdb_store(struct tdb_context *tdb, TDB_DATA key,
        if (flag != TDB_INSERT)
                tdb_delete_hash(tdb, key, hash);
 
-       /* Copy key+value *before* allocating free space in case malloc
-          fails and we are left with a dead spot in the tdb. */
-
-       if (!(p = (char *)malloc(key.dsize + dbuf.dsize))) {
-               tdb->ecode = TDB_ERR_OOM;
-               goto fail;
-       }
-
-       memcpy(p, key.dptr, key.dsize);
-       if (dbuf.dsize)
-               memcpy(p+key.dsize, dbuf.dptr, dbuf.dsize);
-
-       if (tdb->max_dead_records != 0) {
-               /*
-                * Allow for some dead records per hash chain, look if we can
-                * find one that can hold the new record. We need enough space
-                * for key, data and tailer. If we find one, we don't have to
-                * consult the central freelist.
-                */
-               rec_ptr = tdb_find_dead(
-                       tdb, hash, &rec,
-                       key.dsize + dbuf.dsize + sizeof(tdb_off_t));
-
-               if (rec_ptr != 0) {
-                       rec.key_len = key.dsize;
-                       rec.data_len = dbuf.dsize;
-                       rec.full_hash = hash;
-                       rec.magic = TDB_MAGIC;
-                       if (tdb_rec_write(tdb, rec_ptr, &rec) == -1
-                           || tdb->methods->tdb_write(
-                                   tdb, rec_ptr + sizeof(rec),
-                                   p, key.dsize + dbuf.dsize) == -1) {
-                               goto fail;
-                       }
-                       goto done;
-               }
-       }
-
-       /*
-        * We have to allocate some space from the freelist, so this means we
-        * have to lock it. Use the chance to purge all the DEAD records from
-        * the hash chain under the freelist lock.
-        */
-
-       if (tdb_lock(tdb, -1, F_WRLCK) == -1) {
-               goto fail;
-       }
-
-       if ((tdb->max_dead_records != 0)
-           && (tdb_purge_dead(tdb, hash) == -1)) {
-               tdb_unlock(tdb, -1, F_WRLCK);
-               goto fail;
-       }
-
        /* we have to allocate some space */
-       rec_ptr = tdb_allocate(tdb, key.dsize + dbuf.dsize, &rec);
-
-       tdb_unlock(tdb, -1, F_WRLCK);
+       rec_ptr = tdb_allocate(tdb, hash, rec_len, &rec);
 
        if (rec_ptr == 0) {
                goto fail;
@@ -545,14 +594,36 @@ static int _tdb_store(struct tdb_context *tdb, TDB_DATA key,
                goto fail;
 
        rec.key_len = key.dsize;
-       rec.data_len = dbuf.dsize;
+       rec.data_len = dbufs_len;
        rec.full_hash = hash;
        rec.magic = TDB_MAGIC;
 
+       ofs = rec_ptr;
+
        /* write out and point the top of the hash chain at it */
-       if (tdb_rec_write(tdb, rec_ptr, &rec) == -1
-           || tdb->methods->tdb_write(tdb, rec_ptr+sizeof(rec), p, key.dsize+dbuf.dsize)==-1
-           || tdb_ofs_write(tdb, TDB_HASH_TOP(hash), &rec_ptr) == -1) {
+       ret = tdb_rec_write(tdb, ofs, &rec);
+       if (ret == -1) {
+               goto fail;
+       }
+       ofs += sizeof(rec);
+
+       ret = tdb->methods->tdb_write(tdb, ofs, key.dptr, key.dsize);
+       if (ret == -1) {
+               goto fail;
+       }
+       ofs += key.dsize;
+
+       for (i=0; i<num_dbufs; i++) {
+               ret = tdb->methods->tdb_write(tdb, ofs, dbufs[i].dptr,
+                                             dbufs[i].dsize);
+               if (ret == -1) {
+                       goto fail;
+               }
+               ofs += dbufs[i].dsize;
+       }
+
+       ret = tdb_ofs_write(tdb, TDB_HASH_TOP(hash), &rec_ptr);
+       if (ret == -1) {
                /* Need to tdb_unallocate() here */
                goto fail;
        }
@@ -563,17 +634,21 @@ static int _tdb_store(struct tdb_context *tdb, TDB_DATA key,
        if (ret == 0) {
                tdb_increment_seqnum(tdb);
        }
-
-       SAFE_FREE(p); 
        return ret;
 }
 
+static int _tdb_store(struct tdb_context *tdb, TDB_DATA key,
+                     TDB_DATA dbuf, int flag, uint32_t hash)
+{
+       return _tdb_storev(tdb, key, &dbuf, 1, flag, hash);
+}
+
 /* store an element in the database, replacing any existing element
    with the same key
 
    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;
        int ret;
@@ -596,7 +671,7 @@ int tdb_store(struct tdb_context *tdb, TDB_DATA key, TDB_DATA dbuf, int flag)
 }
 
 /* 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;
        TDB_DATA dbuf;
@@ -635,7 +710,7 @@ int tdb_append(struct tdb_context *tdb, TDB_DATA key, TDB_DATA new_dbuf)
 
        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);
        SAFE_FREE(dbuf.dptr);
@@ -647,7 +722,7 @@ failed:
   return the name of the current tdb file
   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;
 }
@@ -657,7 +732,7 @@ const char *tdb_name(struct tdb_context *tdb)
   useful for external routines that want to check the device/inode
   of the fd
 */
-int tdb_fd(struct tdb_context *tdb)
+_PUBLIC_ int tdb_fd(struct tdb_context *tdb)
 {
        return tdb->fd;
 }
@@ -666,7 +741,7 @@ int tdb_fd(struct tdb_context *tdb)
   return the current logging function
   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;
 }
@@ -682,7 +757,7 @@ tdb_log_func tdb_log_fn(struct tdb_context *tdb)
   The aim of this sequence number is to allow for a very lightweight
   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;
 
@@ -690,28 +765,67 @@ int tdb_get_seqnum(struct tdb_context *tdb)
        return seqnum;
 }
 
-int tdb_hash_size(struct tdb_context *tdb)
+_PUBLIC_ int tdb_hash_size(struct tdb_context *tdb)
 {
-       return tdb->header.hash_size;
+       return tdb->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) &&
+           (flags & TDB_DISALLOW_NESTING)) {
+               tdb->ecode = TDB_ERR_NESTING;
+               TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_add_flags: "
+                       "allow_nesting and disallow_nesting are not allowed together!"));
+               return;
+       }
+
+       if (flags & TDB_ALLOW_NESTING) {
+               tdb->flags &= ~TDB_DISALLOW_NESTING;
+       }
+       if (flags & TDB_DISALLOW_NESTING) {
+               tdb->flags &= ~TDB_ALLOW_NESTING;
+       }
+
        tdb->flags |= flags;
 }
 
-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) &&
+           (flags & TDB_DISALLOW_NESTING)) {
+               tdb->ecode = TDB_ERR_NESTING;
+               TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_remove_flags: "
+                       "allow_nesting and disallow_nesting are not allowed together!"));
+               return;
+       }
+
+       if ((flags & TDB_NOLOCK) &&
+           (tdb->feature_flags & TDB_FEATURE_FLAG_MUTEX) &&
+           (tdb->mutexes == NULL)) {
+               tdb->ecode = TDB_ERR_LOCK;
+               TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_remove_flags: "
+                        "Can not remove NOLOCK flag on mutexed databases"));
+               return;
+       }
+
+       if (flags & TDB_ALLOW_NESTING) {
+               tdb->flags |= TDB_DISALLOW_NESTING;
+       }
+       if (flags & TDB_DISALLOW_NESTING) {
+               tdb->flags |= TDB_ALLOW_NESTING;
+       }
+
        tdb->flags &= ~flags;
 }
 
@@ -719,26 +833,26 @@ void tdb_remove_flags(struct tdb_context *tdb, unsigned flags)
 /*
   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;
 }
 
 
 /*
-  add a region of the file to the freelist. Length is the size of the region in bytes, 
+  add a region of the file to the freelist. Length is the size of the region in bytes,
   which includes the free list header that needs to be added
  */
 static int tdb_free_region(struct tdb_context *tdb, tdb_off_t offset, ssize_t length)
 {
-       struct list_struct rec;
+       struct tdb_record rec;
        if (length <= sizeof(rec)) {
                /* the region is not worth adding */
                return 0;
        }
        if (length + offset > tdb->map_size) {
                TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_free_region: adding region beyond end of file\n"));
-               return -1;              
+               return -1;
        }
        memset(&rec,'\0',sizeof(rec));
        rec.rec_len = length - sizeof(rec);
@@ -751,14 +865,14 @@ static int tdb_free_region(struct tdb_context *tdb, tdb_off_t offset, ssize_t le
 
 /*
   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;
+       uint32_t i;
        tdb_off_t offset = 0;
        ssize_t data_len;
        tdb_off_t recovery_head;
@@ -780,16 +894,16 @@ int tdb_wipe_all(struct tdb_context *tdb)
        }
 
        if (recovery_head != 0) {
-               struct list_struct rec;
+               struct tdb_record rec;
                if (tdb->methods->tdb_read(tdb, recovery_head, &rec, sizeof(rec), DOCONV()) == -1) {
                        TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_wipe_all: failed to read recovery record\n"));
                        return -1;
-               }       
+               }
                recovery_size = rec.rec_len + sizeof(rec);
        }
 
        /* wipe the hashes */
-       for (i=0;i<tdb->header.hash_size;i++) {
+       for (i=0;i<tdb->hash_size;i++) {
                if (tdb_ofs_write(tdb, TDB_HASH_TOP(i), &offset) == -1) {
                        TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_wipe_all: failed to write hash %d\n", i));
                        goto failed;
@@ -802,25 +916,25 @@ int tdb_wipe_all(struct tdb_context *tdb)
                goto failed;
        }
 
-       /* add all the rest of the file to the freelist, possibly leaving a gap 
+       /* add all the rest of the file to the freelist, possibly leaving a gap
           for the recovery area */
        if (recovery_size == 0) {
                /* the simple case - the whole file can be used as a freelist */
-               data_len = (tdb->map_size - TDB_DATA_START(tdb->header.hash_size));
-               if (tdb_free_region(tdb, TDB_DATA_START(tdb->header.hash_size), data_len) != 0) {
+               data_len = (tdb->map_size - TDB_DATA_START(tdb->hash_size));
+               if (tdb_free_region(tdb, TDB_DATA_START(tdb->hash_size), data_len) != 0) {
                        goto failed;
                }
        } else {
                /* we need to add two freelist entries - one on either
-                  side of the recovery area 
+                  side of the recovery area
 
                   Note that we cannot shift the recovery area during
                   this operation. Only the transaction.c code may
                   move the recovery area or we risk subtle data
                   corruption
                */
-               data_len = (recovery_head - TDB_DATA_START(tdb->header.hash_size));
-               if (tdb_free_region(tdb, TDB_DATA_START(tdb->header.hash_size), data_len) != 0) {
+               data_len = (recovery_head - TDB_DATA_START(tdb->hash_size));
+               if (tdb_free_region(tdb, TDB_DATA_START(tdb->hash_size), data_len) != 0) {
                        goto failed;
                }
                /* and the 2nd free list entry after the recovery area - if any */
@@ -830,6 +944,8 @@ int tdb_wipe_all(struct tdb_context *tdb)
                }
        }
 
+       tdb_increment_seqnum_nonblock(tdb);
+
        if (tdb_unlockall(tdb) != 0) {
                TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_wipe_all: failed to unlock\n"));
                goto failed;
@@ -863,7 +979,7 @@ static int repack_traverse(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data,
 /*
   repack a tdb
  */
-int tdb_repack(struct tdb_context *tdb)
+_PUBLIC_ int tdb_repack(struct tdb_context *tdb)
 {
        struct tdb_context *tmp_db;
        struct traverse_state state;
@@ -889,7 +1005,7 @@ int tdb_repack(struct tdb_context *tdb)
                TDB_LOG((tdb, TDB_DEBUG_FATAL, __location__ " Failed to traverse copying out\n"));
                tdb_transaction_cancel(tdb);
                tdb_close(tmp_db);
-               return -1;              
+               return -1;
        }
 
        if (state.error) {
@@ -913,7 +1029,7 @@ int tdb_repack(struct tdb_context *tdb)
                TDB_LOG((tdb, TDB_DEBUG_FATAL, __location__ " Failed to traverse copying back\n"));
                tdb_transaction_cancel(tdb);
                tdb_close(tmp_db);
-               return -1;              
+               return -1;
        }
 
        if (state.error) {
@@ -933,10 +1049,35 @@ int tdb_repack(struct tdb_context *tdb)
        return 0;
 }
 
+/* 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;
+}
+
+bool tdb_add_off_t(tdb_off_t a, tdb_off_t b, tdb_off_t *pret)
+{
+       tdb_off_t ret = a + b;
+
+       if ((ret < a) || (ret < b)) {
+               return false;
+       }
+       *pret = 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_all(tdb->tracefd, str, strlen(str))) {
                close(tdb->tracefd);
                tdb->tracefd = -1;
        }