ctdb: when we fill the client packet queue we need to drop the client

We can't just drop packets to the list, as those packets could be part
of the core protocol the client is using. This happens (for example)
when Samba is doing a traverse. If we drop a traverse packet then
Samba hangs indefinately. We are better off dropping the ctdb socket
to Samba.

ctdb: move ctdb_io.c to use TLIST_*() macros

This will make large packet queues much more efficient

util: added TLIST_*() macros

The TLIST_*() macros are like the DLIST_*() macros, but take both a
head and tail pointer for the list. This means that adding an element
to the end of the list is efficient (it doesn't need to walk the
list).

We should move all uses of the DLIST_*() macros which use
DLIST_ADD_END() to use the TLIST_*() macros instead.

When trying to enable/disable a node.
Check if the node is already enabled/disabled and log an information
message if so.

We only queued up to 1000 packets per queue before we start dropping
packets, to avoid the queue to grow excessively if smbd has blocked.

This could cause traverse packets to become discarded in case the main
smbd daemon does a traverse of a database while there is a recovery
(sending a erconfigured message to smbd, causing an avalanche of unlock
messages to be sent across the cluster.)

This avalance of messages could cause also the tranversal message to be
discarded  causing the main smbd process to hang indefinitely waiting
for the traversal message that will never arrive.

Bump the maximum queue length before starting to discard messages from
1000 to 1000000 and at the same time rework the queueing slightly so we
can append messages cheaply to the queue instead of walking the list
from head to tail every time.

add two new debug controls to send and receive messages

ctdb msglisten and msgsend

Drop the debug level for logging fd creation to DEBUG_DEBUG

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.

initscript: handle spaces in option values inserted into $CTDB_OPTIONS.

This puts single quotes around everything and uses eval on the
command-lines that actually start ctdbd.  The eval causes the single
quotes to be interpreted.

The "redhat" init style no longer uses the Red Hat daemon function.
It loses the quoting and re-splits on spaces.  Instead we add an extra
line that uses the success/failure functions to keep things pretty.
Note that this means that we don't respect daemon's
$DAEMON_COREFILE_LIMIT variable but we do our own core file handling
with $CTDB_SUPPRESS_COREFILE anyway.  daemon's core file handling was
probably overriding what we were doing anyway, so this can be regarded
as a bug fix.

Signed-off-by: Martin Schwenke <martin@meltin.net>

onnode: update algorithm for finding nodes file.

2 changes:

* If a relative nodes file is specified via -f or $CTDB_NODES_FILE but
  this file does not exist then try looking for the file in /etc/ctdb
  (or $CTDB_BASE if set).

* If a nodes file is specified via -f or $CTDB_NODES_FILE but this
  file does not exist (even when checked as per above) then do not
  fall back to /etc/ctdb/nodes ((or $CTDB_BASE if set).  The old
  behaviour was surprising and hid errors.

Signed-off-by: Martin Schwenke <martin@meltin.net>

onnode - respect $CTDB_BASE rather than hard-coding /etc/ctdb.

Signed-off-by: Martin Schwenke <martin@meltin.net>

config: 10.interface: search "ethtool" in $PATH instead of using a hardcoded path

This is very useful for testing, I use such a script:

cat ~/bin/ethtool
 #!/bin/sh

 IFACE=$1

 case "$IFACE" in
        Neth2)
                ;;
        Neth3)
                ;;
        Neth4)
                ;;
        Neth5)
                ;;
        *)
                exec /usr/sbin/ethtool $@
                ;;
 esac

 ip link set down $IFACE

 exec /usr/sbin/ethtool $@

metze

server: reload the public addresses before doing a takeover run

metze

server: ban ourself if the ctdb and kernel knowledge of a public ip differs

metze

server: give an error if we're getting an takeover_ip event with a wrong pnn

metze

server: return an error if we get an takeover ip event and we cannot serve the ip

metze

server: print node number as signed integer on release ip event

metze

server: debug redundant takeover ip events with level INFO

metze

server: be less verbose on redundant release_ip events

metze

server: add a ctdb_do_updateip()

metze

server: split out a ctdb_do_takeover_ip() function

metze

server: split out a ctdb_announce_vnn_iface() function

metze

events: add updateip event to 13.per_ip_routing

metze

events: 10.interface handle updateip event

metze

server: add updateip event

metze

config: add CTDB_PARTIALLY_ONLINE_INTERFACES to ctdb.sysconfig

With this option set to "yes", we don't become unhealthy
as long as at least one interface is still available.

metze

server: start with disabled interfaces and let the event scripts enable the interfaces explicit

This makes sure that we don't get public addresses assigned during the
initial recovery and remove them again in the startup event.

metze

