TDB2: more internal cleanups after TDB1 compatibility removal.

This eliminates the separate tdb2 substructure, and makes some
tdb1-required functions static.

Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>

diff --git a/lib/tdb2/check.c b/lib/tdb2/check.c
index e6c815815c7fad4a6e0f7f10182b0aab5dcdca6e..4b589b6ee108deb68dd33fdd6886cee0c3bf8009 100644 (file)
--- a/lib/tdb2/check.c
+++ b/lib/tdb2/check.c
@@ -497,10 +497,10 @@ static enum TDB_ERROR check_free(struct tdb_context *tdb,
 
        }
 
-       ecode = tdb->tdb2.io->oob(tdb, off,
-                                 frec_len(frec)
-                                 + sizeof(struct tdb_used_record),
-                                 false);
+       ecode = tdb->io->oob(tdb, off,
+                            frec_len(frec)
+                            + sizeof(struct tdb_used_record),
+                            false);
        if (ecode != TDB_SUCCESS) {
                return ecode;
        }
@@ -606,7 +606,7 @@ tdb_off_t dead_space(struct tdb_context *tdb, tdb_off_t off)
 
        for (len = 0; off + len < tdb->file->map_size; len++) {
                char c;
-               ecode = tdb->tdb2.io->tread(tdb, off, &c, 1);
+               ecode = tdb->io->tread(tdb, off, &c, 1);
                if (ecode != TDB_SUCCESS) {
                        return TDB_ERR_TO_OFF(ecode);
                }

diff --git a/lib/tdb2/free.c b/lib/tdb2/free.c
index 0868a6ea3019d56ebf70f10f14df449affb9ff75..c4015a0f2afb24daedefe4b7019c6d093fcdfde0 100644 (file)
--- a/lib/tdb2/free.c
+++ b/lib/tdb2/free.c
@@ -65,8 +65,8 @@ enum TDB_ERROR tdb_ftable_init(struct tdb_context *tdb)
        unsigned int rnd, max = 0, count = 0;
        tdb_off_t off;
 
-       tdb->tdb2.ftable_off = off = first_ftable(tdb);
-       tdb->tdb2.ftable = 0;
+       tdb->ftable_off = off = first_ftable(tdb);
+       tdb->ftable = 0;
 
        while (off) {
                if (TDB_OFF_IS_ERR(off)) {
@@ -75,8 +75,8 @@ enum TDB_ERROR tdb_ftable_init(struct tdb_context *tdb)
 
                rnd = random();
                if (rnd >= max) {
-                       tdb->tdb2.ftable_off = off;
-                       tdb->tdb2.ftable = count;
+                       tdb->ftable_off = off;
+                       tdb->ftable = count;
                        max = rnd;
                }
 
@@ -218,7 +218,8 @@ static enum TDB_ERROR enqueue_in_free(struct tdb_context *tdb,
                return TDB_OFF_TO_ERR(head);
 
        /* We only need to set ftable_and_len; rest is set in enqueue_in_free */
-       new.ftable_and_len = ((uint64_t)tdb->tdb2.ftable << (64 - TDB_OFF_UPPER_STEAL))
+       new.ftable_and_len = ((uint64_t)tdb->ftable
+                             << (64 - TDB_OFF_UPPER_STEAL))
                | len;
 
        /* new->next = head. */
@@ -287,8 +288,8 @@ static tdb_off_t ftable_offset(struct tdb_context *tdb, unsigned int ftable)
        tdb_off_t off;
        unsigned int i;
 
-       if (likely(tdb->tdb2.ftable == ftable))
-               return tdb->tdb2.ftable_off;
+       if (likely(tdb->ftable == ftable))
+               return tdb->ftable_off;
 
        off = first_ftable(tdb);
        for (i = 0; i < ftable; i++) {
@@ -595,7 +596,7 @@ enum TDB_ERROR add_free_record(struct tdb_context *tdb,
 
        len = len_with_header - sizeof(struct tdb_used_record);
 
-       b_off = bucket_off(tdb->tdb2.ftable_off, size_to_bucket(len));
+       b_off = bucket_off(tdb->ftable_off, size_to_bucket(len));
        ecode = tdb_lock_free_bucket(tdb, b_off, waitflag);
        if (ecode != TDB_SUCCESS) {
                return ecode;
@@ -606,7 +607,7 @@ enum TDB_ERROR add_free_record(struct tdb_context *tdb,
 
        /* Coalescing unlocks free list. */
        if (!ecode && coalesce_ok)
-               ecode = coalesce_list(tdb, tdb->tdb2.ftable_off, b_off, 2);
+               ecode = coalesce_list(tdb, tdb->ftable_off, b_off, 2);
        else
                tdb_unlock_free_bucket(tdb, b_off);
        return ecode;
@@ -752,8 +753,8 @@ static tdb_off_t lock_and_alloc(struct tdb_context *tdb,
 
                /* For futureproofing, we put a 0 in any unused space. */
                if (rec_extra_padding(&rec)) {
-                       ecode = tdb->tdb2.io->twrite(tdb, best_off + sizeof(rec)
-                                                    + keylen + datalen, "", 1);
+                       ecode = tdb->io->twrite(tdb, best_off + sizeof(rec)
+                                               + keylen + datalen, "", 1);
                        if (ecode != TDB_SUCCESS) {
                                goto unlock_err;
                        }
@@ -800,9 +801,9 @@ static tdb_off_t get_free(struct tdb_context *tdb,
        else
                start_b = size_to_bucket(adjust_size(keylen, datalen));
 
-       ftable_off = tdb->tdb2.ftable_off;
-       ftable = tdb->tdb2.ftable;
-       while (!wrapped || ftable_off != tdb->tdb2.ftable_off) {
+       ftable_off = tdb->ftable_off;
+       ftable = tdb->ftable;
+       while (!wrapped || ftable_off != tdb->ftable_off) {
                /* Start at exact size bucket, and search up... */
                for (b = find_free_head(tdb, ftable_off, start_b);
                     b < TDB_FREE_BUCKETS;
@@ -819,8 +820,8 @@ static tdb_off_t get_free(struct tdb_context *tdb,
                                if (b == TDB_FREE_BUCKETS - 1)
                                        tdb->stats.alloc_bucket_max++;
                                /* Worked?  Stay using this list. */
-                               tdb->tdb2.ftable_off = ftable_off;
-                               tdb->tdb2.ftable = ftable;
+                               tdb->ftable_off = ftable_off;
+                               tdb->ftable = ftable;
                                return off;
                        }
                        /* Didn't work.  Try next bucket. */
@@ -926,7 +927,7 @@ static enum TDB_ERROR tdb_expand(struct tdb_context *tdb, tdb_len_t size)
 
        /* Someone else may have expanded the file, so retry. */
        old_size = tdb->file->map_size;
-       tdb->tdb2.io->oob(tdb, tdb->file->map_size, 1, true);
+       tdb->io->oob(tdb, tdb->file->map_size, 1, true);
        if (tdb->file->map_size != old_size) {
                tdb_unlock_expand(tdb, F_WRLCK);
                return TDB_SUCCESS;
@@ -937,7 +938,7 @@ static enum TDB_ERROR tdb_expand(struct tdb_context *tdb, tdb_len_t size)
        /* We need room for the record header too. */
        wanted = adjust_size(0, sizeof(struct tdb_used_record) + wanted);
 
-       ecode = tdb->tdb2.io->expand_file(tdb, wanted);
+       ecode = tdb->io->expand_file(tdb, wanted);
        if (ecode != TDB_SUCCESS) {
                tdb_unlock_expand(tdb, F_WRLCK);
                return ecode;
@@ -957,7 +958,7 @@ tdb_off_t alloc(struct tdb_context *tdb, size_t keylen, size_t datalen,
        tdb_off_t off;
 
        /* We can't hold pointers during this: we could unmap! */
-       assert(!tdb->tdb2.direct_access);
+       assert(!tdb->direct_access);
 
        for (;;) {
                enum TDB_ERROR ecode;

diff --git a/lib/tdb2/io.c b/lib/tdb2/io.c
index 7308d2bf4496d5a9db7979010c48774e7b4eb6a3..ca044ae3615abae807c6a9ff6701d02ff2a7556c 100644 (file)
--- a/lib/tdb2/io.c
+++ b/lib/tdb2/io.c
@@ -99,7 +99,7 @@ static enum TDB_ERROR tdb_oob(struct tdb_context *tdb,
        enum TDB_ERROR ecode;
 
        /* We can't hold pointers during this: we could unmap! */
-       assert(!tdb->tdb2.direct_access
+       assert(!tdb->direct_access
               || (tdb->flags & TDB_NOLOCK)
               || tdb_has_expansion_lock(tdb));
 
@@ -216,7 +216,7 @@ uint64_t tdb_find_zero_off(struct tdb_context *tdb, tdb_off_t off,
 enum TDB_ERROR zero_out(struct tdb_context *tdb, tdb_off_t off, tdb_len_t len)
 {
        char buf[8192] = { 0 };
-       void *p = tdb->tdb2.io->direct(tdb, off, len, true);
+       void *p = tdb->io->direct(tdb, off, len, true);
        enum TDB_ERROR ecode = TDB_SUCCESS;
 
        assert(!(tdb->flags & TDB_RDONLY));
@@ -229,7 +229,7 @@ enum TDB_ERROR zero_out(struct tdb_context *tdb, tdb_off_t off, tdb_len_t len)
        }
        while (len) {
                unsigned todo = len < sizeof(buf) ? len : sizeof(buf);
-               ecode = tdb->tdb2.io->twrite(tdb, off, buf, todo);
+               ecode = tdb->io->twrite(tdb, off, buf, todo);
                if (ecode != TDB_SUCCESS) {
                        break;
                }
@@ -245,8 +245,7 @@ tdb_off_t tdb_read_off(struct tdb_context *tdb, tdb_off_t off)
        enum TDB_ERROR ecode;
 
        if (likely(!(tdb->flags & TDB_CONVERT))) {
-               tdb_off_t *p = tdb->tdb2.io->direct(tdb, off, sizeof(*p),
-                                                   false);
+               tdb_off_t *p = tdb->io->direct(tdb, off, sizeof(*p), false);
                if (TDB_PTR_IS_ERR(p)) {
                        return TDB_ERR_TO_OFF(TDB_PTR_ERR(p));
                }
@@ -272,7 +271,7 @@ static enum TDB_ERROR tdb_write(struct tdb_context *tdb, tdb_off_t off,
                                  "Write to read-only database");
        }
 
-       ecode = tdb->tdb2.io->oob(tdb, off, len, false);
+       ecode = tdb->io->oob(tdb, off, len, false);
        if (ecode != TDB_SUCCESS) {
                return ecode;
        }
@@ -306,7 +305,7 @@ static enum TDB_ERROR tdb_read(struct tdb_context *tdb, tdb_off_t off,
 {
        enum TDB_ERROR ecode;
 
-       ecode = tdb->tdb2.io->oob(tdb, off, len, false);
+       ecode = tdb->io->oob(tdb, off, len, false);
        if (ecode != TDB_SUCCESS) {
                return ecode;
        }
@@ -344,11 +343,11 @@ enum TDB_ERROR tdb_write_convert(struct tdb_context *tdb, tdb_off_t off,
                                          " %zu bytes", len);
                }
                memcpy(conv, rec, len);
-               ecode = tdb->tdb2.io->twrite(tdb, off,
-                                          tdb_convert(tdb, conv, len), len);
+               ecode = tdb->io->twrite(tdb, off,
+                                       tdb_convert(tdb, conv, len), len);
                free(conv);
        } else {
-               ecode = tdb->tdb2.io->twrite(tdb, off, rec, len);
+               ecode = tdb->io->twrite(tdb, off, rec, len);
        }
        return ecode;
 }
@@ -356,7 +355,7 @@ enum TDB_ERROR tdb_write_convert(struct tdb_context *tdb, tdb_off_t off,
 enum TDB_ERROR tdb_read_convert(struct tdb_context *tdb, tdb_off_t off,
                                void *rec, size_t len)
 {
-       enum TDB_ERROR ecode = tdb->tdb2.io->tread(tdb, off, rec, len);
+       enum TDB_ERROR ecode = tdb->io->tread(tdb, off, rec, len);
        tdb_convert(tdb, rec, len);
        return ecode;
 }
@@ -370,8 +369,7 @@ enum TDB_ERROR tdb_write_off(struct tdb_context *tdb,
        }
 
        if (likely(!(tdb->flags & TDB_CONVERT))) {
-               tdb_off_t *p = tdb->tdb2.io->direct(tdb, off, sizeof(*p),
-                                                   true);
+               tdb_off_t *p = tdb->io->direct(tdb, off, sizeof(*p), true);
                if (TDB_PTR_IS_ERR(p)) {
                        return TDB_PTR_ERR(p);
                }
@@ -397,7 +395,7 @@ static void *_tdb_alloc_read(struct tdb_context *tdb, tdb_off_t offset,
                           (size_t)(prefix + len));
                return TDB_ERR_PTR(TDB_ERR_OOM);
        } else {
-               ecode = tdb->tdb2.io->tread(tdb, offset, buf+prefix, len);
+               ecode = tdb->io->tread(tdb, offset, buf+prefix, len);
                if (unlikely(ecode != TDB_SUCCESS)) {
                        free(buf);
                        return TDB_ERR_PTR(ecode);
@@ -486,7 +484,7 @@ const void *tdb_access_read(struct tdb_context *tdb,
        void *ret = NULL;
 
        if (likely(!(tdb->flags & TDB_CONVERT))) {
-               ret = tdb->tdb2.io->direct(tdb, off, len, false);
+               ret = tdb->io->direct(tdb, off, len, false);
 
                if (TDB_PTR_IS_ERR(ret)) {
                        return ret;
@@ -498,14 +496,14 @@ const void *tdb_access_read(struct tdb_context *tdb,
                if (TDB_PTR_IS_ERR(hdr)) {
                        return hdr;
                }
-               hdr->next = tdb->tdb2.access;
-               tdb->tdb2.access = hdr;
+               hdr->next = tdb->access;
+               tdb->access = hdr;
                ret = hdr + 1;
                if (convert) {
                        tdb_convert(tdb, (void *)ret, len);
                }
        } else
-               tdb->tdb2.direct_access++;
+               tdb->direct_access++;
 
        return ret;
 }
@@ -522,7 +520,7 @@ void *tdb_access_write(struct tdb_context *tdb,
        }
 
        if (likely(!(tdb->flags & TDB_CONVERT))) {
-               ret = tdb->tdb2.io->direct(tdb, off, len, true);
+               ret = tdb->io->direct(tdb, off, len, true);
 
                if (TDB_PTR_IS_ERR(ret)) {
                        return ret;
@@ -535,8 +533,8 @@ void *tdb_access_write(struct tdb_context *tdb,
                if (TDB_PTR_IS_ERR(hdr)) {
                        return hdr;
                }
-               hdr->next = tdb->tdb2.access;
-               tdb->tdb2.access = hdr;
+               hdr->next = tdb->access;
+               tdb->access = hdr;
                hdr->off = off;
                hdr->len = len;
                hdr->convert = convert;
@@ -544,7 +542,7 @@ void *tdb_access_write(struct tdb_context *tdb,
                if (convert)
                        tdb_convert(tdb, (void *)ret, len);
        } else
-               tdb->tdb2.direct_access++;
+               tdb->direct_access++;
 
        return ret;
 }
@@ -553,7 +551,7 @@ static struct tdb_access_hdr **find_hdr(struct tdb_context *tdb, const void *p)
 {
        struct tdb_access_hdr **hp;
 
-       for (hp = &tdb->tdb2.access; *hp; hp = &(*hp)->next) {
+       for (hp = &tdb->access; *hp; hp = &(*hp)->next) {
                if (*hp + 1 == p)
                        return hp;
        }
@@ -569,7 +567,7 @@ void tdb_access_release(struct tdb_context *tdb, const void *p)
                *hp = hdr->next;
                free(hdr);
        } else
-               tdb->tdb2.direct_access--;
+               tdb->direct_access--;
 }
 
 enum TDB_ERROR tdb_access_commit(struct tdb_context *tdb, void *p)
@@ -586,7 +584,7 @@ enum TDB_ERROR tdb_access_commit(struct tdb_context *tdb, void *p)
                *hp = hdr->next;
                free(hdr);
        } else {
-               tdb->tdb2.direct_access--;
+               tdb->direct_access--;
                ecode = TDB_SUCCESS;
        }
 
@@ -614,10 +612,9 @@ void tdb_inc_seqnum(struct tdb_context *tdb)
        if (likely(!(tdb->flags & TDB_CONVERT))) {
                int64_t *direct;
 
-               direct = tdb->tdb2.io->direct(tdb,
-                                             offsetof(struct tdb_header,
-                                                      seqnum),
-                                             sizeof(*direct), true);
+               direct = tdb->io->direct(tdb,
+                                        offsetof(struct tdb_header, seqnum),
+                                        sizeof(*direct), true);
                if (likely(direct)) {
                        /* Don't let it go negative, even briefly */
                        if (unlikely((*direct) + 1) < 0)
@@ -649,5 +646,5 @@ static const struct tdb_methods io_methods = {
 */
 void tdb_io_init(struct tdb_context *tdb)
 {
-       tdb->tdb2.io = &io_methods;
+       tdb->io = &io_methods;
 }

diff --git a/lib/tdb2/lock.c b/lib/tdb2/lock.c
index bf6cf7d38877e125f7e11ba9ef66312b83077f42..b0583546fbf4cb8c19569f214ee494da466ff41a 100644 (file)
--- a/lib/tdb2/lock.c
+++ b/lib/tdb2/lock.c
@@ -183,9 +183,9 @@ static int unlock(struct tdb_context *tdb, int rw, off_t off, off_t len)
 
    note that a len of zero means lock to end of file
 */
-enum TDB_ERROR tdb_brlock(struct tdb_context *tdb,
-                         int rw_type, tdb_off_t offset, tdb_off_t len,
-                         enum tdb_lock_flags flags)
+static enum TDB_ERROR tdb_brlock(struct tdb_context *tdb,
+                                int rw_type, tdb_off_t offset, tdb_off_t len,
+                                enum tdb_lock_flags flags)
 {
        int ret;
 
@@ -225,8 +225,8 @@ enum TDB_ERROR tdb_brlock(struct tdb_context *tdb,
        return TDB_SUCCESS;
 }
 
-enum TDB_ERROR tdb_brunlock(struct tdb_context *tdb,
-                           int rw_type, tdb_off_t offset, size_t len)
+static enum TDB_ERROR tdb_brunlock(struct tdb_context *tdb,
+                                  int rw_type, tdb_off_t offset, size_t len)
 {
        if (tdb->flags & TDB_NOLOCK) {
                return TDB_SUCCESS;
@@ -339,9 +339,9 @@ enum TDB_ERROR tdb_lock_and_recover(struct tdb_context *tdb)
 }
 
 /* lock an offset in the database. */
-enum TDB_ERROR tdb_nest_lock(struct tdb_context *tdb,
-                            tdb_off_t offset, int ltype,
-                            enum tdb_lock_flags flags)
+static enum TDB_ERROR tdb_nest_lock(struct tdb_context *tdb,
+                                   tdb_off_t offset, int ltype,
+                                   enum tdb_lock_flags flags)
 {
        struct tdb_lock *new_lck;
        enum TDB_ERROR ecode;
@@ -435,8 +435,8 @@ enum TDB_ERROR tdb_nest_lock(struct tdb_context *tdb,
        return TDB_SUCCESS;
 }
 
-enum TDB_ERROR tdb_nest_unlock(struct tdb_context *tdb,
-                              tdb_off_t off, int ltype)
+static enum TDB_ERROR tdb_nest_unlock(struct tdb_context *tdb,
+                                     tdb_off_t off, int ltype)
 {
        struct tdb_lock *lck;
        enum TDB_ERROR ecode;
@@ -491,9 +491,9 @@ void tdb_transaction_unlock(struct tdb_context *tdb, int ltype)
 
 /* We only need to lock individual bytes, but Linux merges consecutive locks
  * so we lock in contiguous ranges. */
-enum TDB_ERROR tdb_lock_gradual(struct tdb_context *tdb,
-                               int ltype, enum tdb_lock_flags flags,
-                               tdb_off_t off, tdb_off_t len)
+static enum TDB_ERROR tdb_lock_gradual(struct tdb_context *tdb,
+                                      int ltype, enum tdb_lock_flags flags,
+                                      tdb_off_t off, tdb_off_t len)
 {
        enum TDB_ERROR ecode;
        enum tdb_lock_flags nb_flags = (flags & ~TDB_LOCK_WAIT);

diff --git a/lib/tdb2/open.c b/lib/tdb2/open.c
index 023dc7fe7d5dc64e3f80047545a8e7c491ca0087..fab855b6b85af54948d3cc187880b1214db3342d 100644 (file)
--- a/lib/tdb2/open.c
+++ b/lib/tdb2/open.c
@@ -100,9 +100,9 @@ static void tdb2_context_init(struct tdb_context *tdb)
 {
        /* Initialize the TDB2 fields here */
        tdb_io_init(tdb);
-       tdb->tdb2.direct_access = 0;
-       tdb->tdb2.transaction = NULL;
-       tdb->tdb2.access = NULL;
+       tdb->direct_access = 0;
+       tdb->transaction = NULL;
+       tdb->access = NULL;
 }
 
 struct new_database {
@@ -640,7 +640,7 @@ _PUBLIC_ struct tdb_context *tdb_open(const char *name, int tdb_flags,
        tdb_unlock_open(tdb, openlock);
 
        /* This makes sure we have current map_size and mmap. */
-       ecode = tdb->tdb2.io->oob(tdb, tdb->file->map_size, 1, true);
+       ecode = tdb->io->oob(tdb, tdb->file->map_size, 1, true);
        if (unlikely(ecode != TDB_SUCCESS))
                goto fail;
 
@@ -722,7 +722,7 @@ _PUBLIC_ int tdb_close(struct tdb_context *tdb)
 
        tdb_trace(tdb, "tdb_close");
 
-       if (tdb->tdb2.transaction) {
+       if (tdb->transaction) {
                tdb_transaction_cancel(tdb);
        }
 

diff --git a/lib/tdb2/private.h b/lib/tdb2/private.h
index da0454b4dee0d87eea1e9f13ca8a3bc1c8da5f92..8c917a70b273682ed542594118fc43292fffb3c6 100644 (file)
--- a/lib/tdb2/private.h
+++ b/lib/tdb2/private.h
@@ -547,25 +547,6 @@ bool tdb_has_expansion_lock(struct tdb_context *tdb);
 /* If it needs recovery, grab all the locks and do it. */
 enum TDB_ERROR tdb_lock_and_recover(struct tdb_context *tdb);
 
-/* Byte-range lock wrappers for TDB1 to access. */
-enum TDB_ERROR tdb_brlock(struct tdb_context *tdb,
-                         int rw_type, tdb_off_t offset, tdb_off_t len,
-                         enum tdb_lock_flags flags);
-
-enum TDB_ERROR tdb_brunlock(struct tdb_context *tdb,
-                           int rw_type, tdb_off_t offset, size_t len);
-
-enum TDB_ERROR tdb_nest_lock(struct tdb_context *tdb,
-                            tdb_off_t offset, int ltype,
-                            enum tdb_lock_flags flags);
-
-enum TDB_ERROR tdb_nest_unlock(struct tdb_context *tdb,
-                              tdb_off_t off, int ltype);
-
-enum TDB_ERROR tdb_lock_gradual(struct tdb_context *tdb,
-                               int ltype, enum tdb_lock_flags flags,
-                               tdb_off_t off, tdb_off_t len);
-
 /* Default lock and unlock functions. */
 int tdb_fcntl_lock(int fd, int rw, off_t off, off_t len, bool waitflag, void *);
 int tdb_fcntl_unlock(int fd, int rw, off_t off, off_t len, void *);
@@ -618,24 +599,21 @@ struct tdb_context {
        /* Last error we returned. */
        enum TDB_ERROR last_error;
 
-       struct {
-
-               /* Are we accessing directly? (debugging check). */
-               int direct_access;
+       /* Are we accessing directly? (debugging check). */
+       int direct_access;
 
-               /* Set if we are in a transaction. */
-               struct tdb_transaction *transaction;
+       /* Set if we are in a transaction. */
+       struct tdb_transaction *transaction;
 
-               /* What free table are we using? */
-               tdb_off_t ftable_off;
-               unsigned int ftable;
+       /* What free table are we using? */
+       tdb_off_t ftable_off;
+       unsigned int ftable;
 
-               /* IO methods: changes for transactions. */
-               const struct tdb_methods *io;
+       /* IO methods: changes for transactions. */
+       const struct tdb_methods *io;
 
-               /* Direct access information */
-               struct tdb_access_hdr *access;
-       } tdb2;
+       /* Direct access information */
+       struct tdb_access_hdr *access;
 };
 
 /* tdb.c: */

diff --git a/lib/tdb2/tdb.c b/lib/tdb2/tdb.c
index 98d1ad6c668a9acbcbc0e8a9738135b0670c5a52..5257aa17e32df779687edd9a24f1ccee8405fb9e 100644 (file)
--- a/lib/tdb2/tdb.c
+++ b/lib/tdb2/tdb.c
@@ -72,13 +72,13 @@ static enum TDB_ERROR replace_data(struct tdb_context *tdb,
        }
 
        new_off += sizeof(struct tdb_used_record);
-       ecode = tdb->tdb2.io->twrite(tdb, new_off, key.dptr, key.dsize);
+       ecode = tdb->io->twrite(tdb, new_off, key.dptr, key.dsize);
        if (ecode != TDB_SUCCESS) {
                return ecode;
        }
 
        new_off += key.dsize;
-       ecode = tdb->tdb2.io->twrite(tdb, new_off, dbuf.dptr, dbuf.dsize);
+       ecode = tdb->io->twrite(tdb, new_off, dbuf.dptr, dbuf.dsize);
        if (ecode != TDB_SUCCESS) {
                return ecode;
        }
@@ -96,10 +96,10 @@ static enum TDB_ERROR update_data(struct tdb_context *tdb,
 {
        enum TDB_ERROR ecode;
 
-       ecode = tdb->tdb2.io->twrite(tdb, off, dbuf.dptr, dbuf.dsize);
+       ecode = tdb->io->twrite(tdb, off, dbuf.dptr, dbuf.dsize);
        if (ecode == TDB_SUCCESS && extra) {
                /* Put a zero in; future versions may append other data. */
-               ecode = tdb->tdb2.io->twrite(tdb, off + dbuf.dsize, "", 1);
+               ecode = tdb->io->twrite(tdb, off + dbuf.dsize, "", 1);
        }
        if (tdb->flags & TDB_SEQNUM)
                tdb_inc_seqnum(tdb);
@@ -213,8 +213,8 @@ _PUBLIC_ enum TDB_ERROR tdb_append(struct tdb_context *tdb,
                                                    + dbuf.dsize));
                        goto out;
                }
-               ecode = tdb->tdb2.io->tread(tdb, off + sizeof(rec) + key.dsize,
-                                           newdata, old_dlen);
+               ecode = tdb->io->tread(tdb, off + sizeof(rec) + key.dsize,
+                                      newdata, old_dlen);
                if (ecode != TDB_SUCCESS) {
                        goto out_free_newdata;
                }
@@ -328,7 +328,7 @@ _PUBLIC_ unsigned int tdb_get_flags(struct tdb_context *tdb)
 
 static bool inside_transaction(const struct tdb_context *tdb)
 {
-       return tdb->tdb2.transaction != NULL;
+       return tdb->transaction != NULL;
 }
 
 static bool readonly_changable(struct tdb_context *tdb, const char *caller)

diff --git a/lib/tdb2/test/helprun-layout.c b/lib/tdb2/test/helprun-layout.c
index 3e56d0ed7a4657225d78d34595a2fb250571e9aa..b9cd4a643233226f2461d75410bd28030be8c1c3 100644 (file)
--- a/lib/tdb2/test/helprun-layout.c
+++ b/lib/tdb2/test/helprun-layout.c
@@ -191,8 +191,8 @@ static void add_to_freetable(struct tdb_context *tdb,
                             unsigned ftable,
                             struct tle_freetable *freetable)
 {
-       tdb->tdb2.ftable_off = freetable->base.off;
-       tdb->tdb2.ftable = ftable;
+       tdb->ftable_off = freetable->base.off;
+       tdb->ftable = ftable;
        add_free_record(tdb, eoff, sizeof(struct tdb_used_record) + elen,
                        TDB_LOCK_WAIT, false);
 }
@@ -367,7 +367,7 @@ struct tdb_context *tdb_layout_get(struct tdb_layout *layout,
                }
        }
 
-       tdb->tdb2.ftable_off = find_ftable(layout, 0)->base.off;
+       tdb->ftable_off = find_ftable(layout, 0)->base.off;
        return tdb;
 }
 

diff --git a/lib/tdb2/test/run-03-coalesce.c b/lib/tdb2/test/run-03-coalesce.c
index ad39719bcbd965eb51eca130d04056d233586cc8..ecc469fa3288744cea12bdaa9c148e76899689b9 100644 (file)
--- a/lib/tdb2/test/run-03-coalesce.c
+++ b/lib/tdb2/test/run-03-coalesce.c
@@ -44,7 +44,7 @@ int main(int argc, char *argv[])
        ok1(free_record_length(tdb, layout->elem[1].base.off) == len);
 
        /* Figure out which bucket free entry is. */
-       b_off = bucket_off(tdb->tdb2.ftable_off, size_to_bucket(len));
+       b_off = bucket_off(tdb->ftable_off, size_to_bucket(len));
        /* Lock and fail to coalesce. */
        ok1(tdb_lock_free_bucket(tdb, b_off, TDB_LOCK_WAIT) == 0);
        test = layout->elem[1].base.off;
@@ -70,7 +70,7 @@ int main(int argc, char *argv[])
        ok1(tdb_check(tdb, NULL, NULL) == 0);
 
        /* Figure out which bucket free entry is. */
-       b_off = bucket_off(tdb->tdb2.ftable_off, size_to_bucket(1024));
+       b_off = bucket_off(tdb->ftable_off, size_to_bucket(1024));
        /* Lock and fail to coalesce. */
        ok1(tdb_lock_free_bucket(tdb, b_off, TDB_LOCK_WAIT) == 0);
        test = layout->elem[1].base.off;
@@ -97,7 +97,7 @@ int main(int argc, char *argv[])
        ok1(tdb_check(tdb, NULL, NULL) == 0);
 
        /* Figure out which bucket (first) free entry is. */
-       b_off = bucket_off(tdb->tdb2.ftable_off, size_to_bucket(1024));
+       b_off = bucket_off(tdb->ftable_off, size_to_bucket(1024));
        /* Lock and coalesce. */
        ok1(tdb_lock_free_bucket(tdb, b_off, TDB_LOCK_WAIT) == 0);
        test = layout->elem[2].base.off;
@@ -127,7 +127,7 @@ int main(int argc, char *argv[])
        ok1(tdb_check(tdb, NULL, NULL) == 0);
 
        /* Figure out which bucket free entry is. */
-       b_off = bucket_off(tdb->tdb2.ftable_off, size_to_bucket(1024));
+       b_off = bucket_off(tdb->ftable_off, size_to_bucket(1024));
        /* Lock and coalesce. */
        ok1(tdb_lock_free_bucket(tdb, b_off, TDB_LOCK_WAIT) == 0);
        test = layout->elem[2].base.off;
@@ -157,7 +157,7 @@ int main(int argc, char *argv[])
        ok1(tdb_check(tdb, NULL, NULL) == 0);
 
        /* Figure out which bucket free entry is. */
-       b_off = bucket_off(tdb->tdb2.ftable_off, size_to_bucket(1024));
+       b_off = bucket_off(tdb->ftable_off, size_to_bucket(1024));
        /* Lock and coalesce. */
        ok1(tdb_lock_free_bucket(tdb, b_off, TDB_LOCK_WAIT) == 0);
        test = layout->elem[2].base.off;

diff --git a/lib/tdb2/test/run-04-basichash.c b/lib/tdb2/test/run-04-basichash.c
index 9ab45ad978cfb0b8b0d9bcdda1b083d6f23a8e8d..dc75fc72dc77e4835553847d2ecb109525c8e8f5 100644 (file)
--- a/lib/tdb2/test/run-04-basichash.c
+++ b/lib/tdb2/test/run-04-basichash.c
@@ -68,9 +68,9 @@ int main(int argc, char *argv[])
 
                /* Make sure we fill it in for later finding. */
                off = new_off + sizeof(struct tdb_used_record);
-               ok1(!tdb->tdb2.io->twrite(tdb, off, key.dptr, key.dsize));
+               ok1(!tdb->io->twrite(tdb, off, key.dptr, key.dsize));
                off += key.dsize;
-               ok1(!tdb->tdb2.io->twrite(tdb, off, dbuf.dptr, dbuf.dsize));
+               ok1(!tdb->io->twrite(tdb, off, dbuf.dptr, dbuf.dsize));
 
                /* We should be able to unlock that OK. */
                ok1(tdb_unlock_hashes(tdb, h.hlock_start, h.hlock_range,
@@ -228,9 +228,9 @@ int main(int argc, char *argv[])
 
                /* Make sure we fill it in for later finding. */
                off = new_off + sizeof(struct tdb_used_record);
-               ok1(!tdb->tdb2.io->twrite(tdb, off, key.dptr, key.dsize));
+               ok1(!tdb->io->twrite(tdb, off, key.dptr, key.dsize));
                off += key.dsize;
-               ok1(!tdb->tdb2.io->twrite(tdb, off, dbuf.dptr, dbuf.dsize));
+               ok1(!tdb->io->twrite(tdb, off, dbuf.dptr, dbuf.dsize));
 
                /* We should be able to unlock that OK. */
                ok1(tdb_unlock_hashes(tdb, h.hlock_start, h.hlock_range,

diff --git a/lib/tdb2/test/run-30-exhaust-before-expand.c b/lib/tdb2/test/run-30-exhaust-before-expand.c
index c39f0591f0c97cc252e5c04cedbe80e8f92dbade..13bb9461d4756e878ef00b131a2156d2c6e5f62e 100644 (file)
--- a/lib/tdb2/test/run-30-exhaust-before-expand.c
+++ b/lib/tdb2/test/run-30-exhaust-before-expand.c
@@ -8,7 +8,7 @@ static bool empty_freetable(struct tdb_context *tdb)
        unsigned int i;
 
        /* Now, free table should be completely exhausted in zone 0 */
-       if (tdb_read_convert(tdb, tdb->tdb2.ftable_off, &ftab, sizeof(ftab)) != 0)
+       if (tdb_read_convert(tdb, tdb->ftable_off, &ftab, sizeof(ftab)) != 0)
                abort();
 
        for (i = 0; i < sizeof(ftab.buckets)/sizeof(ftab.buckets[0]); i++) {

diff --git a/lib/tdb2/test/run-50-multiple-freelists.c b/lib/tdb2/test/run-50-multiple-freelists.c
index 617b1e4dd4e353509e86a673b9c7260e1c0825d8..b102876c8d59ec14153861589bf53a81014841dd 100644 (file)
--- a/lib/tdb2/test/run-50-multiple-freelists.c
+++ b/lib/tdb2/test/run-50-multiple-freelists.c
@@ -41,22 +41,22 @@ int main(int argc, char *argv[])
        off = get_free(tdb, 0, 80 - sizeof(struct tdb_used_record), 0,
                       TDB_USED_MAGIC, 0);
        ok1(off == layout->elem[3].base.off);
-       ok1(tdb->tdb2.ftable_off == layout->elem[0].base.off);
+       ok1(tdb->ftable_off == layout->elem[0].base.off);
 
        off = get_free(tdb, 0, 160 - sizeof(struct tdb_used_record), 0,
                       TDB_USED_MAGIC, 0);
        ok1(off == layout->elem[5].base.off);
-       ok1(tdb->tdb2.ftable_off == layout->elem[1].base.off);
+       ok1(tdb->ftable_off == layout->elem[1].base.off);
 
        off = get_free(tdb, 0, 320 - sizeof(struct tdb_used_record), 0,
                       TDB_USED_MAGIC, 0);
        ok1(off == layout->elem[7].base.off);
-       ok1(tdb->tdb2.ftable_off == layout->elem[2].base.off);
+       ok1(tdb->ftable_off == layout->elem[2].base.off);
 
        off = get_free(tdb, 0, 40 - sizeof(struct tdb_used_record), 0,
                       TDB_USED_MAGIC, 0);
        ok1(off == layout->elem[9].base.off);
-       ok1(tdb->tdb2.ftable_off == layout->elem[0].base.off);
+       ok1(tdb->ftable_off == layout->elem[0].base.off);
 
        /* Now we fail. */
        off = get_free(tdb, 0, 0, 1, TDB_USED_MAGIC, 0);

diff --git a/lib/tdb2/transaction.c b/lib/tdb2/transaction.c
index cd6d42a6ec816cd717ced06ee52b335c691714fe..2b714714dcae15c927435c76803f24d392fa4c6c 100644 (file)
--- a/lib/tdb2/transaction.c
+++ b/lib/tdb2/transaction.c
@@ -151,10 +151,10 @@ static enum TDB_ERROR transaction_read(struct tdb_context *tdb, tdb_off_t off,
        blk = off / PAGESIZE;
 
        /* see if we have it in the block list */
-       if (tdb->tdb2.transaction->num_blocks <= blk ||
-           tdb->tdb2.transaction->blocks[blk] == NULL) {
+       if (tdb->transaction->num_blocks <= blk ||
+           tdb->transaction->blocks[blk] == NULL) {
                /* nope, do a real read */
-               ecode = tdb->tdb2.transaction->io_methods->tread(tdb, off, buf, len);
+               ecode = tdb->transaction->io_methods->tread(tdb, off, buf, len);
                if (ecode != TDB_SUCCESS) {
                        goto fail;
                }
@@ -162,19 +162,19 @@ static enum TDB_ERROR transaction_read(struct tdb_context *tdb, tdb_off_t off,
        }
 
        /* it is in the block list. Now check for the last block */
-       if (blk == tdb->tdb2.transaction->num_blocks-1) {
-               if (len > tdb->tdb2.transaction->last_block_size) {
+       if (blk == tdb->transaction->num_blocks-1) {
+               if (len > tdb->transaction->last_block_size) {
                        ecode = TDB_ERR_IO;
                        goto fail;
                }
        }
 
        /* now copy it out of this block */
-       memcpy(buf, tdb->tdb2.transaction->blocks[blk] + (off % PAGESIZE), len);
+       memcpy(buf, tdb->transaction->blocks[blk] + (off % PAGESIZE), len);
        return TDB_SUCCESS;
 
 fail:
-       tdb->tdb2.transaction->transaction_error = 1;
+       tdb->transaction->transaction_error = 1;
        return tdb_logerr(tdb, ecode, TDB_LOG_ERROR,
                          "transaction_read: failed at off=%zu len=%zu",
                          (size_t)off, (size_t)len);
@@ -191,7 +191,7 @@ static enum TDB_ERROR transaction_write(struct tdb_context *tdb, tdb_off_t off,
        enum TDB_ERROR ecode;
 
        /* Only a commit is allowed on a prepared transaction */
-       if (tdb->tdb2.transaction->prepared) {
+       if (tdb->transaction->prepared) {
                ecode = tdb_logerr(tdb, TDB_ERR_EINVAL, TDB_LOG_ERROR,
                                   "transaction_write: transaction already"
                                   " prepared, write not allowed");
@@ -219,15 +219,15 @@ static enum TDB_ERROR transaction_write(struct tdb_context *tdb, tdb_off_t off,
        blk = off / PAGESIZE;
        off = off % PAGESIZE;
 
-       if (tdb->tdb2.transaction->num_blocks <= blk) {
+       if (tdb->transaction->num_blocks <= blk) {
                uint8_t **new_blocks;
                /* expand the blocks array */
-               if (tdb->tdb2.transaction->blocks == NULL) {
+               if (tdb->transaction->blocks == NULL) {
                        new_blocks = (uint8_t **)malloc(
                                (blk+1)*sizeof(uint8_t *));
                } else {
                        new_blocks = (uint8_t **)realloc(
-                               tdb->tdb2.transaction->blocks,
+                               tdb->transaction->blocks,
                                (blk+1)*sizeof(uint8_t *));
                }
                if (new_blocks == NULL) {
@@ -236,30 +236,30 @@ static enum TDB_ERROR transaction_write(struct tdb_context *tdb, tdb_off_t off,
                                           " failed to allocate");
                        goto fail;
                }
-               memset(&new_blocks[tdb->tdb2.transaction->num_blocks], 0,
-                      (1+(blk - tdb->tdb2.transaction->num_blocks))*sizeof(uint8_t *));
-               tdb->tdb2.transaction->blocks = new_blocks;
-               tdb->tdb2.transaction->num_blocks = blk+1;
-               tdb->tdb2.transaction->last_block_size = 0;
+               memset(&new_blocks[tdb->transaction->num_blocks], 0,
+                      (1+(blk - tdb->transaction->num_blocks))*sizeof(uint8_t *));
+               tdb->transaction->blocks = new_blocks;
+               tdb->transaction->num_blocks = blk+1;
+               tdb->transaction->last_block_size = 0;
        }
 
        /* allocate and fill a block? */
-       if (tdb->tdb2.transaction->blocks[blk] == NULL) {
-               tdb->tdb2.transaction->blocks[blk] = (uint8_t *)calloc(PAGESIZE, 1);
-               if (tdb->tdb2.transaction->blocks[blk] == NULL) {
+       if (tdb->transaction->blocks[blk] == NULL) {
+               tdb->transaction->blocks[blk] = (uint8_t *)calloc(PAGESIZE, 1);
+               if (tdb->transaction->blocks[blk] == NULL) {
                        ecode = tdb_logerr(tdb, TDB_ERR_OOM, TDB_LOG_ERROR,
                                           "transaction_write:"
                                           " failed to allocate");
                        goto fail;
                }
-               if (tdb->tdb2.transaction->old_map_size > blk * PAGESIZE) {
+               if (tdb->transaction->old_map_size > blk * PAGESIZE) {
                        tdb_len_t len2 = PAGESIZE;
-                       if (len2 + (blk * PAGESIZE) > tdb->tdb2.transaction->old_map_size) {
-                               len2 = tdb->tdb2.transaction->old_map_size - (blk * PAGESIZE);
+                       if (len2 + (blk * PAGESIZE) > tdb->transaction->old_map_size) {
+                               len2 = tdb->transaction->old_map_size - (blk * PAGESIZE);
                        }
-                       ecode = tdb->tdb2.transaction->io_methods->tread(tdb,
+                       ecode = tdb->transaction->io_methods->tread(tdb,
                                        blk * PAGESIZE,
-                                       tdb->tdb2.transaction->blocks[blk],
+                                       tdb->transaction->blocks[blk],
                                        len2);
                        if (ecode != TDB_SUCCESS) {
                                ecode = tdb_logerr(tdb, ecode,
@@ -268,31 +268,31 @@ static enum TDB_ERROR transaction_write(struct tdb_context *tdb, tdb_off_t off,
                                                   " failed to"
                                                   " read old block: %s",
                                                   strerror(errno));
-                               SAFE_FREE(tdb->tdb2.transaction->blocks[blk]);
+                               SAFE_FREE(tdb->transaction->blocks[blk]);
                                goto fail;
                        }
-                       if (blk == tdb->tdb2.transaction->num_blocks-1) {
-                               tdb->tdb2.transaction->last_block_size = len2;
+                       if (blk == tdb->transaction->num_blocks-1) {
+                               tdb->transaction->last_block_size = len2;
                        }
                }
        }
 
        /* overwrite part of an existing block */
        if (buf == NULL) {
-               memset(tdb->tdb2.transaction->blocks[blk] + off, 0, len);
+               memset(tdb->transaction->blocks[blk] + off, 0, len);
        } else {
-               memcpy(tdb->tdb2.transaction->blocks[blk] + off, buf, len);
+               memcpy(tdb->transaction->blocks[blk] + off, buf, len);
        }
-       if (blk == tdb->tdb2.transaction->num_blocks-1) {
-               if (len + off > tdb->tdb2.transaction->last_block_size) {
-                       tdb->tdb2.transaction->last_block_size = len + off;
+       if (blk == tdb->transaction->num_blocks-1) {
+               if (len + off > tdb->transaction->last_block_size) {
+                       tdb->transaction->last_block_size = len + off;
                }
        }
 
        return TDB_SUCCESS;
 
 fail:
-       tdb->tdb2.transaction->transaction_error = 1;
+       tdb->transaction->transaction_error = 1;
        return ecode;
 }
 
@@ -324,21 +324,21 @@ static void transaction_write_existing(struct tdb_context *tdb, tdb_off_t off,
        blk = off / PAGESIZE;
        off = off % PAGESIZE;
 
-       if (tdb->tdb2.transaction->num_blocks <= blk ||
-           tdb->tdb2.transaction->blocks[blk] == NULL) {
+       if (tdb->transaction->num_blocks <= blk ||
+           tdb->transaction->blocks[blk] == NULL) {
                return;
        }
 
-       if (blk == tdb->tdb2.transaction->num_blocks-1 &&
-           off + len > tdb->tdb2.transaction->last_block_size) {
-               if (off >= tdb->tdb2.transaction->last_block_size) {
+       if (blk == tdb->transaction->num_blocks-1 &&
+           off + len > tdb->transaction->last_block_size) {
+               if (off >= tdb->transaction->last_block_size) {
                        return;
                }
-               len = tdb->tdb2.transaction->last_block_size - off;
+               len = tdb->transaction->last_block_size - off;
        }
 
        /* overwrite part of an existing block */
-       memcpy(tdb->tdb2.transaction->blocks[blk] + off, buf, len);
+       memcpy(tdb->transaction->blocks[blk] + off, buf, len);
 }
 
 
@@ -388,32 +388,32 @@ static void *transaction_direct(struct tdb_context *tdb, tdb_off_t off,
        if (write_mode) {
                tdb->stats.transaction_write_direct++;
                if (blk != end_blk
-                   || blk >= tdb->tdb2.transaction->num_blocks
-                   || tdb->tdb2.transaction->blocks[blk] == NULL) {
+                   || blk >= tdb->transaction->num_blocks
+                   || tdb->transaction->blocks[blk] == NULL) {
                        tdb->stats.transaction_write_direct_fail++;
                        return NULL;
                }
-               return tdb->tdb2.transaction->blocks[blk] + off % PAGESIZE;
+               return tdb->transaction->blocks[blk] + off % PAGESIZE;
        }
 
        tdb->stats.transaction_read_direct++;
        /* Single which we have copied? */
        if (blk == end_blk
-           && blk < tdb->tdb2.transaction->num_blocks
-           && tdb->tdb2.transaction->blocks[blk])
-               return tdb->tdb2.transaction->blocks[blk] + off % PAGESIZE;
+           && blk < tdb->transaction->num_blocks
+           && tdb->transaction->blocks[blk])
+               return tdb->transaction->blocks[blk] + off % PAGESIZE;
 
        /* Otherwise must be all not copied. */
        while (blk <= end_blk) {
-               if (blk >= tdb->tdb2.transaction->num_blocks)
+               if (blk >= tdb->transaction->num_blocks)
                        break;
-               if (tdb->tdb2.transaction->blocks[blk]) {
+               if (tdb->transaction->blocks[blk]) {
                        tdb->stats.transaction_read_direct_fail++;
                        return NULL;
                }
                blk++;
        }
-       return tdb->tdb2.transaction->io_methods->direct(tdb, off, len, false);
+       return tdb->transaction->io_methods->direct(tdb, off, len, false);
 }
 
 static const struct tdb_methods transaction_methods = {
@@ -459,38 +459,38 @@ static void _tdb_transaction_cancel(struct tdb_context *tdb)
        int i;
        enum TDB_ERROR ecode;
 
-       if (tdb->tdb2.transaction == NULL) {
+       if (tdb->transaction == NULL) {
                tdb_logerr(tdb, TDB_ERR_EINVAL, TDB_LOG_USE_ERROR,
                           "tdb_transaction_cancel: no transaction");
                return;
        }
 
-       if (tdb->tdb2.transaction->nesting != 0) {
-               tdb->tdb2.transaction->transaction_error = 1;
-               tdb->tdb2.transaction->nesting--;
+       if (tdb->transaction->nesting != 0) {
+               tdb->transaction->transaction_error = 1;
+               tdb->transaction->nesting--;
                return;
        }
 
-       tdb->file->map_size = tdb->tdb2.transaction->old_map_size;
+       tdb->file->map_size = tdb->transaction->old_map_size;
 
        /* free all the transaction blocks */
-       for (i=0;i<tdb->tdb2.transaction->num_blocks;i++) {
-               if (tdb->tdb2.transaction->blocks[i] != NULL) {
-                       free(tdb->tdb2.transaction->blocks[i]);
+       for (i=0;i<tdb->transaction->num_blocks;i++) {
+               if (tdb->transaction->blocks[i] != NULL) {
+                       free(tdb->transaction->blocks[i]);
                }
        }
-       SAFE_FREE(tdb->tdb2.transaction->blocks);
+       SAFE_FREE(tdb->transaction->blocks);
 
-       if (tdb->tdb2.transaction->magic_offset) {
-               const struct tdb_methods *methods = tdb->tdb2.transaction->io_methods;
+       if (tdb->transaction->magic_offset) {
+               const struct tdb_methods *methods = tdb->transaction->io_methods;
                uint64_t invalid = TDB_RECOVERY_INVALID_MAGIC;
 
                /* remove the recovery marker */
-               ecode = methods->twrite(tdb, tdb->tdb2.transaction->magic_offset,
+               ecode = methods->twrite(tdb, tdb->transaction->magic_offset,
                                        &invalid, sizeof(invalid));
                if (ecode == TDB_SUCCESS)
                        ecode = transaction_sync(tdb,
-                                                tdb->tdb2.transaction->magic_offset,
+                                                tdb->transaction->magic_offset,
                                                 sizeof(invalid));
                if (ecode != TDB_SUCCESS) {
                        tdb_logerr(tdb, ecode, TDB_LOG_ERROR,
@@ -503,14 +503,14 @@ static void _tdb_transaction_cancel(struct tdb_context *tdb)
                tdb_allrecord_unlock(tdb, tdb->file->allrecord_lock.ltype);
 
        /* restore the normal io methods */
-       tdb->tdb2.io = tdb->tdb2.transaction->io_methods;
+       tdb->io = tdb->transaction->io_methods;
 
        tdb_transaction_unlock(tdb, F_WRLCK);
 
        if (tdb_has_open_lock(tdb))
                tdb_unlock_open(tdb, F_WRLCK);
 
-       SAFE_FREE(tdb->tdb2.transaction);
+       SAFE_FREE(tdb->transaction);
 }
 
 /*
@@ -542,7 +542,7 @@ _PUBLIC_ enum TDB_ERROR tdb_transaction_start(struct tdb_context *tdb)
        }
 
        /* cope with nested tdb_transaction_start() calls */
-       if (tdb->tdb2.transaction != NULL) {
+       if (tdb->transaction != NULL) {
                if (!(tdb->flags & TDB_ALLOW_NESTING)) {
                        return tdb->last_error
                                = tdb_logerr(tdb, TDB_ERR_IO,
@@ -550,7 +550,7 @@ _PUBLIC_ enum TDB_ERROR tdb_transaction_start(struct tdb_context *tdb)
                                             "tdb_transaction_start:"
                                             " already inside transaction");
                }
-               tdb->tdb2.transaction->nesting++;
+               tdb->transaction->nesting++;
                tdb->stats.transaction_nest++;
                return 0;
        }
@@ -567,9 +567,9 @@ _PUBLIC_ enum TDB_ERROR tdb_transaction_start(struct tdb_context *tdb)
                                                    " held");
        }
 
-       tdb->tdb2.transaction = (struct tdb_transaction *)
+       tdb->transaction = (struct tdb_transaction *)
                calloc(sizeof(struct tdb_transaction), 1);
-       if (tdb->tdb2.transaction == NULL) {
+       if (tdb->transaction == NULL) {
                return tdb->last_error = tdb_logerr(tdb, TDB_ERR_OOM,
                                                    TDB_LOG_ERROR,
                                                    "tdb_transaction_start:"
@@ -581,8 +581,8 @@ _PUBLIC_ enum TDB_ERROR tdb_transaction_start(struct tdb_context *tdb)
           make this async, which we will probably do in the future */
        ecode = tdb_transaction_lock(tdb, F_WRLCK);
        if (ecode != TDB_SUCCESS) {
-               SAFE_FREE(tdb->tdb2.transaction->blocks);
-               SAFE_FREE(tdb->tdb2.transaction);
+               SAFE_FREE(tdb->transaction->blocks);
+               SAFE_FREE(tdb->transaction);
                return tdb->last_error = ecode;
        }
 
@@ -595,19 +595,19 @@ _PUBLIC_ enum TDB_ERROR tdb_transaction_start(struct tdb_context *tdb)
 
        /* make sure we know about any file expansions already done by
           anyone else */
-       tdb->tdb2.io->oob(tdb, tdb->file->map_size, 1, true);
-       tdb->tdb2.transaction->old_map_size = tdb->file->map_size;
+       tdb->io->oob(tdb, tdb->file->map_size, 1, true);
+       tdb->transaction->old_map_size = tdb->file->map_size;
 
        /* finally hook the io methods, replacing them with
           transaction specific methods */
-       tdb->tdb2.transaction->io_methods = tdb->tdb2.io;
-       tdb->tdb2.io = &transaction_methods;
+       tdb->transaction->io_methods = tdb->io;
+       tdb->io = &transaction_methods;
        return tdb->last_error = TDB_SUCCESS;
 
 fail_allrecord_lock:
        tdb_transaction_unlock(tdb, F_WRLCK);
-       SAFE_FREE(tdb->tdb2.transaction->blocks);
-       SAFE_FREE(tdb->tdb2.transaction);
+       SAFE_FREE(tdb->transaction->blocks);
+       SAFE_FREE(tdb->transaction);
        return tdb->last_error = ecode;
 }
 
@@ -630,16 +630,16 @@ static tdb_len_t tdb_recovery_size(struct tdb_context *tdb)
        int i;
 
        recovery_size = 0;
-       for (i=0;i<tdb->tdb2.transaction->num_blocks;i++) {
-               if (i * PAGESIZE >= tdb->tdb2.transaction->old_map_size) {
+       for (i=0;i<tdb->transaction->num_blocks;i++) {
+               if (i * PAGESIZE >= tdb->transaction->old_map_size) {
                        break;
                }
-               if (tdb->tdb2.transaction->blocks[i] == NULL) {
+               if (tdb->transaction->blocks[i] == NULL) {
                        continue;
                }
                recovery_size += 2*sizeof(tdb_off_t);
-               if (i == tdb->tdb2.transaction->num_blocks-1) {
-                       recovery_size += tdb->tdb2.transaction->last_block_size;
+               if (i == tdb->transaction->num_blocks-1) {
+                       recovery_size += tdb->transaction->last_block_size;
                } else {
                        recovery_size += PAGESIZE;
                }
@@ -726,7 +726,7 @@ static struct tdb_recovery_record *alloc_recovery(struct tdb_context *tdb,
        size_t i;
        enum TDB_ERROR ecode;
        unsigned char *p;
-       const struct tdb_methods *old_methods = tdb->tdb2.io;
+       const struct tdb_methods *old_methods = tdb->io;
 
        rec = malloc(sizeof(*rec) + tdb_recovery_size(tdb));
        if (!rec) {
@@ -738,28 +738,28 @@ static struct tdb_recovery_record *alloc_recovery(struct tdb_context *tdb,
 
        /* We temporarily revert to the old I/O methods, so we can use
         * tdb_access_read */
-       tdb->tdb2.io = tdb->tdb2.transaction->io_methods;
+       tdb->io = tdb->transaction->io_methods;
 
        /* build the recovery data into a single blob to allow us to do a single
           large write, which should be more efficient */
        p = (unsigned char *)(rec + 1);
-       for (i=0;i<tdb->tdb2.transaction->num_blocks;i++) {
+       for (i=0;i<tdb->transaction->num_blocks;i++) {
                tdb_off_t offset;
                tdb_len_t length;
                unsigned int off;
                const unsigned char *buffer;
 
-               if (tdb->tdb2.transaction->blocks[i] == NULL) {
+               if (tdb->transaction->blocks[i] == NULL) {
                        continue;
                }
 
                offset = i * PAGESIZE;
                length = PAGESIZE;
-               if (i == tdb->tdb2.transaction->num_blocks-1) {
-                       length = tdb->tdb2.transaction->last_block_size;
+               if (i == tdb->transaction->num_blocks-1) {
+                       length = tdb->transaction->last_block_size;
                }
 
-               if (offset >= tdb->tdb2.transaction->old_map_size) {
+               if (offset >= tdb->transaction->old_map_size) {
                        continue;
                }
 
@@ -770,9 +770,9 @@ static struct tdb_recovery_record *alloc_recovery(struct tdb_context *tdb,
                                           " boundary");
                        goto fail;
                }
-               if (offset + length > tdb->tdb2.transaction->old_map_size) {
+               if (offset + length > tdb->transaction->old_map_size) {
                        /* Short read at EOF. */
-                       length = tdb->tdb2.transaction->old_map_size - offset;
+                       length = tdb->transaction->old_map_size - offset;
                }
                buffer = tdb_access_read(tdb, offset, length, false);
                if (TDB_PTR_IS_ERR(buffer)) {
@@ -781,14 +781,14 @@ static struct tdb_recovery_record *alloc_recovery(struct tdb_context *tdb,
                }
 
                /* Skip over anything the same at the start. */
-               off = same(tdb->tdb2.transaction->blocks[i], buffer, length);
+               off = same(tdb->transaction->blocks[i], buffer, length);
                offset += off;
 
                while (off < length) {
                        tdb_len_t len1;
                        unsigned int samelen;
 
-                       len1 = different(tdb->tdb2.transaction->blocks[i] + off,
+                       len1 = different(tdb->transaction->blocks[i] + off,
                                        buffer + off, length - off,
                                        sizeof(offset) + sizeof(len1) + 1,
                                        &samelen);
@@ -806,12 +806,12 @@ static struct tdb_recovery_record *alloc_recovery(struct tdb_context *tdb,
        }
 
        *len = p - (unsigned char *)(rec + 1);
-       tdb->tdb2.io = old_methods;
+       tdb->io = old_methods;
        return rec;
 
 fail:
        free(rec);
-       tdb->tdb2.io = old_methods;
+       tdb->io = old_methods;
        return TDB_ERR_PTR(ecode);
 }
 
@@ -822,7 +822,7 @@ static tdb_off_t create_recovery_area(struct tdb_context *tdb,
        tdb_off_t off, recovery_off;
        tdb_len_t addition;
        enum TDB_ERROR ecode;
-       const struct tdb_methods *methods = tdb->tdb2.transaction->io_methods;
+       const struct tdb_methods *methods = tdb->transaction->io_methods;
 
        /* round up to a multiple of page size. Overallocate, since each
         * such allocation forces us to expand the file. */
@@ -839,9 +839,9 @@ static tdb_off_t create_recovery_area(struct tdb_context *tdb,
           Also so that we don't try to expand the file again in the
           transaction commit, which would destroy the recovery
           area */
-       addition = (tdb->file->map_size - tdb->tdb2.transaction->old_map_size) +
+       addition = (tdb->file->map_size - tdb->transaction->old_map_size) +
                sizeof(*rec) + rec->max_len;
-       tdb->file->map_size = tdb->tdb2.transaction->old_map_size;
+       tdb->file->map_size = tdb->transaction->old_map_size;
        tdb->stats.transaction_expand_file++;
        ecode = methods->expand_file(tdb, addition);
        if (ecode != TDB_SUCCESS) {
@@ -854,7 +854,7 @@ static tdb_off_t create_recovery_area(struct tdb_context *tdb,
        /* we have to reset the old map size so that we don't try to
           expand the file again in the transaction commit, which
           would destroy the recovery area */
-       tdb->tdb2.transaction->old_map_size = tdb->file->map_size;
+       tdb->transaction->old_map_size = tdb->file->map_size;
 
        /* write the recovery header offset and sync - we can sync without a race here
           as the magic ptr in the recovery record has not been set */
@@ -881,9 +881,9 @@ static enum TDB_ERROR transaction_setup_recovery(struct tdb_context *tdb)
 {
        tdb_len_t recovery_size = 0;
        tdb_off_t recovery_off = 0;
-       tdb_off_t old_map_size = tdb->tdb2.transaction->old_map_size;
+       tdb_off_t old_map_size = tdb->transaction->old_map_size;
        struct tdb_recovery_record *recovery;
-       const struct tdb_methods *methods = tdb->tdb2.transaction->io_methods;
+       const struct tdb_methods *methods = tdb->transaction->io_methods;
        uint64_t magic;
        enum TDB_ERROR ecode;
 
@@ -955,21 +955,21 @@ static enum TDB_ERROR transaction_setup_recovery(struct tdb_context *tdb)
        magic = TDB_RECOVERY_MAGIC;
        tdb_convert(tdb, &magic, sizeof(magic));
 
-       tdb->tdb2.transaction->magic_offset
+       tdb->transaction->magic_offset
                = recovery_off + offsetof(struct tdb_recovery_record, magic);
 
-       ecode = methods->twrite(tdb, tdb->tdb2.transaction->magic_offset,
+       ecode = methods->twrite(tdb, tdb->transaction->magic_offset,
                                &magic, sizeof(magic));
        if (ecode != TDB_SUCCESS) {
                return tdb_logerr(tdb, ecode, TDB_LOG_ERROR,
                                  "tdb_transaction_setup_recovery:"
                                  " failed to write recovery magic");
        }
-       transaction_write_existing(tdb, tdb->tdb2.transaction->magic_offset,
+       transaction_write_existing(tdb, tdb->transaction->magic_offset,
                                   &magic, sizeof(magic));
 
        /* ensure the recovery magic marker is on disk */
-       return transaction_sync(tdb, tdb->tdb2.transaction->magic_offset,
+       return transaction_sync(tdb, tdb->transaction->magic_offset,
                                sizeof(magic));
 }
 
@@ -978,20 +978,20 @@ static enum TDB_ERROR _tdb_transaction_prepare_commit(struct tdb_context *tdb)
        const struct tdb_methods *methods;
        enum TDB_ERROR ecode;
 
-       if (tdb->tdb2.transaction == NULL) {
+       if (tdb->transaction == NULL) {
                return tdb_logerr(tdb, TDB_ERR_EINVAL, TDB_LOG_USE_ERROR,
                                  "tdb_transaction_prepare_commit:"
                                  " no transaction");
        }
 
-       if (tdb->tdb2.transaction->prepared) {
+       if (tdb->transaction->prepared) {
                _tdb_transaction_cancel(tdb);
                return tdb_logerr(tdb, TDB_ERR_EINVAL, TDB_LOG_USE_ERROR,
                                  "tdb_transaction_prepare_commit:"
                                  " transaction already prepared");
        }
 
-       if (tdb->tdb2.transaction->transaction_error) {
+       if (tdb->transaction->transaction_error) {
                _tdb_transaction_cancel(tdb);
                return tdb_logerr(tdb, TDB_ERR_EINVAL, TDB_LOG_ERROR,
                                  "tdb_transaction_prepare_commit:"
@@ -999,16 +999,16 @@ static enum TDB_ERROR _tdb_transaction_prepare_commit(struct tdb_context *tdb)
        }
 
 
-       if (tdb->tdb2.transaction->nesting != 0) {
+       if (tdb->transaction->nesting != 0) {
                return TDB_SUCCESS;
        }
 
        /* check for a null transaction */
-       if (tdb->tdb2.transaction->blocks == NULL) {
+       if (tdb->transaction->blocks == NULL) {
                return TDB_SUCCESS;
        }
 
-       methods = tdb->tdb2.transaction->io_methods;
+       methods = tdb->transaction->io_methods;
 
        /* upgrade the main transaction lock region to a write lock */
        ecode = tdb_allrecord_upgrade(tdb, TDB_HASH_LOCK_START);
@@ -1025,23 +1025,23 @@ static enum TDB_ERROR _tdb_transaction_prepare_commit(struct tdb_context *tdb)
 
        /* Since we have whole db locked, we don't need the expansion lock. */
        if (!(tdb->flags & TDB_NOSYNC)) {
-               /* Sets up tdb->tdb2.transaction->recovery and
-                * tdb->tdb2.transaction->magic_offset. */
+               /* Sets up tdb->transaction->recovery and
+                * tdb->transaction->magic_offset. */
                ecode = transaction_setup_recovery(tdb);
                if (ecode != TDB_SUCCESS) {
                        return ecode;
                }
        }
 
-       tdb->tdb2.transaction->prepared = true;
+       tdb->transaction->prepared = true;
 
        /* expand the file to the new size if needed */
-       if (tdb->file->map_size != tdb->tdb2.transaction->old_map_size) {
+       if (tdb->file->map_size != tdb->transaction->old_map_size) {
                tdb_len_t add;
 
-               add = tdb->file->map_size - tdb->tdb2.transaction->old_map_size;
+               add = tdb->file->map_size - tdb->transaction->old_map_size;
                /* Restore original map size for tdb_expand_file */
-               tdb->file->map_size = tdb->tdb2.transaction->old_map_size;
+               tdb->file->map_size = tdb->transaction->old_map_size;
                ecode = methods->expand_file(tdb, add);
                if (ecode != TDB_SUCCESS) {
                        return ecode;
@@ -1069,7 +1069,7 @@ _PUBLIC_ enum TDB_ERROR tdb_transaction_commit(struct tdb_context *tdb)
        int i;
        enum TDB_ERROR ecode;
 
-       if (tdb->tdb2.transaction == NULL) {
+       if (tdb->transaction == NULL) {
                return tdb->last_error = tdb_logerr(tdb, TDB_ERR_EINVAL,
                                                    TDB_LOG_USE_ERROR,
                                                    "tdb_transaction_commit:"
@@ -1078,18 +1078,18 @@ _PUBLIC_ enum TDB_ERROR tdb_transaction_commit(struct tdb_context *tdb)
 
        tdb_trace(tdb, "tdb_transaction_commit");
 
-       if (tdb->tdb2.transaction->nesting != 0) {
-               tdb->tdb2.transaction->nesting--;
+       if (tdb->transaction->nesting != 0) {
+               tdb->transaction->nesting--;
                return tdb->last_error = TDB_SUCCESS;
        }
 
        /* check for a null transaction */
-       if (tdb->tdb2.transaction->blocks == NULL) {
+       if (tdb->transaction->blocks == NULL) {
                _tdb_transaction_cancel(tdb);
                return tdb->last_error = TDB_SUCCESS;
        }
 
-       if (!tdb->tdb2.transaction->prepared) {
+       if (!tdb->transaction->prepared) {
                ecode = _tdb_transaction_prepare_commit(tdb);
                if (ecode != TDB_SUCCESS) {
                        _tdb_transaction_cancel(tdb);
@@ -1097,41 +1097,41 @@ _PUBLIC_ enum TDB_ERROR tdb_transaction_commit(struct tdb_context *tdb)
                }
        }
 
-       methods = tdb->tdb2.transaction->io_methods;
+       methods = tdb->transaction->io_methods;
 
        /* perform all the writes */
-       for (i=0;i<tdb->tdb2.transaction->num_blocks;i++) {
+       for (i=0;i<tdb->transaction->num_blocks;i++) {
                tdb_off_t offset;
                tdb_len_t length;
 
-               if (tdb->tdb2.transaction->blocks[i] == NULL) {
+               if (tdb->transaction->blocks[i] == NULL) {
                        continue;
                }
 
                offset = i * PAGESIZE;
                length = PAGESIZE;
-               if (i == tdb->tdb2.transaction->num_blocks-1) {
-                       length = tdb->tdb2.transaction->last_block_size;
+               if (i == tdb->transaction->num_blocks-1) {
+                       length = tdb->transaction->last_block_size;
                }
 
                ecode = methods->twrite(tdb, offset,
-                                       tdb->tdb2.transaction->blocks[i], length);
+                                       tdb->transaction->blocks[i], length);
                if (ecode != TDB_SUCCESS) {
                        /* we've overwritten part of the data and
                           possibly expanded the file, so we need to
                           run the crash recovery code */
-                       tdb->tdb2.io = methods;
+                       tdb->io = methods;
                        tdb_transaction_recover(tdb);
 
                        _tdb_transaction_cancel(tdb);
 
                        return tdb->last_error = ecode;
                }
-               SAFE_FREE(tdb->tdb2.transaction->blocks[i]);
+               SAFE_FREE(tdb->transaction->blocks[i]);
        }
 
-       SAFE_FREE(tdb->tdb2.transaction->blocks);
-       tdb->tdb2.transaction->num_blocks = 0;
+       SAFE_FREE(tdb->transaction->blocks);
+       tdb->transaction->num_blocks = 0;
 
        /* ensure the new data is on disk */
        ecode = transaction_sync(tdb, 0, tdb->file->map_size);
@@ -1156,7 +1156,7 @@ _PUBLIC_ enum TDB_ERROR tdb_transaction_commit(struct tdb_context *tdb)
 
        /* use a transaction cancel to free memory and remove the
           transaction locks: it "restores" map_size, too. */
-       tdb->tdb2.transaction->old_map_size = tdb->file->map_size;
+       tdb->transaction->old_map_size = tdb->file->map_size;
        _tdb_transaction_cancel(tdb);
 
        return tdb->last_error = TDB_SUCCESS;
@@ -1218,7 +1218,7 @@ enum TDB_ERROR tdb_transaction_recover(struct tdb_context *tdb)
        }
 
        /* read the full recovery data */
-       ecode = tdb->tdb2.io->tread(tdb, recovery_head + sizeof(rec), data,
+       ecode = tdb->io->tread(tdb, recovery_head + sizeof(rec), data,
                                    rec.len);
        if (ecode != TDB_SUCCESS) {
                return tdb_logerr(tdb, ecode, TDB_LOG_ERROR,
@@ -1236,7 +1236,7 @@ enum TDB_ERROR tdb_transaction_recover(struct tdb_context *tdb)
                memcpy(&len, p + sizeof(ofs), sizeof(len));
                p += sizeof(ofs) + sizeof(len);
 
-               ecode = tdb->tdb2.io->twrite(tdb, ofs, p, len);
+               ecode = tdb->io->twrite(tdb, ofs, p, len);
                if (ecode != TDB_SUCCESS) {
                        free(data);
                        return tdb_logerr(tdb, ecode, TDB_LOG_ERROR,