configurator: HAVE_BACKTRACE

failtest: simplify FAIL_PROBE.

When a failtest_hook returns fail_probe(), we start a counter to
continue for a little way.  Replace this hack with a simple flag,
which disables further failures.

Interestingly, this doesn't reduce coverage on the current modules
which use failtest.

failtest: report errors in children directly to original stderr.

This is useful for debugging failtest itself, as well as for things
like tracing.

failtest: use high-numbers file descriptors to stay out of the way.

We use file descriptors inside failtest; use dup2 to try to avoid
changing the file descriptor numbers used in the program (particularly
when programs mess with invalid file descriptors, they're likely to
still be invalid).

failtest: use a linked list for history, not an array.

This avoids a silly realloc, but more importantly it gets us closer to
being runtime extensible, as each history element can be a different
size.

tlist: implement tlist_for_each_rev

list: implement list_for_each_rev()

tdb2: consolidate testing failtest suppression routines.

Less cut & paste means less patching as failtest changes.

failtest: fix internal cut & paste bug

failtest_malloc should use p->u.malloc not p->u.calloc.  The layouts
are identical, so it doesn't matter, but it's confusing and leaves us
open to weird bugs in future should one change.

ccanlint: fix depends_build_without_features

This depends on reduce_features; currently it tends to run before
that, so it doesn't think there are any features to reduce and doesn't
build or run the tests with reduced features.

Makefile-web: push to github repo too.

Saves me doing it manually.

list: fix list element counting in provided example inside _info file

This change initializes a counter of children, otherwise is may contain
arbitrary value.

Signed-off-by: Vladimir Zapolskiy <vz@mleia.com>

cast: fix warnings with -Wextra (specifically -Wmissing-field-initializers)

As noted by Jan Engelhardt; libHX fixed this already.

list: simplify tests a little.

The two tests are identical with one line different, so make it clear.

ccanlint: fix --test-dep-graph

Broken by 758ab1f402b4 "ccanlint: drop -d, interpret any arguments as
directories, and allow multiple."

ccanlint: make fewer tests compulsory.

Compulsory means "malformed", we might get rid of it altogether, since
any test can mark "fail" and make ccanlint exit with non-zero status.

Now we only have four compulsory tests:
   info_exists               Module has _info file
   depends_exist             Module's CCAN dependencies can be found
   objects_build             Module object files can be built
   module_builds             Module can be built from object files

ccanlint: fix ccanlint -l

tdb2: don't be fascist when TDB_VERSION1 is specified.

We currently insist that a tdb file be a version1 file if tdb_open() is
passed the TDB_VERSION1 flag; we fail if it's actually a tdb2.

But that makes generic wrappers harder, and is unlikely to be what the
user wants: if they do, they can check tdb_get_flags() & TDB_VERSION1
after opening.

strset: set errno to ENOENT even if we return NULL.

It seems redundant: strset_test() and strset_clear() can only return NULL
when the string is not a member.  However, it became clear in writing
ccan/tsort that it's much more convenient for callers if we set errno
in this case too, so they can pass it up.

strmap: set errno to ENOENT even if we return NULL.

It seems redundant: strmap_get() and strmap_del() can only return NULL
when the string is not a member.  However, it became clear in writing
ccan/tsort that it's much more convenient for callers if we set errno
in this case too, so they can pass it up.

ccanlint: fix uninitialized variables in tests_pass_valgrind.

We weren't initializing the leak_info field when the test was marked
FAIL in _info (as in tdb2).

ccanlint: fix test link when given no arguments.

Fallout from commit 758ab1f402b4af3cccac09548b709deca17ef930
(ccanlint: drop -d, interpret any arguments as directories...)

compiler, ilog: IDEMPOTENT "idempotent does not mean what you think it means"

Actually, I don't even think it means that.  But rename it to something
which is sane.

Thanks to David Gibson for reporting.

strset: set errno on strset_add failures.

strmap: set errno on strmap_add() failures.

ccanlint: fix creation of example test/run.c

Hasn't worked for a while now.  Oops.

ccanlint: drop -d, interpret any arguments as directories, and allow multiple.

This gets us closer to 'ccanlint *' rather than relying on Makefiles
to test all modules.  Unfortunately, because of limited parallelism, it's
currently slower than make -j.

ccanlint: fix spurious warning errors.

Because we fork children to do compilations, and we use stdio, we need
to flush stdout before the fork otherwise the child will flush
afterwards.  The compile tests interpret this output as a compiler
warning.