config: 10.interfaces call monitor_interfaces on startup

metze

config: 10.interfaces call ctdb ifaces and ctdb setifacelink for monitoring

metze

events: splitout a monitor_interfaces function in 10.interface

metze

server: monitor interfaces in verify_ip_allocation()

metze

server: only trigger one takeover run in verify_ip_allocation()

metze

tools/ctdb: add PartiallyOnline state for "ctdb status" and "ctdb status -Y"

This is based on the GET_IFACES control against each node.

metze

tools/ctdb: display interfaces in "ctdb ip" and "ctdb ip -Y" outputs

metze

tests: add a all_ips_on_node() helper function that wraps ctdb ip -Y

metze

tests/simple/11_ctdb_ip.sh: be more strict in checking ctdb ip -Y output

metze

tools/ctdb: add "ctdb ipinfo <ip>"

metze

tools/ctdb: add "ctdb setifacelink <iface> <status>"

metze

tools/ctdb: add "ctdb ifaces"

metze

server: implement ctdb_control_set_iface_link()

This only marks the interface status and doesn't
generate any directly triggered action.

The actions is later taken by the recovery process
in verify_ip_allocation.

metze

server: implement ctdb_control_get_ifaces()

metze

server: implement ctdb_control_get_public_ip_info()

metze

client: implement ctdb_ctrl_set_iface_link()

metze

client: implement ctdb_ctrl_get_ifaces()

metze

client: implement ctdb_ctrl_get_public_ip_info()

metze

controls: add stups for GET_PUBLIC_IP_INFO, GET_IFACES and SET_IFACE_LINK_STATE

metze

server: use CTDB_PUBLIC_IP_FLAGS_ONLY_AVAILABLE during a takeover run

We know ask for the known and available interfaces.
This means a node gets a RELEASE_IP event for all interfaces
it "knows", but doesn't serve and a node only gets a TAKE_IP event
for "available" interfaces.

metze

server: implement CTDB_PUBLIC_IP_FLAGS_ONLY_AVAILABLE behavior

metze

client: add CTDB_PUBLIC_IP_FLAGS_ONLY_AVAILABLE ctdb_ctrl_get_public_ips_flags()

metze

reserve upper bits in ctdb_control->flags for opcode specific flags

metze

server: keep the interface information in a list of ctdb_iface structures

metze

server: we don't need to copy strings we pass as talloc_asprintf() arguments

metze

events: 10.interfaces allow multiple interfaces per public address

metze

server: allow multiple interfaces comma separated in public_addresses

metze

server: add a ctdb_vnn_iface_string() helper function to access vnn->iface

metze

server: add a ctdb_set_single_public_ip() helper function

metze

config: add 13.per_ip_routing event script

With this script it's possible to generate routing tables
per public ip address.

metze

config: add some ipv4 helper shell functions

Many thanks to Michael Adam <obnox@samba.org>
for the basic work.

metze

config: add interface_modify.sh and call it under flock to make modification on interfaces atomic

When two releaseip events run in parallel it's possible that the 2nd script
readds a secondary ip that was removed by the 1st script.

metze

events/10.interfaces: move some parts to helper functions

metze

config/functions: add tickle_tcp_connections()

metze

server: add "init" event

This is needed because the "startup" event runs after the initial recovery,
but we need to do some actions before the initial recovery.

metze

server: setup fault handler to get the build-in backtrace support

The panic action feature will be added later.

metze

lib/util: add pre and post panic action hooks

metze

lib/util: import fault/backtrace handling from samba.

metze

configure: don't overwrite AC_CHECK_FUNC_EXT and AC_CHECK_LIB_EXT

This has curently no affect on the generated configure and config.h.in files.

metze

move DEBUG* macros to one place

metze

tools/ctdb: display INACTIVE status in "ctdb status" and "ctdb status -Y"

metze

server: add missing goto again after do_recovery()

metze

lib/events: finish "Run only one event for each epoll_wait/select call"

This finished commit a78b8ea7168e5fdb2d62379ad3112008b2748576.

