tools: fix warnings from Ubuntu strict compiler.

tdb: handle processes dying during transaction commit.

tdb transactions were designed to be robust against the machine
powering off, but interestingly were never designed to handle the case
where an administrator kill -9's a process during commit.  Because
recovery is only done on tdb_open, processes with the tdb already
mapped will simply use it despite it being corrupt and needing
recovery.

The solution to this is to check for recovery every time we grab a
data lock: we could have gained the lock because a process just died.
This has no measurable cost: here is the time for tdbtorture -s 0 -n 1
-l 10000:

Before:
2.75 2.50 2.81 3.19 2.91 2.53 2.72 2.50 2.78 2.77 = Avg 2.75

After:
2.81 2.57 3.42 2.49 3.02 2.49 2.84 2.48 2.80 2.43 = Avg 2.74

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

tdb: cleanup: tdb_lock_list helper to cover tdb_lock and tdb_lock_nonblock

Reduce code duplication, and also gives us a central point for the next
patch which wants to cover all list locks.

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

tdb: remove lock ops

Now the transaction code uses the standard allrecord lock, that stops
us from trying to grab any per-record locks anyway.  We don't need to
have special noop lock ops for transactions.

This is a nice simplification: if you see brlock, you know it's really
going to grab a lock.

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

tdb: more testcase fixup.

tdb: suppress record write locks when allrecord lock is taken.

Records themselves get (read) locked by the traversal code against delete.
Interestingly, this locking isn't done when the allrecord lock has been
taken, though the allrecord lock until recently didn't cover the actual
records (it now goes to end of file).

The write record lock, grabbed by the delete code, is not suppressed by
the allrecord lock, which causes us to punch a hole in that lock when we
release the write record lock.  Make this consistent: *no* record locks
of any kind when the allrecord lock is taken.

tdb: new test, cleanup old tests by centralizing lock tracking.

tdb: fix test to remove warning, and don't fail when tdb_check() barfs.

tdb: don't reduce file size on transaction recovery.

There's little point in ever shrinking the file, and it definitely breaks in the case where a process has died during a transaction commit and other processes have the tdb mapped.

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

tdb:  fix recovery reuse after crash (from SAMBA)

commit b37b452cb8c1f56b37b04abe7bffdede371ca361
Author: Rusty Russell <rusty@rustcorp.com.au>
Date:   Thu Feb 4 23:59:54 2010 +1030

    tdb: fix recovery reuse after crash

    If a process (or the machine) dies after just after writing the
    recovery head (pointing at the end of file), the recovery record will filled
    with 0x42.  This will not invoke a recovery on open, since rec.magic
    != TDB_RECOVERY_MAGIC.

    Unfortunately, the first transaction commit will happily reuse that
    area: tdb_recovery_allocate() doesn't check the magic.  The recovery
    record has length 0x42424242, and it writes that back into the
    now-valid-looking transaction header) for the next comer (which
    happens to be tdb_wipe_all in my tests).

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

tdb: fix tdbtorture seed printing, plus remove CLEAR_IF_FIRST

With killing children, CLEAR_IF_FIRST can happen quite a bit.

tdb: cleanup: remove ltype argument from _tdb_transaction_cancel.

Now the transaction allrecord lock the standard one, and thus is cleaned
in tdb_release_extra_locks(), _tdb_transaction_cancel() doesn't need to
know what type it is.

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

tdb: tdb_allrecord_lock/tdb_allrecord_unlock/tdb_allrecord_upgrade

Centralize locking of all chains of the tdb; rename _tdb_lockall to
tdb_allrecord_lock and _tdb_unlockall to tdb_allrecord_unlock, and
tdb_brlock_upgrade to tdb_allrecord_upgrade.

Then we use this in the transaction code.  Unfortunately, if the transaction
code records that it has grabbed the allrecord lock read-only, write locks
will fail, so we treat this upgradable lock as a write lock, and mark it
as upgradable using the otherwise-unused offset field.

One subtlety: now the transaction code is using the allrecord_lock, the
tdb_release_extra_locks() function drops it for us, so we no longer need
to do it manually in _tdb_transaction_cancel.

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

