don't use mmap in tdb if --nosetsched is set. That makes valgrind
happier (it doesn't like the mmap/msync calls in tdb)

prevent valgrind errors where we print unitialised values on control errors

fixed a warning

fixed some incorrect CTDB_NO_MEMORY*() calls found after fixing the
_VOID varient

CTDB_NO_MEMORY_VOID() needs to return on error

added option to start ctdb under valgrind

Just add CTDB_VALGRIND=yes in /etc/sysconfig/ctdb, and look at the
logs in /var/log/ctdb_valgrind.*

zero out the ctdb->freeze_handle when we free it

This prevents heap corruption when a freeze child dies

we dont need to explicitely thaw the databases from the recovery daemon
since this is already done implicitely when we changed recovery mode
back to normal

track both when we last started and ended a recovery.
make ctdb uptime print how long the recovery took

in the recovery daemon when we check that the public ip address
allocation on the local node is correct (we have the ips we should have
and we dont have any we shouldnt have) use ctdb uptime and check the
recovery start/stop times and make sure we dont check for ip allocation
inconsistencies during a recovery  where the ip address allocation is in flux.

print the opcode when an async callback detects an error

update a comment to reflect that this is not always a real recovery
it can also be printed when we just do an ip reallocation

new version

initdit/ctdb is not a config file

make /etc/ctdb/functions executable and add a hashbang to it so
rpmlint wont complain

test

Revert "test"

This reverts commit f71287a28d66db202fe52f9a43b6daf2389d7f66.

test

reduce loglevel of the info message we are updating the flags on all nodes

force an update of the flags from the recmaster after each monitoring run

/etc/ctdb/functions should not be executable

third attempt for fixing a freeze child writing to the socket

verify that the recmaster has the correct flags for us   and if not tell the recmaster what the flags should be

only loop over the write it the write failed

the write() from the freeze child process can fail
try writing many times and log an error if the write failed

it is 2008   not 2008 right now :-)

update to 1.0.42

ban the node after 3 failed scripts by default

if the event scripts hangs EventScriptsBanCount consecutive times in a row
the node will ban itself for the default recovery ban period

when a eventscript has timed out, log the event options (i.e. "monitor" "takeip 1.2..." etc)
to the log

make it possible to re-start a recovery without marking the current node as
the culprit.

add a callback for failed nodes to the async control helper.

this callback is called for every node where the control failed (or timed out)

when we issue the start recovery control from recovery master,
set any node that fails as a culprit   so it will eventually be banned

first cut to convert takeover_callback_state{}
to use ctdb_sock_addr instead of sockaddr_in

fix a comment

note that we dont actually send the ipv6 "gratious arp" on the wire just yet.
(since ipv6 doesnt use arp)
but all the infrastructure is there when we implement sending raw neig.disc. packets

convert handling of gratious arps and their controls and helpers to
use the ctdb_sock_addr structure so tehy work for both ipv4 and ipv6

add a parameter for the tdb-flags to the client function
ctdb_attach()   so that we can pass TDB_NOSYNC when we attach to
a persistent database and want fast unsafe writes instead of
slow but safe tdb_transaction writes.

enhance the ctdb_persistent test suite to test both safe and unsafe writes

run the persistent write test with 4 nodes by default

use the timelimit argument to the persistent writer to run the test for
30 seconds by default

redesign the test of persistent writes
so that we have n persistent writers on n nodes,
all writers writing persistently to the same record.

each writer on a node has its own "counter" in this record that is incremented by one in each iteration.
the persistent writer on node 0 also checks that all the counters in the record are increasing monotonically and if they are not, flagging it as an ERROR.

create the nodes file in a 'test' subdirectory and not the current directory

delete all persistent databases when the test starts
(the tests only uses test databases in a special test directory)

do not set up any public addresses in the tests

wait until there are no disconnected or unhealthy nodes when starting the
test daemons instead of waiting for the recovery mode to change.
we do want to wait until the system has recovered and ALL nodes are ok.

debugleves can now be negative   so print their value using %d instead of %u

update to .41

dont bother casting to a void* private_data pointer,
just pass it as 'state' structure

remove another field we dont need in the childwrite_handle structure

remote a comment that is no longer relevant

remove a field in the childwrite_handle structure we dont need

do persistent writes in a child process

update to .40

read the samba sysconfig from the samba eventscript

disable transactions for now,  there are more situations where there are conflicting locks   and the "net" command is not prepared that the persistent store can fail.

restore a timeout value to the default settings instead of the hardcoded 3 second test value

fix some memory hierarchy bugs in allocation of the state structure for persistent writes.