This shows up if you redirect ccanlint output to a file.

tdb2: fix valgrind suppression in _info.

Commit c4ca9f54301c0367 renamed run-83-openhook.c to
api-83-openhook.c, but didn't update the suppression in _info.  My
system runs a patched valgrind, which doesn't have this problem.

short_types: fix example for 64 bit platforms

Use correct printf string.

opt: increase testing coverage on 64 bit platforms

Help the compiler eliminate untestable code.

net: fix tests for systems without IPv6 entries in /etc/hosts.

We fake up a dual IPv4/IPv6 response to localhost for testing, but it
assumed localhost6 or ip6-localhost entries.  Fall back to "::1" which
should always work.

jmap: fix _info example for 64 bit systems.

foreach: make test more accurate, fix for 64-bit gcc 4.4.3

gcc (Ubuntu 4.4.3-4ubuntu5) 4.4.3 on x86_64 uses a different stack
offset for the second call to test_ptr_recursion(), meaning it sees
new iterators.  Put it inside a loop to reduce the chance of that
happening.

asearch: fix example on 64 bit platforms.

alloc: fix memory leak in tests.

tdb2: fix test printf for 64 bit.

Very minor fix, since this won't happen unless the test fails.

web: add pointer to wiki/Contribute.

Note new URL: ccodearchive.net, and point to new wiki on GitHub.

strmap: new module for ordered map of strings using a critbit tree.

tcon: more help, for making strmap.

htable: benchmark against hsearch(3)

Since that has a fixed hash table size and doesn't support delete, we can't
do a thorough comparison, but we can insert and search.

likely: use htable_type

Also general cleanups:
(1) Don't assume that strings are folded by the compiler.
(2) Implement likely_stats_reset().
(3) Return non-const string from likely_stats(), as caller must free it.
(4) Don't use struct info indirection (that was from when we used callbacks?)
(5) Close memory leak in run-debug.c

htable: HTABLE_INITIALIZER() for static initialization.

Unfortunately it's a bit of a pain to use for typed hashtables, but it
works.

htable: clean up interface, document htable_type better.

We change from htable_new()/htable_free() to htable_init/htable_clear.
We also change HTABLE_DEFINE_TYPE() to be the full name, without automatically
prepending htable_.

htable: start empty.

There's no real reason to start with 128 entries.

tap: fix exit status when we have exactly 256 errors.

tcon: update and enhance documentation.

htable, strset: benchmarking tools.

This lets us compare hash table vs. strset vs. the example
implementation of critbit trees.

cbspeed 100 runs, min-max(avg):
#01: Initial insert:   236-245(237)
#02: Initial lookup (match):   180-186(180)
#03: Initial lookup (miss):   171-185(172)
#04: Initial lookup (random):   441-457(444)
#05: Initial delete all:   127-132(128)
#06: Initial re-inserting:   219-225(220)
#07: Deleting first half:   101-104(102)
#08: Adding (a different) half:   158-162(159)
#09: Lookup after half-change (match):   202-207(203)
#10: Lookup after half-change (miss):   217-222(218)
#11: Churn 1:   297-302(299)
#12: Churn 2:   297-305(300)
#13: Churn 3:   301-308(303)
#14: Post-Churn lookup (match):   189-195(190)
#15: Post-Churn lookup (miss):   189-193(190)
#16: Post-Churn lookup (random):   499-513(503)

speed 100 runs, min-max(avg):
#01: Initial insert:   211-218(212)
#02: Initial lookup (match):   161-166(162)
#03: Initial lookup (miss):   157-162(158)
#04: Initial lookup (random):   452-460(454)
#05: Initial delete all:   126-135(127)
#06: Initial re-inserting:   193-201(194)
#07: Deleting first half:   99-107(99)
#08: Adding (a different) half:   143-190(144)
#09: Lookup after half-change (match):   183-195(184)
#10: Lookup after half-change (miss):   197-203(198)
#11: Churn 1:   271-278(274)
#12: Churn 2:   280-287(282)
#13: Churn 3:   277-285(279)
#14: Post-Churn lookup (match):   171-175(171)
#15: Post-Churn lookup (miss):   174-178(175)
#16: Post-Churn lookup (random):   525-552(528)