tdb: cleanup: always grab allrecord lock to infinity.

We were previously inconsistent with our "global" lock: the
transaction code grabbed it from FREELIST_TOP to end of file, and the
rest of the code grabbed it from FREELIST_TOP to end of the hash
chains.  Change it to always grab to end of file for simplicity.

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

tdb: remove num_locks

This was redundant before this patch series: it mirrored num_lockrecs
exactly.  It still does.

Also, skip useless branch when locks == 1: unconditional assignment is
cheaper anyway.

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

tdb: use tdb_nest_lock() for seqnum lock.

This is pure overhead, but it centralizes the locking.  Realloc (esp. as
most implementations are lazy) is fast compared to the fnctl anyway.

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

tdb: use tdb_nest_lock() for active lock.

Rather than a boutique lock and a separate nest count, use our
newly-generic nested lock tracking for the active lock.

Note that the tdb_have_extra_locks() and tdb_release_extra_locks()
functions have to skip over this lock now it is tracked.

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

tdb: use tdb_nest_lock() for open lock.

This never nests, so it's overkill, but it centralizes the locking into
lock.c and removes the ugly flag in the transaction code to track whether
we have the lock or not.

Note that we have a temporary hack so this places a real lock, despite
the fact that we are in a transaction.

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

tdb: use tdb_nest_lock() for transaction lock.

Rather than a boutique lock and a separate nest count, use our
newly-generic nested lock tracking for the transaction lock.

Note that the tdb_have_extra_locks() and tdb_release_extra_locks()
functions have to skip over this lock now it is tracked.

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

tdb: cleanup: find_nestlock() helper.

Factor out two loops which find locks; we are going to introduce a couple
more so a helper makes sense.

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

tdb: cleanup: tdb_release_extra_locks() helper

Move locking intelligence back into lock.c.

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

tdb: cleanup: tdb_have_extra_locks() helper

In many places we check whether locks are held: add a helper to do this.

The _tdb_lockall() case has already checked for the allrecord lock, so
the extra work done by tdb_have_extra_locks() is merely redundant.

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

tdb: don't suppress the transaction lock because of the allrecord lock.

tdb_transaction_lock() and tdb_transaction_unlock() do nothing if we
hold the allrecord lock.  However, the two locks don't overlap, so
this is wrong.

This simplification makes the transaction lock a straight-forward nested
lock.

There are two callers for these functions:
1) The transaction code, which already makes sure the allrecord_lock
   isn't held.
2) The traverse code, which wants to stop transactions whether it has the
   allrecord lock or not.  There have been deadlocks here before, however
   this should not bring them back (I hope!)

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

tdb: cleanup: tdb_nest_lock/tdb_nest_unlock

Because fcntl locks don't nest, we track them in the tdb->lockrecs array
and only place/release them when the count goes to 1/0.  We only do this
for record locks, so we simply place the list number (or -1 for the free
list) in the structure.

To generalize this:

1) Put the offset rather than list number in struct tdb_lock_type.
2) Rename _tdb_lock() to tdb_nest_lock, make it non-static and move the
   allrecord check out to the callers (except the mark case which doesn't
   care).
3) Rename _tdb_unlock() to tdb_nest_unlock(), make it non-static and
   move the allrecord out to the callers (except mark again).

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

tdb: cleanup: rename global_lock to allrecord_lock.

The word global is overloaded in tdb.  The global_lock inside struct
tdb_context is used to indicate we hold a lock across all the chains.

Rename it to allrecord_lock.

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

tdb: cleanup: rename GLOBAL_LOCK to OPEN_LOCK.

The word global is overloaded in tdb.  The GLOBAL_LOCK offset is used at
open time to serialize initialization (and by the transaction code to block
open).

Rename it to OPEN_LOCK.

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

tdb: commit 9b987e3923f7e8714acec6a2929435b1e6016645 from SAMBA

