The remote node needs to get the IMMEDIATE_MIGRATION flag to actually send the
record

fixed a bug found by volker - initialse the record on disk when initialised in memory

- split out ctdb_ltdb_lock_fetch_requeue() into a simpler
  ctdb_ltdb_lock_requeue() and a small wrapper

- use ctdb_ltdb_lock_requeue() to fix a possible hang in
  ctdb_reply_dmaster(), where the ctdb_ltdb_store() could hang waiting
  for a client. We now requeue the reply_dmaster packet until we have
  the lock

- added a --torture option to all ctdb tools. This sets
  CTDB_FLAG_TORTURE, which forces some race conditions to be much more
  likely. For example a 20% chance of not getting the lock on the
  first try in the daemon

- abstraced the ctdb_ltdb_lock_fetch_requeue() code to allow it to
  work with both inter-node packets and client->daemon packets

- fixed a bug left over in ctdb_call from when the client updated the
  header on a call reply

- removed CTDB_FLAG_CONNECT_WAIT flag (not needed any more)

merge from ronnie

 the checks for srcnode and destnode from the client are redundant since the daemon will sort these out itself before it sends the call of to either the local handler or a remote daemon

merge from ronnie
remove unused bench_incr function in ctdb_bench.c

remove a comment that is no longer valid

don't need these structures any more

add some tests in the daemon that a REQ_CALL that a client sent us has valid srcnode and destnode

update ctdbd_test.c to show how to force a migration onto the local node

merge from tridge

merge from tridge

much simpler fetch code!
fetch is now confined to the client code, no spcial code at
all in the daemon.

- fully separate the client version of ctdb_call from the daemon
  version. The client version is different enough that this is
  worthwhile

- enable local shortcut for client version of ctdb_call

- add idr_find_type(), with better error reporting in case of type
  mismatch

- make he packet allocation routines take a mem_ctx, which allows
  us to put memory directly in the right context, avoiding quite a few
  talloc_steal calls, and simplifying the code

- make the fetch lock code in the daemon fully async

ctdbd does no longer take a --daemon parameter since we no longer do non-daemon mode
remove the parameter from the ctdbd script

remove the store_unlock from ctdbd_test since there is no and will be no pdu for this
CTDB_REPLY_FETCH_LOCK no longer return the data for the record since the client is assumed to read this itself from the local tdb. remove some variables that no longer exists.

merge from tridge

avoid a deadlock the fetch_lock code. The deadlock could happen when
a client held the chainlock, and the daemon received a dmaster reply
at the same time. The daemon would not be able to process the dmaster
reply, due to the lock, but the fetch lock cannot make progres until
the dmaster reply is processed.

The solution is to not hold the lock in the client while talking to
the daemon. The client has to retry the lock after the record has
migrated. This means that forward progress is not guaranteed. We'll
have to see if that matters in practice.

- use separate directories for the tdb files by default
- use TDB_CLEAR_IF_FIRST to ensure we don't use an old tdb

merged the db_dir changes from volker. Changed them slightly,
to make the --dbdir option available to all ctdb tools, not just
the daemon

merge from tridge

Add --dbdir to ctdbd. Necessary for shared operation between ctdbd and smbd.

this fixes a timeout error spotted by volker
It ensures that when the client context goes away (such as when the client exits)
that any timed events and partially completed requests from that client also go away

merged cleanup from ronnie

validate dmaster on a client fetch request

we dont need the structure ctdb_reply_shutdown since we dont implement that pdu any more

merge from tridge

simpler shutdown process. The reply is not actually needed, and
occasionally leads to problems if an immediate send on the socket
causes a context switch and the client exiting before the daemon. We
now exit the client when the daemon goes away.

use shutdown in more tests

make sure we don't double free in the async lock handler

merge from tridge

- merge from ronnie, and use wait instead of sleep in test scripts

add/finish the ctdb_shutdown() function.
this function can be used in test applications to perform an orderly shutdown of the ctdb cluster once the test has completed.
the ctdb nodes will remain operational until all of them have received a shutdown from their client(s)  after which the ctdb daemons will all terminate.

this eliminates the need to using sleep() in some of the test applications

merge fetch1 changes from ronnie

initial shutdown function where a client can request an orderly shutdown of a ctdb cluster

started adding a cleaner daemon finish method

merge from tridge

bit less verbose when client exits

- merge volkers debug changes

