tdb2: use tdb->flags & TDB_RDONLY instead of tdb->read_only for TDB1 code.
authorRusty Russell <rusty@rustcorp.com.au>
Wed, 31 Aug 2011 05:58:16 +0000 (15:28 +0930)
committerRusty Russell <rusty@rustcorp.com.au>
Wed, 31 Aug 2011 05:58:16 +0000 (15:28 +0930)
There's also a semantic change here: for tdb1, being read-only meant no
locking, and it was an error to try to lock a r/o database.  For TDB2, you'd
need to specify TDB_NOLOCK, which suppresses locking silently.

ccan/tdb2/tdb1_check.c
ccan/tdb2/tdb1_io.c
ccan/tdb2/tdb1_lock.c
ccan/tdb2/tdb1_open.c
ccan/tdb2/tdb1_private.h
ccan/tdb2/tdb1_summary.c
ccan/tdb2/tdb1_tdb.c
ccan/tdb2/tdb1_transaction.c
ccan/tdb2/tdb1_traverse.c
ccan/tdb2/test/run-tdb1-3G-file.c

index edbfd86bcfe1041168931f6102e014d3e6c58bbf..9097017ea14a0eb36e945093705752e4c3dcb4c2 100644 (file)
@@ -334,9 +334,8 @@ int tdb1_check(struct tdb1_context *tdb,
        tdb1_len_t dead;
        bool locked;
 
-       /* Read-only databases use no locking at all: it's best-effort.
-        * We may have a write lock already, so skip that case too. */
-       if (tdb->read_only || tdb->file->allrecord_lock.count != 0) {
+       /* We may have a write lock already, so don't re-lock. */
+       if (tdb->file->allrecord_lock.count != 0) {
                locked = false;
        } else {
                if (tdb1_lockall_read(tdb) == -1)
index f61db51e24d6d637c59c8d38363db6caf41e6c7f..a738bd090190d4da1eb4a8edc2680788dc4aade7 100644 (file)
@@ -82,7 +82,7 @@ static int tdb1_write(struct tdb1_context *tdb, tdb1_off_t off,
                return 0;
        }
 
-       if (tdb->read_only || tdb->traverse_read) {
+       if ((tdb->flags & TDB_RDONLY) || tdb->traverse_read) {
                tdb->last_error = TDB_ERR_RDONLY;
                return -1;
        }
@@ -213,8 +213,14 @@ void tdb1_mmap(struct tdb1_context *tdb)
 
 #if HAVE_MMAP
        if (!(tdb->flags & TDB_NOMMAP)) {
+               int mmap_flags;
+               if ((tdb->open_flags & O_ACCMODE) == O_RDONLY)
+                       mmap_flags = PROT_READ;
+               else
+                       mmap_flags = PROT_READ | PROT_WRITE;
+
                tdb->file->map_ptr = mmap(NULL, tdb->file->map_size,
-                                   PROT_READ|(tdb->read_only? 0:PROT_WRITE),
+                                   mmap_flags,
                                    MAP_SHARED|MAP_FILE, tdb->file->fd, 0);
 
                /*
@@ -241,7 +247,7 @@ static int tdb1_expand_file(struct tdb1_context *tdb, tdb1_off_t size, tdb1_off_
 {
        char buf[8192];
 
-       if (tdb->read_only || tdb->traverse_read) {
+       if ((tdb->flags & TDB_RDONLY) || tdb->traverse_read) {
                tdb->last_error = TDB_ERR_RDONLY;
                return -1;
        }
index 65fa1c123c5086b208448ee0dcb8487f1073d965..1b7ab7c7dc6776b0186c0ab56facd464cacc2c1f 100644 (file)
@@ -329,8 +329,8 @@ int tdb1_allrecord_lock(struct tdb1_context *tdb, int ltype,
 /* unlock entire db */
 int tdb1_allrecord_unlock(struct tdb1_context *tdb, int ltype)
 {
-       /* There are no locks on read-only dbs */
-       if (tdb->read_only || tdb->traverse_read) {
+       /* Don't try this during r/o traversal! */
+       if (tdb->traverse_read) {
                tdb->last_error = TDB_ERR_LOCK;
                return -1;
        }
index c01cc6e0614ecf2604020c4a55fcb6ed40935661..73f7f26710e1c1a3691d98acdf9bedfa275cf75b 100644 (file)
@@ -250,7 +250,7 @@ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int tdb1_flag
        if (hash_size == 0)
                hash_size = TDB1_DEFAULT_HASH_SIZE;
        if ((open_flags & O_ACCMODE) == O_RDONLY) {
-               tdb->read_only = 1;
+               tdb->flags |= TDB_RDONLY;
                /* read only databases don't do locking */
                tdb->flags |= TDB_NOLOCK;
        }
index 22a6f7972f2c89219f4a7eb99af00087f0634d98..bff967b25b883ea38fe5992489f8dffd9294ae59 100644 (file)
@@ -217,7 +217,6 @@ struct tdb1_context {
        void *hash_data;
        uint64_t hash_seed;
 
-       bool read_only; /* opened read-only */
        int traverse_read; /* read-only traversal */
        int traverse_write; /* read-write traversal */
        struct tdb1_header header; /* a cached copy of the header */
index 329cb268fc2aefe7af023d396a9ec983bfcc0aa7..6e82eec5f2165fcf88ce84fc9f51d9a85bf92b3d 100644 (file)
@@ -94,9 +94,8 @@ char *tdb1_summary(struct tdb1_context *tdb)
        size_t len, unc = 0;
        struct tdb1_record recovery;
 
-       /* Read-only databases use no locking at all: it's best-effort.
-        * We may have a write lock already, so skip that case too. */
-       if (tdb->read_only || tdb->file->allrecord_lock.count != 0) {
+       /* We may have a write lock already, so don't lock. */
+       if (tdb->file->allrecord_lock.count != 0) {
                locked = false;
        } else {
                if (tdb1_lockall_read(tdb) == -1)
index 8392e71240f33c70e1747d62b06ad9ba71df4c52..827b4fcf093170f677c15b6f00d34d4efbd031f1 100644 (file)
@@ -283,7 +283,7 @@ int tdb1_do_delete(struct tdb1_context *tdb, tdb1_off_t rec_ptr, struct tdb1_rec
        tdb1_off_t last_ptr, i;
        struct tdb1_record lastrec;
 
-       if (tdb->read_only || tdb->traverse_read) return -1;
+       if ((tdb->flags & TDB_RDONLY) || tdb->traverse_read) return -1;
 
        if (((tdb->traverse_write != 0) && (!TDB1_DEAD(rec))) ||
            tdb1_write_lock_record(tdb, rec_ptr) == -1) {
@@ -601,7 +601,7 @@ int tdb1_store(struct tdb1_context *tdb, TDB_DATA key, TDB_DATA dbuf, int flag)
        uint32_t hash;
        int ret;
 
-       if (tdb->read_only || tdb->traverse_read) {
+       if ((tdb->flags & TDB_RDONLY) || tdb->traverse_read) {
                tdb->last_error = TDB_ERR_RDONLY;
                return -1;
        }
index f0623025f95268f12a89febf9246475946e3fd8a..cf77a35996d5543df258d0237e4682c0ac5f2d31 100644 (file)
@@ -418,7 +418,7 @@ static const struct tdb1_methods transaction1_methods = {
 static int _tdb1_transaction_start(struct tdb1_context *tdb)
 {
        /* some sanity checks */
-       if (tdb->read_only || (tdb->flags & TDB_INTERNAL) || tdb->traverse_read) {
+       if ((tdb->flags & TDB_RDONLY) || (tdb->flags & TDB_INTERNAL) || tdb->traverse_read) {
                tdb->last_error = tdb_logerr(tdb, TDB_ERR_EINVAL, TDB_LOG_USE_ERROR,
                                        "tdb1_transaction_start: cannot start a"
                                        " transaction on a read-only or"
@@ -1198,7 +1198,7 @@ int tdb1_transaction_recover(struct tdb1_context *tdb)
                return 0;
        }
 
-       if (tdb->read_only) {
+       if (tdb->flags & TDB_RDONLY) {
                tdb->last_error = tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
                                        "tdb1_transaction_recover:"
                                        " attempt to recover read only"
index 8b09e3874a966d54bd266d92d5894e8fea6cc63a..fe9cd59477b238f535804ba7b749cc393ac6c78b 100644 (file)
@@ -119,7 +119,7 @@ static tdb1_off_t tdb1_next_lock(struct tdb1_context *tdb, struct tdb1_traverse_
                        /* Try to clean dead ones from old traverses */
                        current = tlock->off;
                        tlock->off = rec->next;
-                       if (!(tdb->read_only || tdb->traverse_read) &&
+                       if (!((tdb->flags & TDB_RDONLY) || tdb->traverse_read) &&
                            tdb1_do_delete(tdb, current, rec) != 0)
                                goto fail;
                }
@@ -249,7 +249,7 @@ int tdb1_traverse(struct tdb1_context *tdb,
        struct tdb1_traverse_lock tl = { NULL, 0, 0, F_WRLCK };
        int ret;
 
-       if (tdb->read_only || tdb->traverse_read) {
+       if ((tdb->flags & TDB_RDONLY) || tdb->traverse_read) {
                return tdb1_traverse_read(tdb, fn, private_data);
        }
 
index cf3db233218d8e034559ac0d374f67295d3fdf94..fcb1a0c757f7021f79628b5694a2e04e627941e8 100644 (file)
@@ -10,7 +10,7 @@ static int tdb1_expand_file_sparse(struct tdb1_context *tdb,
                                  tdb1_off_t size,
                                  tdb1_off_t addition)
 {
-       if (tdb->read_only || tdb->traverse_read) {
+       if ((tdb->flags & TDB_RDONLY) || tdb->traverse_read) {
                tdb->last_error = TDB_ERR_RDONLY;
                return -1;
        }