Author: Volker Lendecke <vl@samba.org>
Date:   Tue Aug 12 22:31:52 2008 +0200

    Attempt to fix bug 5684

    With the ctdb checkin dde9f3f006 tdb optimized out write lock checks for
    write-enabled transaction. Sadly, this also removed the possibility to ever
    remove dead records left over from tdb_delete calls within a transaction.

    Tridge, please check this! Did dde9f3f006 have any reason beyond performance
    optimizations?

    Thanks,

    Volker
    (This used to be commit 3f884c4ae36f3260e63626bdd4989d9258ae6497)

tdb: port trivial differences across from SAMBA
Whitespace and C++-compatibility mainly.

Fix Joey's report of rename failing across moint points.

tdb: use TDB_RECOVERY_INVALID_MAGIC rather than 0

Add -k option to tdbtorture, run tdb_check at end.

This patch is made larger by moving the work out to a separate function: with -k, the parent can't run the ops itself but the children must do it.

Don't use ~ in path, seems less reliable?

tdb: new test for dying during a transaction.

This demonstrates some serious failings, which get cleaned up in
following patches.

ccanlint: fix scoring, add score details to --verbose.

Use raw .o files rather than -lccan

Import 898b5edfe757cb145960b8f3631029bfd5592119 from ctdb:
Author: Volker Lendecke <vl@samba.org>  2010-01-30 03:51:09

    tdb: fix an early release of the global lock that can cause data corruption

    There was a bug in tdb where the

                    tdb_brlock(tdb, GLOBAL_LOCK, F_UNLCK, F_SETLKW, 0, 1);

    (ending the transaction-"mutex") was done before the

                            /* remove the recovery marker */

    This means that when a transaction is committed there is a window where another
    opener of the file sees the transaction marker while the transaction committer
    is still fully functional and working on it. This led to transaction being
    rolled back by that second opener of the file while transaction_commit() gave
    no error to the caller.

    This patch moves the F_UNLCK to after the recovery marker was removed, closing
    this window.

Fix bug where we used old clear_if_first when doing I/O in open.
Add more logging.

Change default behaviour: disallow nesting (safer).

Unlike the upstream, we don't have a stable ABI/API.

Import c1c0ede32dc00ed619d1cf5fda40a9de43995f3a from ctdb:
   tdb: add TDB_DISALLOW_NESTING and make TDB_ALLOW_NESTING the default behavior

    We need to keep TDB_ALLOW_NESTING as default behavior,
    so that existing code continues to work.

    However we may change the default together with a major version
    number change in future.

    metze
    (cherry picked from samba commit 3b9f19ed919fef2e88b2f92ae541e07bc7379cd1)

Signed-off-by: Stefan Metzmacher <metze@samba.org>

Import 855391c1e37012b0d6c673a304bb8da8a1efcd72 from ctdb:
    tdb: always set tdb->tracefd to -1 to be safe on goto fail

    metze
    (cherry picked from samba commit 85449b7bcc4bd7948bea38b5514a02357950a002)

Signed-off-by: Stefan Metzmacher <metze@samba.org>

Import f5c992bdaeb73ef726ff4728a9922721474cd6f5 from ctdb:

    tdb: reset tdb->fd to -1 in tdb_close()

    So that erroneous double tdb_close() calls do not try to close() same
    fd again. This is like SAFE_FREE() but for fd.

Signed-off-by: Kirill Smelkov <kirr@mns.spb.ru>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
    (cherry picked from samba commit b4424f8234a78a79fb2d71d46ca208b4f12e0f9e)

Signed-off-by: Stefan Metzmacher <metze@samba.org>

Import 470750fa2e3cf987f10de48451b1ee13aab03907 from ctdb:
    tdb: detect tdb store of identical records and skip

    This can help with ldb where we rewrite the index records
    (cherry picked from samba commit d4c0e8fdf063f88032c32de7ece60d502b322089)

Signed-off-by: Stefan Metzmacher <metze@samba.org>

Import 03b3682e3fa53c9f5fdf2c4beac8b5d030fd2630 from ctdb:

    tdb: rename 'struct list_struct' into 'struct tdb_record'

    metze
    (cherry picked from samba commit 3b62e250c066f44d0ab08a7db037b6b4f74a914b)