- fixed memory leaks in the 3 packet receive routines. The problem was
  that the ctdb_call logic would occasionally complete and free a
  incoming packet, which would then be freed again in the packet
  receive routine. The solution is to make the packet a child of a
  temporary context in the receive routine then free that temporary
  context. That allows other routines to keep or free the packet if
  they want to, while allowing us to safely free it (via a free of the
  temporary context) in the receive function

enhance fetch1 test to verify that a lock is released when a client terminates while holding the lock  and the next blocked waiting client is assigned the lock

merge from tridge

Clean up the call_states correctly

Be less verbose

Some more debug and two memleak fixes

typo

Add timestamps to debug output.

add debug tracing to fetch_lock

more DEBUG() calls

moved cmdline.c to common code

use the common cmdline code in ctdbd
add a basic debug system with -dXX

fixed a missing idr remove, and check the types after idr_find()

make sure we notify ctdb when a node dies

merge from volker and ronnie

merge from volker to prevent some valgrind errors

merge from tridge

ZERO_STRUCT writes one byte too many here.

update destination in a redirect reply

stop the client looping (temporary measure)

start using ctdb_ltdb_lock_fetch_requeue()

merge from tridge

when we get a lmaster request, skip updating the header when we are also the new dmaster

we should not lock in a normal ctdb_call(), as we want them to run concurrently

- send the record header from the client to the daemon when doing a
  fetch, to avoid the daemon re-reading it

- suffix the database name with the node name so that testing on
  loopback doesn't result in a name collision in the database open

merge from tridge

make sure we unlock

block SIGPIPE in the daemon to prevent a SIGPIPE on write to a dead socket

now that both daemon and client access the database, it needs to be a real disk file

merge from tridge

tidyups in test code

- removed the non-daemon mode from ctdb, in order to simplify the
  code. It may be added back later once everything is working nicely,
  or simulated using a in-process pipe instead of a unix domain socket

- rewrote the ctdb_fetch_lock() code to follow the new design

merge from ronnie

create symbols for fetch lock response status

finalize fetch lock changes to get rid of the record handle

do not use a ctdb_record_handle for client fetch_lock/store_unlock any more

change ctdb_client_fetch_lock to return a status code instead of a record handle and make it unconditionally fill in data.

change ctdb_client_store_unlock to take ctdb_db and key as arguments instead of a record handle

update the ctdb_fetch.c test to use the clientside helpers for fetching and storing data

merge from ronnie

remaning code to finish lock_fetch/store_unlock clientside helpers

initial change to remove store_unlock pdu and use tdb chainlock in the client

merge from ronnie

partial merge from volker (some overlaps removed)

better error handling in ctdb_ltdb_lock_fetch_requeue()

change some error printouts to make it easier to determine whether the error occured in the client or in the daemon

merge from tridge

add an explanation of ctdb_ltdb_lock_fetch_requeue()

add an explanation of how to use ctdb_lockwait()

fixed crash bug - thanks volker

darn, forgot this

wait on the right fd ....

added a ctdb_ltdb_lock_fetch_requeue() function
this will be the core of the non-blocking lock idea for ctdb, it will be used
in place of ctdb_ltdb_fetch(), but will also get a lock. It re-starts a request
if it needs to block

added a tdb_chainlock_nonblock() call to tdb

merge local copy of tdb from samba4 tdb

fixed a fd bug (thanks volker)

merge from tridge

this is a demonstration of an idea for handling locks in ctdb.

The problem we have is this:

  - we want the client smbd processes to be able to 'shortcut' access
    to the ltdb, by directly accessing the ltdb, and if the header of
    the record shows we are the dmaster then process immediately, with
    no overhead of talking across the unix domain socket

  - a client doing a shortcut will use tdb_chainlock() to lock the
    record while processing

  - we want the main ctdb daemon to be able to set locks on the
    record, and when those locks collide with a 'shortcut' fcntl lock,
    we want the ctdb daemon to keep processing other operations

  - we don't want to have to send a message from a smbd client to the
    ctdbd each time it releases a lock

The solution is shown in this example. Note that the expensive fork()
and blocking lock is only paid in case of contention, so in the median
case I think this is zero cost.

merge from tridge

merged from samba4

pull out common command line code for tests into tests/cmdline.c

merge from tridge

merge CTDB_SRVID_ALL patch from Samba4

- fix includes to work in both samba4 and ctdb standalone
- when we do a store_unlock the lock record becomes unlocked, so we
  must destroy it (or we leak memory)

added --dblist option to ctdbd, to allow list of databases to be specified on the command line