stringspeed 100 runs, min-max(avg):
#01: Initial insert:   300-343(308)
#02: Initial lookup (match):   98-136(99)
#03: Initial lookup (miss):   73-102(75)
#04: Initial lookup (random):   230-282(233)
#05: Initial delete all:   66-102(69)
#06: Initial re-inserting:   62-99(64)
#07: Deleting first half:   43-52(43)
#08: Adding (a different) half:   101-156(106)
#09: Lookup after half-change (match):   114-156(120)
#10: Lookup after half-change (miss):   94-103(95)
#11: Churn 1:   98-105(99)
#12: Churn 2:   96-104(98)
#13: Churn 3:   174-184(176)
#14: Post-Churn lookup (match):   93-112(94)
#15: Post-Churn lookup (miss):   77-107(79)
#16: Post-Churn lookup (random):   229-265(232)

strset: new module using critbit trees.

Not as fast as using htable, but simple and provides order and prefix
ops.

str: fix warnings.

Firstly, -Wwrite-strings makes string literals const, secondly, we mustn't
define str_strstr etc in terms of themselves!

str: relicense to public domain.

LGPL is overkill for trivial wrappers like this.

ccanlint: more tweaks to example mangling.

Note where previous analysis said the code was outside a function, and
fix double new-line.  Also, treat end of comment as end of statement.

typesafe_cb: fix example macro ordering in typesafe_cb_preargs documentation.

jmap: use ccan/tcon and always be typesafe.

This handles both pointer and integer types using ccan/tcon.

jbitset: rename to jset, use ccan/tcon

It's now a completely generic set implementation, and uses ccan/tcon
to always be typesafe.  It handles both integer and pointer types.

tlist: use ccan/tcon

No real change for users.

tcon: routines for creating typesafe generic containers

ccanlint: fix output for async commands.

Previously, it was always "", since we left the nul terminator at the
start.

tdb2: allow readonly changes even while holding locks.

This happens in SAMBA with the TDB_VERSION1, presumably due to a
read-only traverse nested inside a normal traverse (since it doesn't
occur without TDB_VERSION1).

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

tdb2: add error conversion functions.

This clarifies the code a little, but also provides a more explicit
mechanism which can be used to debug error handling (by introducing
tdb_err_t and making it a pointer type).

ccanlint: run tests in parallel

Measuring ccanlint -d ccan/tdb2 on my dual core hyperthread laptop gives:
Before: 5:30
After: 3:31

tdb2: make tests work in parallel.

Lazy cut & paste of tdb names causes failure when we run in parallel.

ccanlint: compile tests with coverage in parallel

Measuring ccanlint -d ccan/tdb2 on my dual core hyperthread laptop gives:
Before: 5:59
After: 5:30

ccanlint: compile tests in parallel

Measuring ccanlint -d ccan/tdb2 on my dual core hyperthread laptop gives:
Before: 6:47
After: 5:59

ccanlint: infrastructure to run commands async.

We use the lbalance module to figure out how many to run in parallel.

tools: fix realloc bug.

Reallocing smaller can move the pointer; certainly valgrind detects
it.  Found while chasing intermittant errors on "make fastcheck".

ttxml: zero terminate the buffer after checking it was allocated

ttxml: covering my shame

ttxml: modified it to use a smaller buffer during testing

ttxml: ccanlint fixes finished

Meets all of the requirements of ccanlint.
Code coverage of the tests covers everything except for a malloc() failure.
Added some xml files for the tests to work on.

ttxml: added drop static keyword

ttxml: Passes Valgrind now

Removed the last references of the old buffering method. Should be
stable now. Time to write some proper testing.

ttxml: Rplaced ratchet buffer with regular buffer, 20x speed increase

tdb2: fix error handling for tdb1_transaction_commit.

tdb_repack() returns an enum TDB_ERROR, whereas
tdb1_transaction_commit is expected to return 0 or -1.

tdb2: don't return -1 (ie. TDB_ERR_CORRUPT) on transaction write fail.

A left-over -1 return; should be returning ecode (probably TDB_ERR_IO).

tdb2: fix prototypes which return enum TDB_ERROR.

Since enums and ints are compatible in C, the compiler didn't warn
that our prototypes for these functions disagreed with the
definitions.

tdb2: set tdb_error() on tdb_transaction_prepare_commit.

tdb2: enhance tdb1 porting document.

tdb2: delete old tdb1 tests.

These two tdb1-specific tests have been superceded by the TDB_VERSION1
flags used in the main tests.

tdb2: test: Speed up run-01-new_database.