Signed-off-by: Stefan Metzmacher <metze@samba.org>

New test: reveals race (found by Volker) when open occurs during transaction commit.

ccanlint: fix directory issues properly.

Fix valgrind running with debugger.

Fix config for browsing.

Fix browser support.

Make manifest code do chdir into appropriate directory.

New test: run tests under valgrind.
(Also, remove bogus test dependency for hdr include check)

Joey's btree module.

More --recursive fixes for manifest listing.

Fix ccan.tar.bz2 tarball.

Fix tests: path change because they're now run under ccanlint (from their dir)

Makefile fixes: we now do dependencies properly for each ccan module.

Fix getting sub-depends.

More header fixups: now it all compiles again.

Remove old run-tests, clean up #includes to all be <ccan/...

New asort routine; unf. breaks under -Wmissing-prototypes etc :(

New talloc_set for auto-cleanup.

Update where browsing points.

asearch: typesafe binary search.

Don't print full fail results on normal check

tdb: add -t (always transactional) to tdbtorture

tdb: add logging to tdb_check for more verbose answers.

tdb: use logging and tdb_check in tdbtool

tdb: Add tdbtool to 'clean'

Import tdbtool from SAMBA (e440a2e11e78a562f97971c0dfe0cf3f694996ff)

tools/ccanlint: build tests are now compulsory
Offer to run debugger when test fails, with breakpoint.

Web updates.

tdb: avoid checkfn on dead records, reorganize and comment code.
Add test for non-mmap tdbs.

ccan/tdb: tdb_check() function.

sparse_bsearch: new module

typesafe_cb: more support for typesafe compare functions.

Fix documentation: actually, always evaluates to 0.

tools: more build convenience work

add EXCLUDES= with more obscure modules.
use ccanlint for "make check", finally.

tools: fix compile warning under Ubuntu

tdb: remove seqnum field from header
Unused since " tdb: no longer need seqnum store hack as we can read after prepare."

Fix "make check": this is temporary until we use ccanlint for it.

More test fixes.

tap: pass tests after ccanlint changes.

Now we compile everything into the tmp dir.

ccan_depends: Fix up after tools changes.

ccanlint: only compile _info once; speeds tdb test from 18 to 16 seconds.

Generally clean up temp file handling.

Use -O not -O3: reduces ccan/tdb test time from 24 to 18 seconds.

ccanlint: don't use total_score to separate kinds of tests; we have subdirs

ccanlint: compile and run tests.
This means we should skip building if there are no C files in module: running tests requires building the module, but not necessarily that it has any C files.

tdb: no longer need seqnum store hack as we can read after prepare.

tdb: allow reads after prepare commit
(Imported from SAMBA commit 46c99ec2a3781d53138245182345c6c2ddd9a258:
From: Andrew Tridgell <tridge@samba.org>
Date: Tue, 15 Sep 2009 14:04:22 -0700

We previously only allowed a commit to happen after a prepare
commit. It is in fact safe to allow reads between a prepare and a
commit, and the s4 replication code can make use of that, so allow it.

Build tests for ccan.
More sophisticated skipping: skip dependencies when one fails as well.
Allow tests to change their total_score; only access it after running (other than to check it's non-zero).

Don't run dependent tests if one fails.

Dependency checking (make sure .o files exist, prereq to building)

Fix grab_file on other than regular files.

Idris' dependency work.

tdb: fix ecode setting on nonblocking brlock

This bug was introduced in "Wean off TDB_ERRCODE.".

tdb: fix the unlock calls on the GLOBAL_LOCK from previous commit.

Despite the name, they're simple byte locks, not whole-file.

tdb: benchmark target.

tdb: fix locking unlocking error introduced in cleanup

tdb: locking cleanup

Explicitly split lock and unlock, for future replacement with user-supplied functions.
Use explicit flags enum for marking, blocking and probing.
Indicate upon unlock whether we had a read or write lock (POSIX doesn't care, but
wrappers might, and it's nice to be explicit).

Don't rely on terrible dup2 trick, use proper infrastructure for external agent.