The logic was missing in events_standard (the one that's used by default).

metze

source the nfs sysconfig file from the 61.nfstickles script

document the in-memory ringbuffer for logging and the commands
used to set it up and manage it.

Make the size of the in memory ringbuffer for keeping the recent log messages
configureable using --log-ringbuf-size=<num-entries>.

Add an entry in the sysconfig file to set this persistently.

new version 1.0.113

Merge commit 'metze/master-for-ronnie'

server: call event_add_fd at the end of ctdb_set_child_logging()

metze

ctdb_logging: simplify ctdb_fork_with_logging a lot and reduce the syscall usage

metze

New version 1.0.112.

Signed-off-by: Martin Schwenke <martin@meltin.net>

Revert "Use wbinfo --ping-dc isntead of wbingo -p sicne this is a more reliable way to determine if winbindd is in a useful state."

This reverts commit 7c95e56ba871a4e0cb893a5cb5d821e7ff6e6dd6.

wbinfo --ping-dc is proving too unreliable.

Revert "events/50.samba: only use wbinfo --ping-dc if available"

This reverts commit 7b73834ba3ac197cc8a3020c111f9bb2c567e70b.

wbinfo --ping-dc is proving too unreliable.

Merge commit 'origin/master'

New version 1.0.111

eventscript: fix bug when script is aborted

Another corner case when we terminate running monitor scripts to run
something else: logging can flush the output and we write to a NULL
pointer.

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

eventscript: remove cb_status, fix uninitialized bug when monitoring aborted

(Reapplied with merge after accidental revert)

Previously we updated cb_status a each script finished.  Since we're storing
the status anyway, we can calculate it by iterating the scripts array
itself, providing clear and uniform behavior on all code paths.

In particular, this fixes a longstanding bug when we abort monitor
scripts to run some other script: the cb_status was uninitialized.  In
this case, we need to hand *something* to the callback; 0 might make
us go healthy when we shouldn't.  So we use the last status (normally,
this will be the just-saved current status).

In addition, we make the case of failing the first fork for the script
and failing other script forks the same: the error is returned via the
callback and saved for viewing through 'ctdb scriptstatus'.

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

Merge commit 'origin/master'

Test suite: Add an optimisation in the getvar test.

Signed-off-by: Martin Schwenke <martin@meltin.net>

Test suite: allow settign of timeout triggers for all events not just monitor.

Signed-off-by: Martin Schwenke <martin@meltin.net>

Version 1.0.110

eventscript: fix cleanup path when setting up script list

We shouldn't set ctdb->current_monitor until we set destructor: that's
what cleans it up.

Also, free state->scripts on no-scripts exit path: it's not a child of
state because we need it in the destructor.

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

server: add set_close_on_exec() on more fds

metze

server: fix fd leaks in the new logging code

metze

version 1.0.109

eventscript: remove cb_status, fix uninitialized bug when monitoring aborted

Previously we updated cb_status a each script finished.  Since we're storing
the status anyway, we can calculate it by iterating the scripts array
itself, providing clear and uniform behavior on all code paths.

In particular, this fixes a longstanding bug when we abort monitor
scripts to run some other script: the cb_status was uninitialized.  In
this case, we need to hand *something* to the callback; 0 might make
us go healthy when we shouldn't.  So we use the last status (normally,
this will be the just-saved current status).

In addition, we make the case of failing the first fork for the script
and failing other script forks the same: the error is returned via the
callback and saved for viewing through 'ctdb scriptstatus'.

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

fix a conflict in the merge from rusty

Merge commit 'rusty/ctdb-no-setsched'

Conflicts:

server/ctdb_vacuum.c

ctdb: use mlockall, cautiously

We don't want ctdb stalling due to paging; this can be far worse than
scheduling delays.  But if we simply do mlockall(MCL_FUTURE), it
increases the risk that mmap (ie. tdb open) or malloc will fail,
causing us to abort.

This patch is a compromise: we mlock all current pages (including
10k of future stack for expansion) and then relock when a client
asks us to open a TDB.  We warn, but don't exit, if it fails.

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

Remove RT priority, use niceness.

1) It's buggy.  Code needs to be carefully written (ie. no busy
   loops) to handle running with it, and we fork and run scripts.[1]

2) It makes debugging harder.  If ctdbd loops (as has happened recently)
   it can be extremely hard to get in and see what's happening.  We've already
   seen the valgrind hacks.

3) We have seen recent scheduler problems.  Perhaps they are unrelated,
   but removing this very unusual setup is unlikely to hurt.

4) It doesn't make anything faster.  Under all but the most perverse of
   circumstances, 99% of the cpu gives the same performance as 100%, and
   we will always preempt normal processes anyway.

[1] I made this worse in 0fafdcb8d353 "eventscript: fork() a child for
    each script" by removing the switch_from_server_to_client() which
    restored it, but even that was only for monitor scripts.  Others were
    run with RT priority.

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

Add --valgringing flag instead of --nosetsched

The do_setsched was being tested for whether to mmap tdbs: let's make it
explicit.  We can also happily move the kill-child eventscript hack under
this flag.

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

fix conflict in merge from metze

Merge commit 'metze/master-tdb-check'

Conflicts:

server/ctdb_vacuum.c

ctdb: pass TDB_DISALLOW_NESTING to all tdb_open/tdb_wrap_open calls

metze

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

doc: regenerate manpages

metze