since these two controls (UPDATE_RECORD and PERSISTENT_STORE) can respond
asynchronously to the control,   we can not allocate the state variable as a child off ctdb_req_control  instead we must allocate state as a child off ctdb itself
and steal ctdb_req_control so it becomes a child of state.

othervise both ctdb_req_control and also state will be released immediately after we have finished setting up the async reply and returned.

cleanup of the previous patch.

With these patches, ctdbd will enforce and (by default) always use
tdb_transactions when updating/writing records to a persistent database.

This might come with a small performance degratation  since transactions
are slower than no transactions at all.

If a client, such as samba wants to use a persistent database but does NOT
want to pay the performance penalty, it can specify TDB_NOSYNC  as the
srvid parameter in the ctdb_control() for CTDB_CONTROL_DB_ATTACH_PERSISTENT.

In this case CTDBD will remember that "this database is not that important"
so I can use unsafe (no transaction) tdb_stores to write the updates.
It will be faster than the default (always use transaction) but less crash safe.

second try for safe transaction stores into persistend tdb databases

for stores into persistent databases, ALWAYS use a lockwait child take out the lock for the record and never the daemon itself.

update version to .39

move CTDB_MANAGES_NFS from /etc/sysconfig/nfs to /etc/sysconfig/ctdb

move the CTDB_MANAGES_ISCSI setting from /etc/sysconfig/iscsi to /etc/sysconfig/ctdb

move the config optoin CTDB_MANAGES_VSFTPD from /etc/sysconfig/vsftpd to /etc/sysconfig/ctdb

lowe the loglevel for the warning that releaseip was called for a non-public address.

the address might be a public address on a different node so no need to fiull up the logs with thoise messages

 lower the loglevel for when we have "tickles" for an ip address that is not a public address on the local node (it may be a public address on other nodes)

dont emit the can not start transaction with locks held at all.
it just pollutes the logs

lower the debug level for the "can not start transaction" since we do expect this to happen a few times inside ctdb (since we cant really block and wait for all locks to dissapear before we can write the header, for example when doing a dmaster miration)
in those cases we accept that we couldnt get a transaction and then just writes the data "unsafely" anyway.

When ctdb has just been installed on a node, there wont be any persistent databases
stored yet.

Fix a cosmetic and annoying warning message when running "service ctdb start" and supress printing out that "warning your ls command to find the persistent databases didnt find any" ...

new version .38

add "machinereadable output" support to "ctdb getmonmode"

dont disable/enable monitoring for each eventscript, instead
just disable the monitoring during the "startrecovery" event and enable it again once recovery has completed

dont check whether the "recovered" event was successful or not
since  this event wont run unless the recovery mode is normal   but we
can not know what the recovery mode will be in the future on a remote node
so since we issue these commands   that will execute in the future at some other node
it is pointless to try to check if it worked or not

in particular if "failure to successfully run the eventscript" would then trigger a full new recovery which is disruptive and expensive.

remove some unnessecary tests if ->vnn is null or not

Update some debug statements. Dont say that recovery failed if the failed function was invoked from outside of recovery

Merge git://git.samba.org/tridge/ctdb

put the return in the right place

We were refusing the 'startrecovery' event

Fix the chicken and egg problem with ctdb/samba and a registry smb.conf

This attempts to fix the problem of ctdb event scripts blocking due to
attempted access to the ctdb databases during recovery. The changes are:

  - now only the 'shutdown' and 'startrecovery' events can be called
    with the databases locked in recovery. The event scripts must ensure
    that for these two events no database access is attempted

  - the recovered, takeip and releaseip events could previously be called
    inside a recovery. The code now ensures that this doesn't happen, delaying
    the events till after recovery has finished

  - the 50.samba event script now avoids using testparm unless it is really
    needed

This needs extensive testing.

Start implementing support for ipv6.

This enhances the framework for sending tcp tickles to be able to send ipv6 tickles as well.

Since we can not use one single RAW socket to send both handcrafted ipv4 and ipv6 packets, instead of always opening TWO sockets, one ipv4 and one ipv6 we get rid of the helper ctdb_sys_open_sending_socket() and just open (and close)  a raw socket of the appropriate type inside ctdb_sys_send_tcp().
We know which type of socket v4/v6 to use based on the sin_family of the destination address.

Since ctdb_sys_send_tcp() opens its own socket  we no longer nede to pass a socket
descriptor as a parameter.  Get rid of this redundant parameter and fixup all callers.

add a new container to hold a socketaddr for either ipv4 or ipv6

Add a missing include

move the function to open a sending socket into the main executable since this function will dissapear soon...

Merge commit 'ronnie-ctdb/master' into tridge

add a checksum routine for tcp over ipv6