Don't run tdb_check with failtest on, since it is very slow.  Do the
tdb_check w/ failtest in a new test, but skip MMAP suppression which
doesn't add much and slows down valgrind a lot.

Before this change run-01-new_database took 40 seconds (under
valgrind), after it takes 8 seconds, and run-12-check takes 3
seconds).

tdb2: speed up testing.

The time to run tests under valgrind has become excessive; particularly
the failure tests which fork().   Thus we cut down testing:

1) api-94-repack: reduce from 234 seconds to 2 seconds by cutting
   iterations, despite adding TDB_VERSION1 tests.

2) api-missing-entries: reduce from 17 seconds to under 1 second by
   not checking db inside loop, but at end.

This reduces the total ccanlint time from 729 to 489 seconds.

tdb2: test: convert (non-invasive) run tests to api tests.

This reduces compilation time, since these are merely linked with the
pre-built module, rather than recompiling it into the test (which
allows for fancy things like failtest).

This reduces the test compile time down from about 62 seconds to 45
seconds.  Since ccanlint compiles tests three times (once normally,
once with coverage, and once with reduced config.h) this makes a
difference: we go from 780 seconds to 729 seconds.

tdb2: test: fix run-57-die-during-transaction.c to be more efficient.

We track malloc and free, but we didn't catch the free() inside
external_agent, which means that our list of allocations keeps
growing.  Particularly under valgrind, which re-uses memory less than
the glibc allocator.

tdb2: don't continue if tdb1_find fails.

The TDB1 code's tdb1_find() returns 0 on error; the callers should
not assume that the error means that the entry wasn't found, but use
last_error to determine it.

This was found by looking at how long the failure path testing for
test/run-10-simple-store.c was taking under valgrind, ie:

valgrind -q ./run-10-simple-store --show-slowest

This change dropped the time for that test from 53 seconds to 19
seconds.

tdb2: test: try (almost) all tests with TDB_VERSION1 flag.

There are some minor changes required, in particular:

1) Make sure lockcheck understands tdb1 allrecord lock upgrades.
2) Handle tdb1 sequence number jumps: various operations increment the
   sequence number twice, especually tdb_append.
3) Don't test fail on unlock, since it gets triggered with traversal on the
   tdb1 backend (we didn't actually ever test this case for tdb2).
4) Move clear_if_first to offset 4, to match tdb1.

tdb2: log allocation failures in tdb1 backend.

The TDB2 tests are stricter about this; they want every error logged.

tdb2: fix bogus error from tdb_unlockall() after fork in tdb1 backend.

We're always allowed to unlock after a fork; by setting the count to 0
before calling the generic unlock function we don't trigger the pid
check.

tdb2: check lock owner in tdb1 backend.

This reports errors if we fork() while holding a lock, or misuse a tdb
which we have dual-opened.

tdb2: return TDB_ERR_RDONLY from transactions on R/O databases, log nesting

Rather than rturning TDB_ERR_EINVAL, return TDB_ERR_RDONLY, and log
when we fail due to nesting.

tdb2: add stats to tdb1 backend.

It's actually quite a good fit; we use compare_wrong_bucket for dead
records, which is kind of correct (they should be in the free list).

tdb2: increment seqnum on tdb_wipe_all in tdb1 backend.

tdb2: log an error when calling tdb_store() on read-only TDB in tdb1 backend.

tdb2: catch errors in tdb1_needs_recovery()

The tdb1 backend simply returns "true" if there's an error determining
if a tdb needs recovery.  But this leads failtest down a rabbit hole;
it's better to return the error at this case (and makes for better for
diagnostics, since they will come from the first fault, not later in
tdb1_transaction_recover().

tdb2: add tdb_attribute_tdb1_max_dead

This allows us to simulate the old "volatile" flag for tdb1.  It's not
necessary for tdb2.

As this is the last function in tdb1.h, we remove that file.

tdb2: expose and document tdb1_incompatible_hash.

tdb2: make tdb1_null static.

It's only used in two files, make it static in one and do it manually
in the other.

tdb2: tdb_repack

Move the tdb1_repack() code into the core, make it general, rename to
tdb_repack().

It's generic code: copy database into temporary, wipe it, copy back.

tdb2: unify tdb1_wipe into tdb_wipe.

Switch on the TDB_VERSION1 flag.

tdb2: unify tdb1_get_seqnum/tdb1_increment_seqnum into tdb_get_seqnum/tdb_inc_seqnum

Switch on the TDB_VERSION1 flag.