Adding upstream version 2:4.17.12+dfsg.upstream/2%4.17.12+dfsgupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

6 files changed, 1638 insertions, 0 deletions

diff --git a/ctdb/include/common/srvid.h b/ctdb/include/common/srvid.h
new file mode 120000
index 0000000..5a36c27
--- /dev/null
+++ b/ctdb/include/common/srvid.h
@@ -0,0 +1 @@
+../../common/srvid.h
\ No newline at end of file
diff --git a/ctdb/include/ctdb_client.h b/ctdb/include/ctdb_client.h
new file mode 100644
index 0000000..b993620
--- /dev/null
+++ b/ctdb/include/ctdb_client.h
@@ -0,0 +1,289 @@
+/*
+   ctdb database library: old client interface
+
+   Copyright (C) Andrew Tridgell  2006
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _CTDB_CLIENT_H
+#define _CTDB_CLIENT_H
+
+#include "common/srvid.h"
+#include "ctdb_protocol.h"
+
+enum control_state {
+	CTDB_CONTROL_WAIT,
+	CTDB_CONTROL_DONE,
+	CTDB_CONTROL_ERROR,
+	CTDB_CONTROL_TIMEOUT
+};
+
+struct ctdb_client_control_state {
+	struct ctdb_context *ctdb;
+	uint32_t reqid;
+	int32_t status;
+	TDB_DATA outdata;
+	enum control_state state;
+	char *errormsg;
+	struct ctdb_req_control_old *c;
+
+	/* if we have a callback registered for the completion (or failure) of
+	   this control
+	   if a callback is used, it MUST talloc_free the cb_data passed to it
+	*/
+	struct {
+		void (*fn)(struct ctdb_client_control_state *);
+		void *private_data;
+	} async;
+};
+
+struct tevent_context;
+struct ctdb_db_context;
+
+/*
+  allocate a packet for use in client<->daemon communication
+ */
+struct ctdb_req_header *_ctdbd_allocate_pkt(struct ctdb_context *ctdb,
+					    TALLOC_CTX *mem_ctx,
+					    enum ctdb_operation operation,
+					    size_t length, size_t slength,
+					    const char *type);
+
+#define ctdbd_allocate_pkt(ctdb, mem_ctx, operation, length, type) \
+	(type *)_ctdbd_allocate_pkt(ctdb, mem_ctx, operation, length, \
+				    sizeof(type), #type)
+
+int ctdb_call_local(struct ctdb_db_context *ctdb_db, struct ctdb_call *call,
+		    struct ctdb_ltdb_header *header, TALLOC_CTX *mem_ctx,
+		    TDB_DATA *data, bool updatetdb);
+
+void ctdb_request_message(struct ctdb_context *ctdb,
+			  struct ctdb_req_header *hdr);
+
+void ctdb_client_read_cb(uint8_t *data, size_t cnt, void *args);
+
+int ctdb_socket_connect(struct ctdb_context *ctdb);
+
+/*
+  make a ctdb call. The associated ctdb call function will be called on the DMASTER
+  for the given record
+*/
+struct ctdb_client_call_state *ctdb_call_send(struct ctdb_db_context *ctdb_db,
+					      struct ctdb_call *call);
+int ctdb_call_recv(struct ctdb_client_call_state *state,
+		   struct ctdb_call *call);
+int ctdb_call(struct ctdb_db_context *ctdb_db, struct ctdb_call *call);
+
+/* setup a handler for ctdb messages */
+typedef void (*ctdb_msg_fn_t)(struct ctdb_context *, uint64_t srvid,
+			      TDB_DATA data, void *);
+
+int ctdb_client_set_message_handler(struct ctdb_context *ctdb, uint64_t srvid,
+				    srvid_handler_fn handler,
+				    void *private_data);
+int ctdb_client_remove_message_handler(struct ctdb_context *ctdb,
+				       uint64_t srvid, void *private_data);
+
+/* send a ctdb message */
+int ctdb_client_send_message(struct ctdb_context *ctdb, uint32_t pnn,
+			     uint64_t srvid, TDB_DATA data);
+
+struct ctdb_client_control_state *ctdb_control_send(struct ctdb_context *ctdb,
+						    uint32_t destnode,
+						    uint64_t srvid,
+						    uint32_t opcode,
+						    uint32_t flags,
+						    TDB_DATA data,
+						    TALLOC_CTX *mem_ctx,
+						    struct timeval *timeout,
+						    char **errormsg);
+int ctdb_control_recv(struct ctdb_context *ctdb,
+		      struct ctdb_client_control_state *state,
+		      TALLOC_CTX *mem_ctx, TDB_DATA *outdata,
+		      int32_t *status, char **errormsg);
+int ctdb_control(struct ctdb_context *ctdb, uint32_t destnode, uint64_t srvid,
+		 uint32_t opcode, uint32_t flags, TDB_DATA data,
+		 TALLOC_CTX *mem_ctx, TDB_DATA *outdata, int32_t *status,
+		 struct timeval *timeout, char **errormsg);
+
+int ctdb_ctrl_getvnnmap(struct ctdb_context *ctdb, struct timeval timeout,
+			uint32_t destnode, TALLOC_CTX *mem_ctx,
+			struct ctdb_vnn_map **vnnmap);
+
+/*
+  get the recovery mode of a remote node
+ */
+struct ctdb_client_control_state *ctdb_ctrl_getrecmode_send(
+					struct ctdb_context *ctdb,
+					TALLOC_CTX *mem_ctx,
+					struct timeval timeout,
+					uint32_t destnode);
+int ctdb_ctrl_getrecmode_recv(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx,
+			      struct ctdb_client_control_state *state,
+			      uint32_t *recmode);
+int ctdb_ctrl_getrecmode(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx,
+			 struct timeval timeout, uint32_t destnode,
+			 uint32_t *recmode);
+
+/*
+  set the recovery mode of a remote node
+ */
+int ctdb_ctrl_setrecmode(struct ctdb_context *ctdb, struct timeval timeout,
+			 uint32_t destnode, uint32_t recmode);
+
+int ctdb_ctrl_getnodemap(struct ctdb_context *ctdb, struct timeval timeout,
+			 uint32_t destnode, TALLOC_CTX *mem_ctx,
+			 struct ctdb_node_map_old **nodemap);
+
+int ctdb_ctrl_get_runstate(struct ctdb_context *ctdb, struct timeval timeout,
+			   uint32_t destnode, uint32_t *runstate);
+
+int ctdb_ctrl_get_debuglevel(struct ctdb_context *ctdb, uint32_t destnode,
+			     int32_t *level);
+
+int ctdb_ctrl_freeze(struct ctdb_context *ctdb, struct timeval timeout,
+		     uint32_t destnode);
+
+int ctdb_ctrl_getpnn(struct ctdb_context *ctdb, struct timeval timeout,
+		     uint32_t destnode);
+
+int ctdb_ctrl_get_public_ips_flags(struct ctdb_context *ctdb,
+				   struct timeval timeout, uint32_t destnode,
+				   TALLOC_CTX *mem_ctx, uint32_t flags,
+				   struct ctdb_public_ip_list_old **ips);
+int ctdb_ctrl_get_public_ips(struct ctdb_context *ctdb,
+			     struct timeval timeout, uint32_t destnode,
+			     TALLOC_CTX *mem_ctx,
+			     struct ctdb_public_ip_list_old **ips);
+
+int ctdb_ctrl_get_ifaces(struct ctdb_context *ctdb,
+			 struct timeval timeout, uint32_t destnode,
+			 TALLOC_CTX *mem_ctx,
+			 struct ctdb_iface_list_old **ifaces);
+
+int ctdb_ctrl_get_all_tunables(struct ctdb_context *ctdb,
+			       struct timeval timeout, uint32_t destnode,
+			       struct ctdb_tunable_list *tunables);
+
+/*
+  set some flags
+*/
+void ctdb_set_flags(struct ctdb_context *ctdb, unsigned flags);
+
+const char *ctdb_get_socketname(struct ctdb_context *ctdb);
+
+/* return pnn of this node */
+uint32_t ctdb_get_pnn(struct ctdb_context *ctdb);
+
+typedef void (*client_async_callback)(struct ctdb_context *ctdb,
+				      uint32_t node_pnn, int32_t res,
+				      TDB_DATA outdata, void *callback_data);
+
+struct client_async_data {
+	enum ctdb_controls opcode;
+	bool dont_log_errors;
+	uint32_t count;
+	uint32_t fail_count;
+	client_async_callback callback;
+	client_async_callback fail_callback;
+	void *callback_data;
+};
+
+void ctdb_client_async_add(struct client_async_data *data,
+			   struct ctdb_client_control_state *state);
+int ctdb_client_async_wait(struct ctdb_context *ctdb,
+			   struct client_async_data *data);
+int ctdb_client_async_control(struct ctdb_context *ctdb,
+			      enum ctdb_controls opcode, uint32_t *nodes,
+			      uint64_t srvid, struct timeval timeout,
+			      bool dont_log_errors, TDB_DATA data,
+			      client_async_callback client_callback,
+			      client_async_callback fail_callback,
+			      void *callback_data);
+
+uint32_t *list_of_vnnmap_nodes(struct ctdb_context *ctdb,
+			       struct ctdb_vnn_map *vnn_map,
+			       TALLOC_CTX *mem_ctx, bool include_self);
+
+uint32_t *list_of_active_nodes(struct ctdb_context *ctdb,
+			       struct ctdb_node_map_old *node_map,
+			       TALLOC_CTX *mem_ctx, bool include_self);
+uint32_t *list_of_connected_nodes(struct ctdb_context *ctdb,
+				  struct ctdb_node_map_old *node_map,
+				  TALLOC_CTX *mem_ctx, bool include_self);
+
+/*
+  get capabilities of a remote node
+ */
+
+struct ctdb_client_control_state *ctdb_ctrl_getcapabilities_send(
+					struct ctdb_context *ctdb,
+					TALLOC_CTX *mem_ctx,
+					struct timeval timeout,
+					uint32_t destnode);
+int ctdb_ctrl_getcapabilities_recv(struct ctdb_context *ctdb,
+				   TALLOC_CTX *mem_ctx,
+				   struct ctdb_client_control_state *state,
+				   uint32_t *capabilities);
+int ctdb_ctrl_getcapabilities(struct ctdb_context *ctdb,
+			      struct timeval timeout, uint32_t destnode,
+			      uint32_t *capabilities);
+
+struct ctdb_node_capabilities {
+	bool retrieved;
+	uint32_t capabilities;
+};
+
+/* Retrieve capabilities for all connected nodes.  The length of the
+ * returned array can be calculated using talloc_array_length(). */
+struct ctdb_node_capabilities *ctdb_get_capabilities(
+					struct ctdb_context *ctdb,
+					TALLOC_CTX *mem_ctx,
+					struct timeval timeout,
+					struct ctdb_node_map_old *nodemap);
+
+/* Get capabilities for specified node, NULL if not found */
+uint32_t *ctdb_get_node_capabilities(struct ctdb_node_capabilities *caps,
+				     uint32_t pnn);
+
+/* True if the given node has all of the required capabilities */
+bool ctdb_node_has_capabilities(struct ctdb_node_capabilities *caps,
+				uint32_t pnn, uint32_t capabilities_required);
+
+int ctdb_ctrl_recd_ping(struct ctdb_context *ctdb);
+
+int ctdb_ctrl_report_recd_lock_latency(struct ctdb_context *ctdb,
+				       struct timeval timeout, double latency);
+
+int ctdb_ctrl_set_ban(struct ctdb_context *ctdb, struct timeval timeout,
+		      uint32_t destnode, struct ctdb_ban_state *bantime);
+
+struct ctdb_client_control_state *ctdb_ctrl_updaterecord_send(
+					struct ctdb_context *ctdb,
+					TALLOC_CTX *mem_ctx,
+					struct timeval timeout,
+					uint32_t destnode,
+					struct ctdb_db_context *ctdb_db,
+					TDB_DATA key,
+					struct ctdb_ltdb_header *header,
+					TDB_DATA data);
+int ctdb_ctrl_updaterecord_recv(struct ctdb_context *ctdb,
+				struct ctdb_client_control_state *state);
+int ctdb_ctrl_updaterecord(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx,
+			   struct timeval timeout, uint32_t destnode,
+			   struct ctdb_db_context *ctdb_db, TDB_DATA key,
+			   struct ctdb_ltdb_header *header, TDB_DATA data);
+
+#endif /* _CTDB_CLIENT_H */
diff --git a/ctdb/include/ctdb_private.h b/ctdb/include/ctdb_private.h
new file mode 100644
index 0000000..3395f07
--- /dev/null
+++ b/ctdb/include/ctdb_private.h
@@ -0,0 +1,1035 @@
+/* 
+   ctdb database library
+
+   Copyright (C) Andrew Tridgell  2006
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _CTDB_PRIVATE_H
+#define _CTDB_PRIVATE_H
+
+#include "ctdb_client.h"
+#include <sys/socket.h>
+
+#include "common/db_hash.h"
+
+/*
+  array of tcp connections
+ */
+struct ctdb_tcp_array {
+	uint32_t num;
+	struct ctdb_connection *connections;
+};
+
+/*
+  an installed ctdb remote call
+*/
+typedef int (*ctdb_fn_t)(struct ctdb_call_info *);
+
+struct ctdb_registered_call {
+	struct ctdb_registered_call *next, *prev;
+	uint32_t id;
+	ctdb_fn_t fn;
+};
+
+/*
+  check that a pnn is valid
+ */
+#define ctdb_validate_pnn(ctdb, pnn) (((uint32_t)(pnn)) < (ctdb)->num_nodes)
+
+/* used for callbacks in ctdb_control requests */
+typedef void (*ctdb_control_callback_fn_t)(struct ctdb_context *,
+					   int32_t status, TDB_DATA data, 
+					   const char *errormsg,
+					   void *private_data);
+/*
+  structure describing a connected client in the daemon
+ */
+struct ctdb_client {
+	struct ctdb_context *ctdb;
+	int fd;
+	struct ctdb_queue *queue;
+	uint32_t client_id;
+	pid_t pid;
+	struct ctdb_tcp_list *tcp_list;
+	uint32_t db_id;
+	uint32_t num_persistent_updates;
+	struct ctdb_client_notify_list *notify;
+};
+
+/*
+  state associated with one node
+*/
+struct ctdb_node {
+	struct ctdb_context *ctdb;
+	ctdb_sock_addr address;
+	const char *name; /* for debug messages */
+	void *transport_data; /* private to transport */
+	uint32_t pnn;
+	uint32_t flags;
+
+	/* used by the dead node monitoring */
+	uint32_t dead_count;
+	uint32_t rx_cnt;
+	uint32_t tx_cnt;
+
+	/* a list of controls pending to this node, so we can time them out quickly
+	   if the node becomes disconnected */
+	struct daemon_control_state *pending_controls;
+};
+
+/*
+  transport specific methods
+*/
+struct ctdb_methods {
+	int (*initialise)(struct ctdb_context *); /* initialise transport structures */	
+	int (*start)(struct ctdb_context *); /* start the transport */
+	int (*add_node)(struct ctdb_node *); /* setup a new node */	
+	int (*connect_node)(struct ctdb_node *); /* connect to node */
+	int (*queue_pkt)(struct ctdb_node *, uint8_t *data, uint32_t length);
+	void *(*allocate_pkt)(TALLOC_CTX *mem_ctx, size_t );
+	void (*shutdown)(struct ctdb_context *); /* shutdown transport */
+	void (*restart)(struct ctdb_node *); /* stop and restart the connection */
+};
+
+/*
+  transport calls up to the ctdb layer
+*/
+struct ctdb_upcalls {
+	/* recv_pkt is called when a packet comes in */
+	void (*recv_pkt)(struct ctdb_context *, uint8_t *data, uint32_t length);
+
+	/* node_dead is called when an attempt to send to a node fails */
+	void (*node_dead)(struct ctdb_node *);
+
+	/* node_connected is called when a connection to a node is established */
+	void (*node_connected)(struct ctdb_node *);
+};
+
+/* additional data required for the daemon mode */
+struct ctdb_daemon_data {
+	int sd;
+	char *name;
+	struct ctdb_queue *queue;
+};
+
+
+#define CTDB_UPDATE_STAT(ctdb, counter, value) \
+	{										\
+		if (value > ctdb->statistics.counter) {					\
+			ctdb->statistics.counter = value;				\
+		}									\
+		if (value > ctdb->statistics_current.counter) {				\
+			ctdb->statistics_current.counter = value;			\
+		}									\
+	}
+
+#define CTDB_INCREMENT_STAT(ctdb, counter) \
+	{										\
+		ctdb->statistics.counter++;						\
+		ctdb->statistics_current.counter++;					\
+	}
+
+#define CTDB_DECREMENT_STAT(ctdb, counter) \
+	{										\
+		if (ctdb->statistics.counter > 0)					\
+			ctdb->statistics.counter--;					\
+		if (ctdb->statistics_current.counter > 0)				\
+			ctdb->statistics_current.counter--;				\
+	}
+
+#define CTDB_INCREMENT_DB_STAT(ctdb_db, counter) \
+	{										\
+		ctdb_db->statistics.counter++;						\
+	}
+
+#define CTDB_DECREMENT_DB_STAT(ctdb_db, counter) \
+	{										\
+		if (ctdb_db->statistics.counter > 0)					\
+			ctdb_db->statistics.counter--;					\
+	}
+
+#define CTDB_UPDATE_RECLOCK_LATENCY(ctdb, name, counter, value) \
+	{										\
+		if (value > ctdb->statistics.counter.max)				\
+			ctdb->statistics.counter.max = value;				\
+		if (value > ctdb->statistics_current.counter.max)			\
+			ctdb->statistics_current.counter.max = value;			\
+											\
+		if (ctdb->statistics.counter.num == 0 ||				\
+		    value < ctdb->statistics.counter.min)				\
+			ctdb->statistics.counter.min = value;				\
+		if (ctdb->statistics_current.counter.num == 0 ||			\
+		    value < ctdb->statistics_current.counter.min)			\
+			ctdb->statistics_current.counter.min = value;			\
+											\
+		ctdb->statistics.counter.total += value;				\
+		ctdb->statistics_current.counter.total += value;			\
+											\
+		ctdb->statistics.counter.num++;						\
+		ctdb->statistics_current.counter.num++;					\
+											\
+		if (ctdb->tunable.reclock_latency_ms != 0) {				\
+			if (value*1000 > ctdb->tunable.reclock_latency_ms) {		\
+				DEBUG(DEBUG_ERR,					\
+				      ("High RECLOCK latency %fs for operation %s\n",	\
+				       value, name));					\
+			}								\
+		}									\
+	}
+
+#define CTDB_UPDATE_DB_LATENCY(ctdb_db, operation, counter, value)			\
+	{										\
+		if (value > ctdb_db->statistics.counter.max)				\
+			ctdb_db->statistics.counter.max = value;			\
+		if (ctdb_db->statistics.counter.num == 0 || 				\
+		    value < ctdb_db->statistics.counter.min)				\
+			ctdb_db->statistics.counter.min = value;			\
+											\
+		ctdb_db->statistics.counter.total += value;				\
+		ctdb_db->statistics.counter.num++;					\
+											\
+		if (ctdb_db->ctdb->tunable.log_latency_ms != 0) {			\
+			if (value*1000 > ctdb_db->ctdb->tunable.log_latency_ms) {	\
+				DEBUG(DEBUG_ERR,					\
+				      ("High latency %.6fs for operation %s on database %s\n",\
+				       value, operation, ctdb_db->db_name));		\
+			}								\
+		}									\
+	}
+
+#define CTDB_UPDATE_LATENCY(ctdb, db, operation, counter, t) \
+	{										\
+		double l = timeval_elapsed(&t);						\
+											\
+		if (l > ctdb->statistics.counter.max)					\
+			ctdb->statistics.counter.max = l;				\
+		if (l > ctdb->statistics_current.counter.max)				\
+			ctdb->statistics_current.counter.max = l;			\
+											\
+		if (ctdb->statistics.counter.num == 0 ||				\
+		    l < ctdb->statistics.counter.min)					\
+			ctdb->statistics.counter.min = l;				\
+		if (ctdb->statistics_current.counter.num == 0 ||			\
+		    l < ctdb->statistics_current.counter.min)				\
+			ctdb->statistics_current.counter.min = l;			\
+											\
+		ctdb->statistics.counter.total += l;					\
+		ctdb->statistics_current.counter.total += l;				\
+											\
+		ctdb->statistics.counter.num++;						\
+		ctdb->statistics_current.counter.num++;					\
+											\
+		if (ctdb->tunable.log_latency_ms != 0) {				\
+			if (l*1000 > ctdb->tunable.log_latency_ms) {			\
+				DEBUG(DEBUG_WARNING,					\
+				      ("High latency %.6fs for operation %s on database %s\n",\
+				       l, operation, db->db_name));			\
+			}								\
+		}									\
+	}
+
+
+struct ctdb_cluster_mutex_handle;
+struct eventd_context;
+
+enum ctdb_freeze_mode {CTDB_FREEZE_NONE, CTDB_FREEZE_PENDING, CTDB_FREEZE_FROZEN};
+
+/* main state of the ctdb daemon */
+struct ctdb_context {
+	struct tevent_context *ev;
+	struct timeval ctdbd_start_time;
+	struct timeval last_recovery_started;
+	struct timeval last_recovery_finished;
+	uint32_t recovery_mode;
+	TALLOC_CTX *tickle_update_context;
+	TALLOC_CTX *keepalive_ctx;
+	TALLOC_CTX *check_public_ifaces_ctx;
+	struct ctdb_tunable_list tunable;
+	enum ctdb_freeze_mode freeze_mode;
+	struct ctdb_freeze_handle *freeze_handle;
+	bool freeze_transaction_started;
+	uint32_t freeze_transaction_id;
+	ctdb_sock_addr *address;
+	const char *name;
+	const char *db_directory;
+	const char *db_directory_persistent;
+	const char *db_directory_state;
+	struct tdb_wrap *db_persistent_health;
+	uint32_t db_persistent_startup_generation;
+	uint64_t db_persistent_check_errors;
+	uint64_t max_persistent_check_errors;
+	const char *transport;
+	const char *recovery_lock;
+	uint32_t pnn; /* our own pnn */
+	uint32_t num_nodes;
+	uint32_t num_connected;
+	unsigned flags;
+	uint32_t capabilities;
+	struct reqid_context *idr;
+	struct ctdb_node **nodes; /* array of nodes in the cluster - indexed by vnn */
+	struct ctdb_vnn *vnn; /* list of public ip addresses and interfaces */
+	struct ctdb_interface *ifaces; /* list of local interfaces */
+	char *err_msg;
+	const struct ctdb_methods *methods; /* transport methods */
+	const struct ctdb_upcalls *upcalls; /* transport upcalls */
+	void *transport_data; /* private to transport */
+	struct ctdb_db_context *db_list;
+	struct srvid_context *srv;
+	struct srvid_context *tunnels;
+	struct ctdb_daemon_data daemon;
+	struct ctdb_statistics statistics;
+	struct ctdb_statistics statistics_current;
+#define MAX_STAT_HISTORY 100
+	struct ctdb_statistics statistics_history[MAX_STAT_HISTORY];
+	struct ctdb_vnn_map *vnn_map;
+	uint32_t num_clients;
+	struct ctdb_client_ip *client_ip_list;
+	bool do_checkpublicip;
+	bool do_setsched;
+	const char *event_script_dir;
+	const char *notification_script;
+	pid_t ctdbd_pid;
+	pid_t recoverd_pid;
+	enum ctdb_runstate runstate;
+	struct ctdb_monitor_state *monitor;
+	int start_as_disabled;
+	int start_as_stopped;
+	bool valgrinding;
+	uint32_t *recd_ping_count;
+	TALLOC_CTX *recd_ctx; /* a context used to track recoverd monitoring events */
+	TALLOC_CTX *release_ips_ctx; /* a context used to automatically drop all IPs if we fail to recover the node */
+
+	struct eventd_context *ectx;
+
+	TALLOC_CTX *banning_ctx;
+
+	struct ctdb_vacuum_child_context *vacuumer;
+
+	/* mapping from pid to ctdb_client * */
+	struct ctdb_client_pid_list *client_pids;
+
+	/* Used to defer db attach requests while in recovery mode */
+	struct ctdb_deferred_attach_context *deferred_attach;
+
+	/* if we are a child process, do we have a domain socket to send controls on */
+	bool can_send_controls;
+
+	struct ctdb_reloadips_handle *reload_ips;
+
+	const char *nodes_file;
+	const char *public_addresses_file;
+	struct trbt_tree *child_processes; 
+
+	/* Used for locking record/db/alldb */
+	struct lock_context *lock_current;
+	struct lock_context *lock_pending;
+};
+
+struct ctdb_db_hot_key {
+	uint32_t count;
+	TDB_DATA key;
+	uint32_t last_logged_count;
+};
+
+struct ctdb_db_context {
+	struct ctdb_db_context *next, *prev;
+	struct ctdb_context *ctdb;
+	uint32_t db_id;
+	uint8_t db_flags;
+	const char *db_name;
+	const char *db_path;
+	struct tdb_wrap *ltdb;
+	struct tdb_context *rottdb; /* ReadOnly tracking TDB */
+	struct ctdb_registered_call *calls; /* list of registered calls */
+	uint32_t seqnum;
+	struct tevent_timer *seqnum_update;
+	struct ctdb_traverse_local_handle *traverse;
+	struct ctdb_vacuum_handle *vacuum_handle;
+	char *unhealthy_reason;
+	int pending_requests;
+	struct revokechild_handle *revokechild_active;
+	struct ctdb_persistent_state *persistent_state;
+	struct trbt_tree *delete_queue;
+	struct trbt_tree *fetch_queue;
+	struct trbt_tree *sticky_records; 
+	int (*ctdb_ltdb_store_fn)(struct ctdb_db_context *ctdb_db,
+				  TDB_DATA key,
+				  struct ctdb_ltdb_header *header,
+				  TDB_DATA data);
+
+	/* used to track which records we are currently fetching
+	   so we can avoid sending duplicate fetch requests
+	*/
+	struct trbt_tree *deferred_fetch;
+	struct trbt_tree *defer_dmaster;
+
+	struct ctdb_db_statistics_old statistics;
+	struct ctdb_db_hot_key hot_keys[MAX_HOT_KEYS];
+
+	struct lock_context *lock_current;
+	struct lock_context *lock_pending;
+	unsigned int lock_num_current;
+	struct db_hash_context *lock_log;
+
+	struct ctdb_call_state *pending_calls;
+
+	enum ctdb_freeze_mode freeze_mode;
+	struct ctdb_db_freeze_handle *freeze_handle;
+	bool freeze_transaction_started;
+	uint32_t freeze_transaction_id;
+	uint32_t generation;
+
+	bool invalid_records;
+	bool push_started;
+	void *push_state;
+
+	struct hash_count_context *migratedb;
+};
+
+
+#define CTDB_NO_MEMORY(ctdb, p) do { if (!(p)) { \
+          DEBUG(0,("Out of memory for %s at %s\n", #p, __location__)); \
+          ctdb_set_error(ctdb, "Out of memory at %s:%d", __FILE__, __LINE__); \
+	  return -1; }} while (0)
+
+#define CTDB_NO_MEMORY_VOID(ctdb, p) do { if (!(p)) { \
+          DEBUG(0,("Out of memory for %s at %s\n", #p, __location__)); \
+          ctdb_set_error(ctdb, "Out of memory at %s:%d", __FILE__, __LINE__); \
+	  return; }} while (0)
+
+#define CTDB_NO_MEMORY_NULL(ctdb, p) do { if (!(p)) { \
+          DEBUG(0,("Out of memory for %s at %s\n", #p, __location__)); \
+          ctdb_set_error(ctdb, "Out of memory at %s:%d", __FILE__, __LINE__); \
+	  return NULL; }} while (0)
+
+#define CTDB_NO_MEMORY_FATAL(ctdb, p) do { if (!(p)) { \
+          DEBUG(0,("Out of memory for %s at %s\n", #p, __location__)); \
+          ctdb_fatal(ctdb, "Out of memory in " __location__ ); \
+	  }} while (0)
+
+
+enum call_state {CTDB_CALL_WAIT, CTDB_CALL_DONE, CTDB_CALL_ERROR};
+
+/*
+  state of a in-progress ctdb call
+*/
+struct ctdb_call_state {
+	struct ctdb_call_state *next, *prev;
+	enum call_state state;
+	uint32_t reqid;
+	struct ctdb_req_call_old *c;
+	struct ctdb_db_context *ctdb_db;
+	const char *errmsg;
+	struct ctdb_call *call;
+	uint32_t generation;
+	struct {
+		void (*fn)(struct ctdb_call_state *);
+		void *private_data;
+	} async;
+};
+
+/* internal prototypes */
+
+#define CHECK_CONTROL_DATA_SIZE(size) do { \
+ if (indata.dsize != size) { \
+	 DEBUG(0,(__location__ " Invalid data size in opcode %u. Got %u expected %u\n", \
+		  opcode, (unsigned)indata.dsize, (unsigned)size));	\
+	 return -1; \
+ } \
+ } while (0)
+
+#define CHECK_CONTROL_MIN_DATA_SIZE(size) do { \
+ if (indata.dsize < size) { \
+	 DEBUG(0,(__location__ " Invalid data size in opcode %u. Got %u expected >= %u\n", \
+		  opcode, (unsigned)indata.dsize, (unsigned)size));	\
+	 return -1; \
+ } \
+ } while (0)
+
+/*
+  state of a in-progress ctdb call in client
+*/
+struct ctdb_client_call_state {
+	enum call_state state;
+	uint32_t reqid;
+	struct ctdb_db_context *ctdb_db;
+	struct ctdb_call *call;
+	struct {
+		void (*fn)(struct ctdb_client_call_state *);
+		void *private_data;
+	} async;
+};
+
+extern int script_log_level;
+extern bool fast_start;
+extern const char *ctdbd_pidfile;
+
+typedef void (*deferred_requeue_fn)(void *call_context, struct ctdb_req_header *hdr);
+
+
+/* from tcp/ and ib/ */
+
+int ctdb_tcp_init(struct ctdb_context *ctdb);
+int ctdb_ibw_init(struct ctdb_context *ctdb);
+
+/* from ctdb_banning.c */
+
+int32_t ctdb_control_set_ban_state(struct ctdb_context *ctdb, TDB_DATA indata);
+int32_t ctdb_control_get_ban_state(struct ctdb_context *ctdb, TDB_DATA *outdata);
+void ctdb_ban_self(struct ctdb_context *ctdb);
+
+/* from ctdb_call.c */
+
+struct ctdb_db_context *find_ctdb_db(struct ctdb_context *ctdb, uint32_t id);
+
+void ctdb_request_dmaster(struct ctdb_context *ctdb,
+			  struct ctdb_req_header *hdr);
+void ctdb_reply_dmaster(struct ctdb_context *ctdb,
+			struct ctdb_req_header *hdr);
+void ctdb_request_call(struct ctdb_context *ctdb, struct ctdb_req_header *hdr);
+void ctdb_reply_call(struct ctdb_context *ctdb, struct ctdb_req_header *hdr);
+void ctdb_reply_error(struct ctdb_context *ctdb, struct ctdb_req_header *hdr);
+
+void ctdb_call_resend_db(struct ctdb_db_context *ctdb);
+void ctdb_call_resend_all(struct ctdb_context *ctdb);
+
+struct ctdb_call_state *ctdb_call_local_send(struct ctdb_db_context *ctdb_db,
+					     struct ctdb_call *call,
+					     struct ctdb_ltdb_header *header,
+					     TDB_DATA *data);
+
+struct ctdb_call_state *ctdb_daemon_call_send_remote(
+					struct ctdb_db_context *ctdb_db,
+					struct ctdb_call *call,
+					struct ctdb_ltdb_header *header);
+int ctdb_daemon_call_recv(struct ctdb_call_state *state,
+			  struct ctdb_call *call);
+
+int ctdb_start_revoke_ro_record(struct ctdb_context *ctdb,
+				struct ctdb_db_context *ctdb_db,
+				TDB_DATA key, struct ctdb_ltdb_header *header,
+				TDB_DATA data);
+
+int ctdb_add_revoke_deferred_call(struct ctdb_context *ctdb,
+				  struct ctdb_db_context *ctdb_db,
+				  TDB_DATA key, struct ctdb_req_header *hdr,
+				  deferred_requeue_fn fn, void *call_context);
+
+int ctdb_migration_init(struct ctdb_db_context *ctdb_db);
+
+/* from server/ctdb_control.c */
+
+int32_t ctdb_dump_memory(struct ctdb_context *ctdb, TDB_DATA *outdata);
+
+void ctdb_request_control_reply(struct ctdb_context *ctdb,
+				struct ctdb_req_control_old *c,
+				TDB_DATA *outdata, int32_t status,
+				const char *errormsg);
+
+void ctdb_request_control(struct ctdb_context *ctdb,
+			  struct ctdb_req_header *hdr);
+void ctdb_reply_control(struct ctdb_context *ctdb,
+			struct ctdb_req_header *hdr);
+
+int ctdb_daemon_send_control(struct ctdb_context *ctdb, uint32_t destnode,
+			     uint64_t srvid, uint32_t opcode,
+			     uint32_t client_id, uint32_t flags,
+			     TDB_DATA data,
+			     ctdb_control_callback_fn_t callback,
+			     void *private_data);
+
+/* from server/ctdb_daemon.c */
+
+int daemon_register_message_handler(struct ctdb_context *ctdb,
+				    uint32_t client_id, uint64_t srvid);
+int daemon_deregister_message_handler(struct ctdb_context *ctdb,
+				      uint32_t client_id, uint64_t srvid);
+
+void daemon_tunnel_handler(uint64_t tunnel_id, TDB_DATA data,
+			   void *private_data);
+
+struct ctdb_node *ctdb_find_node(struct ctdb_context *ctdb, uint32_t pnn);
+
+int ctdb_start_daemon(struct ctdb_context *ctdb,
+		      bool interactive,
+		      bool test_mode_enabled);
+
+struct ctdb_req_header *_ctdb_transport_allocate(struct ctdb_context *ctdb,
+						 TALLOC_CTX *mem_ctx,
+						 enum ctdb_operation operation,
+						 size_t length, size_t slength,
+						 const char *type);
+
+#define ctdb_transport_allocate(ctdb, mem_ctx, operation, length, type) \
+	(type *)_ctdb_transport_allocate(ctdb, mem_ctx, operation, length, \
+					 sizeof(type), #type)
+
+void ctdb_daemon_cancel_controls(struct ctdb_context *ctdb,
+				 struct ctdb_node *node);
+
+int ctdb_daemon_set_call(struct ctdb_context *ctdb, uint32_t db_id,
+			 ctdb_fn_t fn, int id);
+
+int ctdb_daemon_send_message(struct ctdb_context *ctdb, uint32_t pnn,
+			     uint64_t srvid, TDB_DATA data);
+
+int32_t ctdb_control_register_notify(struct ctdb_context *ctdb,
+				     uint32_t client_id, TDB_DATA indata);
+int32_t ctdb_control_deregister_notify(struct ctdb_context *ctdb,
+				       uint32_t client_id, TDB_DATA indata);
+
+struct ctdb_client *ctdb_find_client_by_pid(struct ctdb_context *ctdb,
+					    pid_t pid);
+
+int32_t ctdb_control_process_exists(struct ctdb_context *ctdb, pid_t pid);
+int32_t ctdb_control_check_pid_srvid(struct ctdb_context *ctdb,
+				     TDB_DATA indata);
+
+int ctdb_control_getnodesfile(struct ctdb_context *ctdb, uint32_t opcode,
+			      TDB_DATA indata, TDB_DATA *outdata);
+
+void ctdb_shutdown_sequence(struct ctdb_context *ctdb, int exit_code);
+
+int switch_from_server_to_client(struct ctdb_context *ctdb);
+
+/* From server/ctdb_fork.c */
+
+void ctdb_track_child(struct ctdb_context *ctdb, pid_t pid);
+
+pid_t ctdb_fork(struct ctdb_context *ctdb);
+pid_t ctdb_vfork_exec(TALLOC_CTX *mem_ctx, struct ctdb_context *ctdb,
+		      const char *helper, int helper_argc,
+		      const char **helper_argv);
+
+struct tevent_signal *ctdb_init_sigchld(struct ctdb_context *ctdb);
+
+int ctdb_kill(struct ctdb_context *ctdb, pid_t pid, int signum);
+
+/* from server/ctdb_freeze.c */
+
+int32_t ctdb_control_db_freeze(struct ctdb_context *ctdb,
+			       struct ctdb_req_control_old *c,
+			       uint32_t db_id, bool *async_reply);
+int32_t ctdb_control_db_thaw(struct ctdb_context *ctdb, uint32_t db_id);
+
+int32_t ctdb_control_freeze(struct ctdb_context *ctdb,
+			    struct ctdb_req_control_old *c, bool *async_reply);
+int32_t ctdb_control_thaw(struct ctdb_context *ctdb, bool check_recmode);
+
+bool ctdb_blocking_freeze(struct ctdb_context *ctdb);
+
+int32_t ctdb_control_db_transaction_start(struct ctdb_context *ctdb,
+					  TDB_DATA indata);
+int32_t ctdb_control_db_transaction_cancel(struct ctdb_context *ctdb,
+					   TDB_DATA indata);
+int32_t ctdb_control_db_transaction_commit(struct ctdb_context *ctdb,
+					   TDB_DATA indata);
+
+int32_t ctdb_control_wipe_database(struct ctdb_context *ctdb, TDB_DATA indata);
+
+bool ctdb_db_frozen(struct ctdb_db_context *ctdb_db);
+bool ctdb_db_all_frozen(struct ctdb_context *ctdb);
+bool ctdb_db_allow_access(struct ctdb_db_context *ctdb_db);
+
+/* from server/ctdb_keepalive.c */
+
+void ctdb_start_keepalive(struct ctdb_context *ctdb);
+void ctdb_stop_keepalive(struct ctdb_context *ctdb);
+
+void ctdb_request_keepalive(struct ctdb_context *ctdb,
+			    struct ctdb_req_header *hdr);
+
+/* from server/ctdb_lock.c */
+
+struct lock_request;
+
+typedef int (*ctdb_db_handler_t)(struct ctdb_db_context *ctdb_db,
+				 void *private_data);
+
+int ctdb_db_iterator(struct ctdb_context *ctdb, ctdb_db_handler_t handler,
+		     void *private_data);
+
+int ctdb_lockdb_mark(struct ctdb_db_context *ctdb_db);
+
+int ctdb_lockdb_unmark(struct ctdb_db_context *ctdb_db);
+
+struct lock_request *ctdb_lock_record(TALLOC_CTX *mem_ctx,
+				      struct ctdb_db_context *ctdb_db,
+				      TDB_DATA key,
+				      bool auto_mark,
+				      void (*callback)(void *, bool),
+				      void *private_data);
+
+struct lock_request *ctdb_lock_db(TALLOC_CTX *mem_ctx,
+				  struct ctdb_db_context *ctdb_db,
+				  bool auto_mark,
+				  void (*callback)(void *, bool),
+				  void *private_data);
+
+/* from ctdb_logging.c */
+
+bool ctdb_logging_init(TALLOC_CTX *mem_ctx, const char *logging,
+		       const char *debug_level);
+
+int ctdb_set_child_logging(struct ctdb_context *ctdb);
+
+/* from ctdb_logging_file.c */
+
+void ctdb_log_init_file(void);
+
+/* from ctdb_logging_syslog.c */
+
+void ctdb_log_init_syslog(void);
+
+/* from ctdb_ltdb_server.c */
+
+int ctdb_ltdb_lock_requeue(struct ctdb_db_context *ctdb_db,
+			   TDB_DATA key, struct ctdb_req_header *hdr,
+			   void (*recv_pkt)(void *, struct ctdb_req_header *),
+			   void *recv_context, bool ignore_generation);
+
+int ctdb_ltdb_lock_fetch_requeue(struct ctdb_db_context *ctdb_db,
+				 TDB_DATA key, struct ctdb_ltdb_header *header,
+				 struct ctdb_req_header *hdr, TDB_DATA *data,
+				 void (*recv_pkt)(void *, struct ctdb_req_header *),
+				 void *recv_context, bool ignore_generation);
+
+int ctdb_load_persistent_health(struct ctdb_context *ctdb,
+				struct ctdb_db_context *ctdb_db);
+int ctdb_update_persistent_health(struct ctdb_context *ctdb,
+				  struct ctdb_db_context *ctdb_db,
+				  const char *reason,/* NULL means healthy */
+				  unsigned int num_healthy_nodes);
+int ctdb_recheck_persistent_health(struct ctdb_context *ctdb);
+
+int32_t ctdb_control_db_set_healthy(struct ctdb_context *ctdb,
+				    TDB_DATA indata);
+int32_t ctdb_control_db_get_health(struct ctdb_context *ctdb,
+				   TDB_DATA indata, TDB_DATA *outdata);
+
+int ctdb_set_db_readonly(struct ctdb_context *ctdb,
+			 struct ctdb_db_context *ctdb_db);
+
+int ctdb_process_deferred_attach(struct ctdb_context *ctdb);
+
+int32_t ctdb_control_db_attach(struct ctdb_context *ctdb,
+			       TDB_DATA indata,
+			       TDB_DATA *outdata,
+			       uint8_t db_flags,
+			       uint32_t srcnode,
+			       uint32_t client_id,
+			       struct ctdb_req_control_old *c,
+			       bool *async_reply);
+int32_t ctdb_control_db_detach(struct ctdb_context *ctdb, TDB_DATA indata,
+			       uint32_t client_id);
+
+int ctdb_attach_databases(struct ctdb_context *ctdb);
+
+int32_t ctdb_ltdb_update_seqnum(struct ctdb_context *ctdb, uint32_t db_id,
+				uint32_t srcnode);
+int32_t ctdb_ltdb_enable_seqnum(struct ctdb_context *ctdb, uint32_t db_id);
+
+int ctdb_set_db_sticky(struct ctdb_context *ctdb,
+		       struct ctdb_db_context *ctdb_db);
+
+void ctdb_db_statistics_reset(struct ctdb_db_context *ctdb_db);
+
+int32_t ctdb_control_get_db_statistics(struct ctdb_context *ctdb,
+				       uint32_t db_id, TDB_DATA *outdata);
+
+/* from ctdb_monitor.c */
+
+void ctdb_run_notification_script(struct ctdb_context *ctdb, const char *event);
+
+void ctdb_stop_monitoring(struct ctdb_context *ctdb);
+
+void ctdb_wait_for_first_recovery(struct ctdb_context *ctdb);
+
+int32_t ctdb_control_modflags(struct ctdb_context *ctdb, TDB_DATA indata);
+
+/* from ctdb_persistent.c */
+
+void ctdb_persistent_finish_trans3_commits(struct ctdb_context *ctdb);
+
+int32_t ctdb_control_trans3_commit(struct ctdb_context *ctdb,
+				   struct ctdb_req_control_old *c,
+				   TDB_DATA recdata, bool *async_reply);
+
+int32_t ctdb_control_start_persistent_update(struct ctdb_context *ctdb,
+					     struct ctdb_req_control_old *c,
+					     TDB_DATA recdata);
+int32_t ctdb_control_cancel_persistent_update(struct ctdb_context *ctdb,
+					      struct ctdb_req_control_old *c,
+					      TDB_DATA recdata);
+
+int32_t ctdb_control_get_db_seqnum(struct ctdb_context *ctdb,
+				   TDB_DATA indata, TDB_DATA *outdata);
+
+/* from ctdb_recover.c */
+
+int ctdb_control_getvnnmap(struct ctdb_context *ctdb, uint32_t opcode,
+			   TDB_DATA indata, TDB_DATA *outdata);
+int ctdb_control_setvnnmap(struct ctdb_context *ctdb, uint32_t opcode,
+			   TDB_DATA indata, TDB_DATA *outdata);
+
+int ctdb_control_getdbmap(struct ctdb_context *ctdb, uint32_t opcode,
+			  TDB_DATA indata, TDB_DATA *outdata);
+int ctdb_control_getnodemap(struct ctdb_context *ctdb, uint32_t opcode,
+			    TDB_DATA indata, TDB_DATA *outdata);
+
+int ctdb_control_reload_nodes_file(struct ctdb_context *ctdb, uint32_t opcode);
+
+int32_t ctdb_control_db_pull(struct ctdb_context *ctdb,
+			     struct ctdb_req_control_old *c,
+			     TDB_DATA indata, TDB_DATA *outdata);
+int32_t ctdb_control_db_push_start(struct ctdb_context *ctdb,
+				   TDB_DATA indata);
+int32_t ctdb_control_db_push_confirm(struct ctdb_context *ctdb,
+				     TDB_DATA indata, TDB_DATA *outdata);
+
+int ctdb_deferred_drop_all_ips(struct ctdb_context *ctdb);
+
+int32_t ctdb_control_set_recmode(struct ctdb_context *ctdb,
+				 struct ctdb_req_control_old *c,
+				 TDB_DATA indata, bool *async_reply,
+				 const char **errormsg);
+
+int32_t ctdb_control_end_recovery(struct ctdb_context *ctdb,
+				 struct ctdb_req_control_old *c,
+				 bool *async_reply);
+int32_t ctdb_control_start_recovery(struct ctdb_context *ctdb,
+				 struct ctdb_req_control_old *c,
+				 bool *async_reply);
+
+int32_t ctdb_control_try_delete_records(struct ctdb_context *ctdb,
+					TDB_DATA indata, TDB_DATA *outdata);
+
+int32_t ctdb_control_get_capabilities(struct ctdb_context *ctdb,
+				      TDB_DATA *outdata);
+
+int32_t ctdb_control_recd_ping(struct ctdb_context *ctdb);
+
+void ctdb_node_become_inactive(struct ctdb_context *ctdb);
+
+int32_t ctdb_control_stop_node(struct ctdb_context *ctdb);
+int32_t ctdb_control_continue_node(struct ctdb_context *ctdb);
+
+/* from ctdb_recoverd.c */
+
+int ctdb_start_recoverd(struct ctdb_context *ctdb);
+void ctdb_stop_recoverd(struct ctdb_context *ctdb);
+
+/* from ctdb_server.c */
+
+int ctdb_set_transport(struct ctdb_context *ctdb, const char *transport);
+
+struct ctdb_node *ctdb_ip_to_node(struct ctdb_context *ctdb,
+				  const ctdb_sock_addr *nodeip);
+uint32_t ctdb_ip_to_pnn(struct ctdb_context *ctdb,
+			const ctdb_sock_addr *nodeip);
+
+void ctdb_load_nodes_file(struct ctdb_context *ctdb);
+
+int ctdb_set_address(struct ctdb_context *ctdb, const char *address);
+
+uint32_t ctdb_get_num_active_nodes(struct ctdb_context *ctdb);
+
+void ctdb_input_pkt(struct ctdb_context *ctdb, struct ctdb_req_header *);
+
+void ctdb_node_dead(struct ctdb_node *node);
+void ctdb_node_connected(struct ctdb_node *node);
+
+void ctdb_queue_packet(struct ctdb_context *ctdb, struct ctdb_req_header *hdr);
+void ctdb_queue_packet_opcode(struct ctdb_context *ctdb,
+			      struct ctdb_req_header *hdr, unsigned opcode);
+
+/* from ctdb_serverids.c */
+
+int32_t ctdb_control_register_server_id(struct ctdb_context *ctdb,
+					uint32_t client_id, TDB_DATA indata);
+int32_t ctdb_control_check_server_id(struct ctdb_context *ctdb,
+				     TDB_DATA indata);
+int32_t ctdb_control_unregister_server_id(struct ctdb_context *ctdb,
+					  TDB_DATA indata);
+int32_t ctdb_control_get_server_id_list(struct ctdb_context *ctdb,
+					TDB_DATA *outdata);
+
+/* from ctdb_statistics.c */
+
+int ctdb_statistics_init(struct ctdb_context *ctdb);
+
+int32_t ctdb_control_get_stat_history(struct ctdb_context *ctdb,
+				      struct ctdb_req_control_old *c,
+				      TDB_DATA *outdata);
+
+/* from ctdb_takeover.c */
+
+int32_t ctdb_control_takeover_ip(struct ctdb_context *ctdb,
+				 struct ctdb_req_control_old *c,
+				 TDB_DATA indata,
+				 bool *async_reply);
+int32_t ctdb_control_release_ip(struct ctdb_context *ctdb,
+				 struct ctdb_req_control_old *c,
+				 TDB_DATA indata,
+				 bool *async_reply);
+int32_t ctdb_control_ipreallocated(struct ctdb_context *ctdb,
+				 struct ctdb_req_control_old *c,
+				 bool *async_reply);
+
+int ctdb_set_public_addresses(struct ctdb_context *ctdb, bool check_addresses);
+
+int32_t ctdb_control_tcp_client(struct ctdb_context *ctdb, uint32_t client_id,
+				TDB_DATA indata);
+int32_t ctdb_control_tcp_add(struct ctdb_context *ctdb, TDB_DATA indata,
+			     bool tcp_update_needed);
+int32_t ctdb_control_tcp_remove(struct ctdb_context *ctdb, TDB_DATA indata);
+int32_t ctdb_control_startup(struct ctdb_context *ctdb, uint32_t vnn);
+
+void ctdb_takeover_client_destructor_hook(struct ctdb_client *client);
+
+void ctdb_release_all_ips(struct ctdb_context *ctdb);
+
+int32_t ctdb_control_get_public_ips(struct ctdb_context *ctdb,
+				    struct ctdb_req_control_old *c,
+				    TDB_DATA *outdata);
+int32_t ctdb_control_get_public_ip_info(struct ctdb_context *ctdb,
+					struct ctdb_req_control_old *c,
+					TDB_DATA indata, TDB_DATA *outdata);
+
+int32_t ctdb_control_get_ifaces(struct ctdb_context *ctdb,
+				struct ctdb_req_control_old *c,
+				TDB_DATA *outdata);
+int32_t ctdb_control_set_iface_link(struct ctdb_context *ctdb,
+				    struct ctdb_req_control_old *c,
+				    TDB_DATA indata);
+
+int32_t ctdb_control_set_tcp_tickle_list(struct ctdb_context *ctdb,
+					 TDB_DATA indata);
+int32_t ctdb_control_get_tcp_tickle_list(struct ctdb_context *ctdb,
+					 TDB_DATA indata, TDB_DATA *outdata);
+
+void ctdb_start_tcp_tickle_update(struct ctdb_context *ctdb);
+
+int32_t ctdb_control_send_gratious_arp(struct ctdb_context *ctdb,
+				       TDB_DATA indata);
+
+int32_t ctdb_control_add_public_address(struct ctdb_context *ctdb,
+					TDB_DATA indata);
+int32_t ctdb_control_del_public_address(struct ctdb_context *ctdb,
+					TDB_DATA recdata);
+
+int32_t ctdb_control_reload_public_ips(struct ctdb_context *ctdb,
+				       struct ctdb_req_control_old *c,
+				       bool *async_reply);
+
+/* from ctdb_traverse.c */
+
+int32_t ctdb_control_traverse_all_ext(struct ctdb_context *ctdb,
+				      TDB_DATA data, TDB_DATA *outdata);
+int32_t ctdb_control_traverse_all(struct ctdb_context *ctdb,
+				  TDB_DATA data, TDB_DATA *outdata);
+int32_t ctdb_control_traverse_data(struct ctdb_context *ctdb,
+				   TDB_DATA data, TDB_DATA *outdata);
+int32_t ctdb_control_traverse_kill(struct ctdb_context *ctdb, TDB_DATA indata,
+				    TDB_DATA *outdata, uint32_t srcnode);
+
+int32_t ctdb_control_traverse_start_ext(struct ctdb_context *ctdb,
+					TDB_DATA indata, TDB_DATA *outdata,
+					uint32_t srcnode, uint32_t client_id);
+int32_t ctdb_control_traverse_start(struct ctdb_context *ctdb,
+				    TDB_DATA indata, TDB_DATA *outdata,
+				    uint32_t srcnode, uint32_t client_id);
+
+/* from ctdb_tunables.c */
+
+void ctdb_tunables_set_defaults(struct ctdb_context *ctdb);
+
+int32_t ctdb_control_get_tunable(struct ctdb_context *ctdb, TDB_DATA indata,
+				 TDB_DATA *outdata);
+int32_t ctdb_control_set_tunable(struct ctdb_context *ctdb, TDB_DATA indata);
+int32_t ctdb_control_list_tunables(struct ctdb_context *ctdb,
+				   TDB_DATA *outdata);
+bool ctdb_tunables_load(struct ctdb_context *ctdb);
+
+/* from ctdb_tunnel.c */
+
+int32_t ctdb_control_tunnel_register(struct ctdb_context *ctdb,
+				     uint32_t client_id, uint64_t tunnel_id);
+int32_t ctdb_control_tunnel_deregister(struct ctdb_context *ctdb,
+				       uint32_t client_id, uint64_t tunnel_id);
+
+int ctdb_daemon_send_tunnel(struct ctdb_context *ctdb, uint32_t destnode,
+			    uint64_t tunnel_id, uint32_t client_id,
+			    TDB_DATA data);
+
+void ctdb_request_tunnel(struct ctdb_context *ctdb,
+			 struct ctdb_req_header *hdr);
+
+/* from ctdb_update_record.c */
+
+int32_t ctdb_control_update_record(struct ctdb_context *ctdb,
+				   struct ctdb_req_control_old *c,
+				   TDB_DATA recdata, bool *async_reply);
+
+/* from ctdb_uptime.c */
+
+int32_t ctdb_control_uptime(struct ctdb_context *ctdb, TDB_DATA *outdata);
+
+/* from ctdb_vacuum.c */
+
+int32_t ctdb_control_db_vacuum(struct ctdb_context *ctdb,
+			       struct ctdb_req_control_old *c,
+			       TDB_DATA indata,
+			       bool *async_reply);
+
+void ctdb_stop_vacuuming(struct ctdb_context *ctdb);
+int ctdb_vacuum_init(struct ctdb_db_context *ctdb_db);
+
+int32_t ctdb_control_schedule_for_deletion(struct ctdb_context *ctdb,
+					   TDB_DATA indata);
+int32_t ctdb_local_schedule_for_deletion(struct ctdb_db_context *ctdb_db,
+					 const struct ctdb_ltdb_header *hdr,
+					 TDB_DATA key);
+
+void ctdb_local_remove_from_delete_queue(struct ctdb_db_context *ctdb_db,
+					 const struct ctdb_ltdb_header *hdr,
+					 const TDB_DATA key);
+
+int32_t ctdb_control_vacuum_fetch(struct ctdb_context *ctdb, TDB_DATA indata);
+
+/* from eventscript.c */
+
+int ctdb_start_eventd(struct ctdb_context *ctdb);
+void ctdb_stop_eventd(struct ctdb_context *ctdb);
+
+int ctdb_event_script_callback(struct ctdb_context *ctdb,
+			       TALLOC_CTX *mem_ctx,
+			       void (*callback)(struct ctdb_context *,
+						int, void *),
+			       void *private_data,
+			       enum ctdb_event call,
+			       const char *fmt, ...) PRINTF_ATTRIBUTE(6,7);
+
+int ctdb_event_script_args(struct ctdb_context *ctdb,
+			   enum ctdb_event call,
+			   const char *fmt, ...) PRINTF_ATTRIBUTE(3,4);
+
+int ctdb_event_script(struct ctdb_context *ctdb,
+		      enum ctdb_event call);
+
+void ctdb_event_reopen_logs(struct ctdb_context *ctdb);
+
+#endif
diff --git a/ctdb/include/ctdb_protocol.h b/ctdb/include/ctdb_protocol.h
new file mode 100644
index 0000000..7b6014f
--- /dev/null
+++ b/ctdb/include/ctdb_protocol.h
@@ -0,0 +1,301 @@
+/*
+   ctdb database library
+
+   Copyright (C) Andrew Tridgell  2006
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _CTDB_PROTOCOL_H
+#define _CTDB_PROTOCOL_H
+
+#include <sys/socket.h>
+#include "protocol/protocol.h"
+
+/* define ctdb port number */
+#define CTDB_PORT 4379
+
+/* we must align packets to ensure ctdb works on all architectures (eg. sparc) */
+#define CTDB_DS_ALIGNMENT 8
+
+/*
+  structure passed to a ctdb call backend function
+*/
+struct ctdb_call_info {
+	TDB_DATA key;          /* record key */
+	struct ctdb_ltdb_header *header;
+	TDB_DATA record_data;  /* current data in the record */
+	TDB_DATA *new_data;    /* optionally updated record data */
+	TDB_DATA *call_data;   /* optionally passed from caller */
+	TDB_DATA *reply_data;  /* optionally returned by function */
+	uint32_t status;       /* optional reply status - defaults to zero */
+};
+
+/*
+  ctdb flags
+*/
+#define CTDB_FLAG_TORTURE      (1<<1)
+
+struct ctdb_script_list_old {
+	uint32_t num_scripts;
+	struct ctdb_script scripts[1];
+};
+
+/* Mapping from enum to names. */
+extern const char *ctdb_eventscript_call_names[];
+
+/*
+  packet structures
+*/
+struct ctdb_req_call_old {
+	struct ctdb_req_header hdr;
+	uint32_t flags;
+	uint32_t db_id;
+	uint32_t callid;
+	uint32_t hopcount;
+	uint32_t keylen;
+	uint32_t calldatalen;
+	uint8_t data[1]; /* key[] followed by calldata[] */
+};
+
+struct ctdb_reply_call_old {
+	struct ctdb_req_header hdr;
+	uint32_t status;
+	uint32_t datalen;
+	uint8_t  data[1];
+};
+
+struct ctdb_reply_error_old {
+	struct ctdb_req_header hdr;
+	uint32_t status;
+	uint32_t msglen;
+	uint8_t  msg[1];
+};
+
+struct ctdb_req_dmaster_old {
+	struct ctdb_req_header hdr;
+	uint32_t db_id;
+	uint64_t rsn;
+	uint32_t dmaster;
+	uint32_t keylen;
+	uint32_t datalen;
+	uint8_t  data[1];
+};
+
+struct ctdb_reply_dmaster_old {
+	struct ctdb_req_header hdr;
+	uint32_t db_id;
+	uint64_t rsn;
+	uint32_t keylen;
+	uint32_t datalen;
+	uint8_t  data[1];
+};
+
+struct ctdb_req_message_old {
+	struct ctdb_req_header hdr;
+	uint64_t srvid;
+	uint32_t datalen;
+	uint8_t data[1];
+};
+
+struct ctdb_req_control_old {
+	struct ctdb_req_header hdr;
+	uint32_t opcode;
+	uint32_t pad;
+	uint64_t srvid;
+	uint32_t client_id;
+	uint32_t flags;
+	uint32_t datalen;
+	uint8_t data[1];
+};
+
+struct ctdb_reply_control_old {
+	struct ctdb_req_header hdr;
+	int32_t  status;
+	uint32_t datalen;
+	uint32_t errorlen;
+	uint8_t data[1];
+};
+
+struct ctdb_req_keepalive_old {
+	struct ctdb_req_header hdr;
+	uint32_t version;
+	uint32_t uptime;
+};
+
+struct ctdb_req_tunnel_old {
+	struct ctdb_req_header hdr;
+	uint64_t tunnel_id;
+	uint32_t flags;
+	uint32_t datalen;
+	uint8_t data[1];
+};
+
+/*
+   Structure used for a nodemap. 
+   The nodemap is the structure containing a list of all nodes
+   known to the cluster and their associated flags.
+*/
+struct ctdb_node_map_old {
+	uint32_t num;
+	struct ctdb_node_and_flags nodes[1];
+};
+
+struct ctdb_public_ip_list_old {
+	uint32_t num;
+	struct ctdb_public_ip ips[1];
+};
+
+/*
+  structure used to pass record data between the child and parent
+ */
+struct ctdb_rec_data_old {
+	uint32_t length;
+	uint32_t reqid;
+	uint32_t keylen;
+	uint32_t datalen;
+	uint8_t  data[1];
+};
+
+/*
+ * wire format for statistics history
+ */
+struct ctdb_statistics_list_old {
+	uint32_t num;
+	struct ctdb_statistics stats[1];
+};
+
+/*
+ * db statistics
+ */
+struct ctdb_db_statistics_old {
+	struct {
+		uint32_t num_calls;
+		uint32_t num_current;
+		uint32_t num_pending;
+		uint32_t num_failed;
+		struct ctdb_latency_counter latency;
+		uint32_t buckets[MAX_COUNT_BUCKETS];
+	} locks;
+	struct {
+		struct ctdb_latency_counter latency;
+	} vacuum;
+	uint32_t db_ro_delegations;
+	uint32_t db_ro_revokes;
+	uint32_t hop_count_bucket[MAX_COUNT_BUCKETS];
+	uint32_t num_hot_keys;
+	struct {
+		uint32_t count;
+		TDB_DATA key;
+	} hot_keys[MAX_HOT_KEYS];
+	char hot_keys_wire[1];
+};
+
+/* 
+   a wire representation of the vnn map
+ */
+struct ctdb_vnn_map_wire {
+	uint32_t generation;
+	uint32_t size;
+	uint32_t map[1];
+};
+
+struct ctdb_notify_data_old {
+	uint64_t srvid;
+	uint32_t len;
+	uint8_t notify_data[1];
+};
+
+/* table that contains a list of all dbids on a node
+ */
+struct ctdb_dbid_map_old {
+	uint32_t num;
+	struct ctdb_dbid dbs[1];
+};
+
+/* the list of tcp tickles used by get/set tcp tickle list */
+struct ctdb_tickle_list_old {
+	ctdb_sock_addr addr;
+	uint32_t num;
+	struct ctdb_connection connections[1];
+};
+
+/*
+  struct holding a ctdb_sock_addr and an interface name,
+  used to add/remove public addresses and grat arp
+ */
+struct ctdb_addr_info_old {
+	ctdb_sock_addr addr;
+	uint32_t mask;
+	uint32_t len;
+	char iface[1];
+};
+
+/* structure used for sending lists of records */
+struct ctdb_marshall_buffer {
+	uint32_t db_id;
+	uint32_t count;
+	uint8_t data[1];
+};
+
+/*
+  structure for setting a tunable
+ */
+struct ctdb_tunable_old {
+	uint32_t value;
+	uint32_t length;
+	uint8_t  name[1];
+};
+
+/*
+  structure for getting a tunable
+ */
+struct ctdb_control_get_tunable {
+	uint32_t length;
+	uint8_t  name[1];
+};
+
+/*
+  structure for listing tunables
+ */
+struct ctdb_control_list_tunable {
+	uint32_t length;
+	/* returns a : separated list of tunable names */
+	uint8_t  data[1];
+};
+
+
+struct ctdb_public_ip_info_old {
+	struct ctdb_public_ip ip;
+	uint32_t active_idx;
+	uint32_t num;
+	struct ctdb_iface ifaces[1];
+};
+
+struct ctdb_iface_list_old {
+	uint32_t num;
+	struct ctdb_iface ifaces[1];
+};
+
+/**
+ * structure to pass to a schedule_for_deletion_control
+ */
+struct ctdb_control_schedule_for_deletion {
+	uint32_t db_id;
+	struct ctdb_ltdb_header hdr;
+	uint32_t keylen;
+	uint8_t key[1]; /* key[] */
+};
+
+#endif
diff --git a/ctdb/include/public/README.txt b/ctdb/include/public/README.txt
new file mode 100644
index 0000000..534e9b7
--- /dev/null
+++ b/ctdb/include/public/README.txt
@@ -0,0 +1,6 @@
+DO NOT REMOVE
+
+This is a placeholder to allow for build rules putting public headers
+in this directory. Using this directory allows us to ensure that our
+public headers will work with external applications that make use of
+Samba libraries
diff --git a/ctdb/include/public/util/README.txt b/ctdb/include/public/util/README.txt
new file mode 100644
index 0000000..534e9b7
--- /dev/null
+++ b/ctdb/include/public/util/README.txt
@@ -0,0 +1,6 @@
+DO NOT REMOVE
+
+This is a placeholder to allow for build rules putting public headers
+in this directory. Using this directory allows us to ensure that our
+public headers will work with external applications that make use of
+Samba libraries