When we run the init script to start the ctdb service
Use tdbdump to verify that all persistent database files are good
before we start the daemon.

Try to use tdb transactions when updating a record and record header inside the ctdb daemon.

If a transaction could be started, do safe transaction store when updating the record inside the daemon.
If the transaction could not be started (maybe another samba process has a lock on the database?) then just do a normal store instead (instead of blocking the ctdb daemon).

The client can "signal" ctdb that updates to this database should, if possible, be done using safe transactions by specifying the TDB_NOSYNC flag when attaching to the database.
The TDB flags are passed to ctdb in the "srvid" field of the control header when attaching using the CTDB_CONTROL_DB_ATTACH_PERSISTENT.

Currently, samba3.2 does not yet tell ctdbd to handle any persistent databases using safe transactions.

If samba3.2 wants a particular persistent database to be handled using
safe transactions inside the ctdbd daemon, it should pass
TDB_NOSYNC as the flags to the call to attach to a persistent database
in ctdbd_db_attach()     it currently specifies 0 as the srvid

Update to new release

when pulling the nfs directories to check during 60.nfs monitor
grep for lines starting with a '/' character since exportfs will sometimes
split a single export line into two lines of output    like this :

[root@fscc-hs21-13 ~]# exportfs
/NFS4exports/tmp
                <world>
/NFS4exports    <world>

ctdb->methods becomes NULL when we shutdown the transport.

If we shutdown the transport   and CTDB later decides to send a command out
for queueing, the call to ctdb->methods->allocate_pkt() will SEGV.

This could trigger for example when we are in the process of shuttind down CTDBD and have already shutdown the transport but we are still waiting for the
"shutdown" eventscripts to finish.
If the event scripts now take much much longer to execute for some reason, this
race condition becomes much more probable.

Decorate all dereferencing of ctdb->methods->    with a check that ctdb->menthods is non-NULL

need to specicy tree to git archive

use git archive to create tarball

update to new version

fix a bug where the public ip addresses of the cluster would not be redistributed across the cluster after a recovery was performed.

Remove a bogus check inside the recovery daemon that ONLY redistributed public addresses IFF the local node had/served public addresses.
This was a valid optimization long ago when we enforced that all nodes must use the same public addresses file   but is invalid today where we can have different public addresses configs on all nodes  and even have some nodes that do NOT use public addresses at all.

fixed realloc bug

Should always use type safe talloc functions when possible. In this case we were allocating bytes instead of uint32_t

fix merge corruption

Merge git://git.samba.org/tridge/ctdb

Merge commit 'sofs1/tridge'

listen_fd is auto-closed

Closing it here just causes an epoll error, and may close a fd in use by
another structure to be closed. This caused a infinite recovery loop

Merge branch 'master' of git://git.samba.org/sahlberg/ctdb

Merge commit 'ronnie-ctdb/master' into tridge

From Mathias Dietz

Make the 60.nfs eventscript more forgiving when using non-us/english
characters in sharenames

update to version .35

Expand the client async framework so that it can take a callback function.
This allows us to use the async framework also for controls that return
outdata.

Add a "capabilities" field to the ctdb_node structure. This field is
only initialized and kept valid inside the recovery daemon context and not
inside the main ctdb daemon.

change the GET_CAPABILITIES control to return the capabilities in outdata instead of in the res return variable.

When performing a recovery inside the recovery daemon, read the capabilities from all connected nodes and update the ctdb->nodes list of nodes.
when building the new vnnmap after the database rebuild in recovery, do not include any nodes which lack the LMASTER capability in the new vnnmap.
Unless there are no available connected node that sports the LMASTER capability in which case we let the local node (recmaster) take on the lmaster role temporarily (i.e. become a member of the vnnmap list)

make sure we lose all elections for recmaster role if we do not have the recmaster capability.

(unless there are no other node at all available with this capability)

close and reopen the reclock pnn file at regular intervals.

handle failure to get/hold the reclock pnn file better and just
treat it as a transient backend filesystem error and try again later
instead of shutting down the recovery daemon

when we have lost the pnn file   and if we are recmaster
release the recmaster role so that someone else can become recmaster isntead

Monitor that the recovery daemon is still running from the main ctdb daemon
and if it has terminated, then we shut down the main daemon as well

Add ability to disable recmaster and lmaster roles through sysconfig file and
command line arguments

Add a capabilities field to the ctdb structure

Define two capabilities :
can be recmaster
can be lmaster
Default both capabilities to YES

Update the ctdb tool to read capabilities off a node

Use DEBUG_ERR and not DEBUG_WARNING when we get a connection
attempt from a non-ctdb host