2006-11-18 02:41:20 +03:00
/*
ctdb database library
Copyright ( C ) Andrew Tridgell 2006
2007-05-31 07:50:53 +04:00
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 2 of the License , or
( at your option ) any later version .
This program is distributed in the hope that it will be useful ,
2006-11-18 02:41:20 +03:00
but WITHOUT ANY WARRANTY ; without even the implied warranty of
2007-05-31 07:50:53 +04:00
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 , write to the Free Software
Foundation , Inc . , 675 Mass Ave , Cambridge , MA 0213 9 , USA .
2006-11-18 02:41:20 +03:00
*/
2007-01-23 03:38:45 +03:00
# ifndef _CTDB_PRIVATE_H
# define _CTDB_PRIVATE_H
# include "ctdb.h"
2007-05-25 07:05:25 +04:00
# include <sys/socket.h>
# include <netinet/in.h>
2006-11-18 02:41:20 +03:00
2007-04-11 05:01:42 +04:00
/* location of daemon socket */
# define CTDB_PATH " / tmp / ctdb.socket"
2007-05-29 09:15:00 +04:00
/* default ctdb port number */
# define CTDB_PORT 9001
2007-04-11 05:01:42 +04:00
/* we must align packets to ensure ctdb works on all architectures (eg. sparc) */
# define CTDB_DS_ALIGNMENT 8
2007-05-02 09:11:11 +04:00
# define CTDB_NULL_FUNC 0xFF000001
# define CTDB_FETCH_FUNC 0xFF000002
2007-04-04 15:15:56 +04:00
2007-06-04 11:23:55 +04:00
/* all tunable variables go in here */
struct ctdb_tunable {
uint32_t max_redirect_count ;
uint32_t seqnum_frequency ;
uint32_t control_timeout ;
uint32_t traverse_timeout ;
uint32_t monitoring_timeout ;
uint32_t monitoring_limit ;
uint32_t max_lacount ;
} ;
2007-04-27 18:42:43 +04:00
2006-11-18 02:41:20 +03:00
/*
an installed ctdb remote call
*/
struct ctdb_registered_call {
struct ctdb_registered_call * next , * prev ;
uint32_t id ;
ctdb_fn_t fn ;
} ;
2006-11-27 13:38:13 +03:00
/*
this address structure might need to be generalised later for some
transports
*/
2006-11-18 03:21:40 +03:00
struct ctdb_address {
const char * address ;
int port ;
} ;
2007-04-18 12:39:02 +04:00
/*
check a vnn is valid
*/
# define ctdb_validate_vnn(ctdb, vnn) (((uint32_t)(vnn)) < (ctdb)->num_nodes)
2007-04-10 13:33:21 +04:00
/* called from the queue code when a packet comes in. Called with data==NULL
on error */
2007-04-11 22:12:15 +04:00
typedef void ( * ctdb_queue_cb_fn_t ) ( uint8_t * data , size_t length ,
void * private_data ) ;
2007-04-10 13:33:21 +04:00
2007-04-26 16:27:49 +04:00
/* used for callbacks in ctdb_control requests */
typedef void ( * ctdb_control_callback_fn_t ) ( struct ctdb_context * ,
2007-05-18 17:48:29 +04:00
int32_t status , TDB_DATA data ,
2007-05-12 15:25:26 +04:00
const char * errormsg ,
2007-04-26 16:27:49 +04:00
void * private_data ) ;
2007-04-10 13:33:21 +04:00
2007-05-27 09:26:29 +04:00
/*
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 ;
struct ctdb_tcp_list * tcp_list ;
} ;
2006-11-18 02:41:20 +03:00
/*
state associated with one node
*/
struct ctdb_node {
struct ctdb_context * ctdb ;
2006-11-18 03:21:40 +03:00
struct ctdb_address address ;
2006-11-28 06:15:46 +03:00
const char * name ; /* for debug messages */
2007-04-11 22:12:15 +04:00
void * private_data ; /* private to transport */
2006-11-28 09:56:10 +03:00
uint32_t vnn ;
2007-04-28 14:40:26 +04:00
# define NODE_FLAGS_CONNECTED 0x00000001
uint32_t flags ;
2007-05-18 13:19:35 +04:00
/* used by the dead node monitoring */
uint32_t dead_count ;
uint32_t rx_cnt ;
2007-05-19 04:20:19 +04:00
uint32_t tx_cnt ;
2007-05-18 17:48:29 +04:00
/* 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 ;
2007-05-25 11:04:13 +04:00
/* the public address of this node, if known */
const char * public_address ;
2007-05-29 06:16:59 +04:00
uint8_t public_netmask_bits ;
2007-05-25 11:04:13 +04:00
/* the node number that has taken over this nodes public address, if any.
If not taken over , then set to - 1 */
int32_t takeover_vnn ;
2006-11-18 02:41:20 +03:00
} ;
2006-11-18 05:45:04 +03:00
/*
2006-11-27 13:38:13 +03:00
transport specific methods
2006-11-18 05:45:04 +03:00
*/
2006-11-27 13:38:13 +03:00
struct ctdb_methods {
2007-05-30 07:26:50 +04:00
int ( * initialise ) ( struct ctdb_context * ) ; /* initialise transport structures */
2006-11-27 13:38:13 +03:00
int ( * start ) ( struct ctdb_context * ) ; /* start protocol processing */
int ( * add_node ) ( struct ctdb_node * ) ; /* setup a new node */
2006-11-28 03:51:33 +03:00
int ( * queue_pkt ) ( struct ctdb_node * , uint8_t * data , uint32_t length ) ;
2007-04-19 04:37:44 +04:00
void * ( * allocate_pkt ) ( TALLOC_CTX * mem_ctx , size_t ) ;
2007-06-02 02:41:19 +04:00
void ( * shutdown ) ( struct ctdb_context * ) ; /* shutdown transport */
2006-11-28 03:51:33 +03:00
} ;
/*
transport calls up to the ctdb layer
*/
struct ctdb_upcalls {
2006-11-28 09:56:10 +03:00
/* recv_pkt is called when a packet comes in */
2006-11-28 06:15:46 +03:00
void ( * recv_pkt ) ( struct ctdb_context * , uint8_t * data , uint32_t length ) ;
2006-11-28 09:56:10 +03:00
/* node_dead is called when an attempt to send to a node fails */
2006-11-28 06:15:46 +03:00
void ( * node_dead ) ( struct ctdb_node * ) ;
2006-11-28 09:56:10 +03:00
/* node_connected is called when a connection to a node is established */
void ( * node_connected ) ( struct ctdb_node * ) ;
2006-11-18 05:45:04 +03:00
} ;
2007-04-11 05:58:28 +04:00
/* list of message handlers - needs to be changed to a more efficient data
structure so we can find a message handler given a srvid quickly */
struct ctdb_message_list {
struct ctdb_context * ctdb ;
struct ctdb_message_list * next , * prev ;
2007-04-27 18:31:45 +04:00
uint64_t srvid ;
2007-04-11 05:58:28 +04:00
ctdb_message_fn_t message_handler ;
void * message_private ;
} ;
2007-04-10 00:03:39 +04:00
/* additional data required for the daemon mode */
struct ctdb_daemon_data {
int sd ;
char * name ;
2007-04-10 13:33:21 +04:00
struct ctdb_queue * queue ;
2007-04-10 00:03:39 +04:00
} ;
2007-04-03 13:41:00 +04:00
2007-04-20 14:07:47 +04:00
/*
ctdb status information
*/
2007-05-29 06:16:59 +04:00
struct ctdb_statistics {
2007-05-05 08:09:46 +04:00
uint32_t num_clients ;
2007-05-12 09:51:08 +04:00
uint32_t frozen ;
uint32_t recovering ;
2007-04-20 14:07:47 +04:00
uint32_t client_packets_sent ;
uint32_t client_packets_recv ;
uint32_t node_packets_sent ;
uint32_t node_packets_recv ;
2007-05-18 13:19:35 +04:00
uint32_t keepalive_packets_sent ;
uint32_t keepalive_packets_recv ;
2007-04-20 15:02:53 +04:00
struct {
uint32_t req_call ;
uint32_t reply_call ;
uint32_t req_dmaster ;
uint32_t reply_dmaster ;
uint32_t reply_error ;
uint32_t req_message ;
2007-04-26 16:27:49 +04:00
uint32_t req_control ;
uint32_t reply_control ;
2007-05-05 02:11:54 +04:00
} node ;
2007-04-20 15:02:53 +04:00
struct {
uint32_t req_call ;
uint32_t req_message ;
2007-04-26 16:27:49 +04:00
uint32_t req_control ;
2007-04-20 15:02:53 +04:00
} client ;
2007-05-05 02:11:54 +04:00
struct {
2007-05-29 06:16:59 +04:00
uint32_t statistics ;
2007-05-05 02:11:54 +04:00
uint32_t get_config ;
uint32_t ping ;
uint32_t attach ;
uint32_t set_call ;
uint32_t process_exists ;
uint32_t traverse_start ;
uint32_t traverse_all ;
uint32_t traverse_data ;
uint32_t update_seqnum ;
uint32_t enable_seqnum ;
uint32_t set_seqnum_frequency ;
uint32_t register_srvid ;
uint32_t deregister_srvid ;
} controls ;
2007-05-10 08:06:48 +04:00
struct {
uint32_t call ;
uint32_t control ;
uint32_t traverse ;
} timeouts ;
2007-04-20 14:07:47 +04:00
uint32_t total_calls ;
uint32_t pending_calls ;
uint32_t lockwait_calls ;
uint32_t pending_lockwait_calls ;
2007-05-05 02:33:35 +04:00
uint32_t memory_used ;
2007-05-29 06:16:59 +04:00
uint32_t __last_counter ; /* hack for control_statistics_all */
2007-05-01 07:25:02 +04:00
uint32_t max_hop_count ;
2007-04-20 14:07:47 +04:00
double max_call_latency ;
double max_lockwait_latency ;
} ;
2007-04-27 12:43:52 +04:00
/* table that contains the mapping between a hash value and lmaster
*/
struct ctdb_vnn_map {
2007-05-10 02:13:19 +04:00
uint32_t generation ;
uint32_t size ;
uint32_t * map ;
} ;
/*
a wire representation of the vnn map
*/
struct ctdb_vnn_map_wire {
2007-04-27 12:43:52 +04:00
uint32_t generation ;
uint32_t size ;
2007-05-03 05:06:24 +04:00
uint32_t map [ 1 ] ;
2007-04-27 12:43:52 +04:00
} ;
2007-05-03 10:18:03 +04:00
/* a structure that contains the elements required for the write record
control
*/
struct ctdb_write_record {
uint32_t dbid ;
uint32_t keylen ;
uint32_t datalen ;
unsigned char blob [ 1 ] ;
} ;
2007-05-12 08:34:21 +04:00
2007-05-12 09:15:27 +04:00
enum ctdb_freeze_mode { CTDB_FREEZE_NONE , CTDB_FREEZE_PENDING , CTDB_FREEZE_FROZEN } ;
2007-05-12 08:34:21 +04:00
2007-05-21 03:24:34 +04:00
# define CTDB_MONITORING_ACTIVE 0
# define CTDB_MONITORING_DISABLED 1
2007-05-25 11:04:13 +04:00
/* information about IP takeover */
struct ctdb_takeover {
bool enabled ;
const char * interface ;
2007-05-29 06:49:25 +04:00
const char * event_script ;
2007-05-25 15:27:26 +04:00
TALLOC_CTX * last_ctx ;
2007-05-25 11:04:13 +04:00
} ;
2006-11-18 02:41:20 +03:00
/* main state of the ctdb daemon */
struct ctdb_context {
struct event_context * ev ;
2007-04-29 16:51:56 +04:00
uint32_t recovery_mode ;
2007-05-21 03:24:34 +04:00
uint32_t monitoring_mode ;
2007-06-04 11:46:37 +04:00
struct ctdb_tunable tunable ;
2007-05-12 09:15:27 +04:00
enum ctdb_freeze_mode freeze_mode ;
struct ctdb_freeze_handle * freeze_handle ;
2006-11-18 03:21:40 +03:00
struct ctdb_address address ;
2006-11-28 09:56:10 +03:00
const char * name ;
2007-04-18 18:36:22 +04:00
const char * db_directory ;
2007-04-26 17:28:13 +04:00
const char * transport ;
2007-04-30 00:42:23 +04:00
const char * logfile ;
2007-05-23 08:35:19 +04:00
char * node_list_file ;
2007-06-02 05:36:42 +04:00
char * recovery_lock_file ;
int recovery_lock_fd ;
2006-11-28 09:56:10 +03:00
uint32_t vnn ; /* our own vnn */
uint32_t num_nodes ;
2006-12-01 01:01:11 +03:00
uint32_t num_connected ;
2006-12-01 07:45:24 +03:00
unsigned flags ;
2006-11-28 12:48:34 +03:00
struct idr_context * idr ;
2007-04-23 12:19:50 +04:00
uint16_t idr_cnt ;
2006-11-28 09:56:10 +03:00
struct ctdb_node * * nodes ; /* array of nodes in the cluster - indexed by vnn */
2006-11-18 02:41:20 +03:00
char * err_msg ;
2006-11-27 13:38:13 +03:00
const struct ctdb_methods * methods ; /* transport methods */
2006-11-28 03:51:33 +03:00
const struct ctdb_upcalls * upcalls ; /* transport upcalls */
2007-04-11 22:12:15 +04:00
void * private_data ; /* private to transport */
2007-04-03 13:41:00 +04:00
struct ctdb_db_context * db_list ;
2007-04-11 05:58:28 +04:00
struct ctdb_message_list * message_list ;
2007-04-10 00:03:39 +04:00
struct ctdb_daemon_data daemon ;
2007-05-29 06:16:59 +04:00
struct ctdb_statistics statistics ;
2007-04-27 12:43:52 +04:00
struct ctdb_vnn_map * vnn_map ;
2007-04-28 17:15:21 +04:00
uint32_t num_clients ;
2007-05-06 23:02:48 +04:00
uint32_t recovery_master ;
2007-05-18 18:56:49 +04:00
struct ctdb_call_state * pending_calls ;
2007-05-25 11:04:13 +04:00
struct ctdb_takeover takeover ;
2007-05-27 09:26:29 +04:00
struct ctdb_tcp_list * tcp_list ;
2007-04-03 13:41:00 +04:00
} ;
struct ctdb_db_context {
struct ctdb_db_context * next , * prev ;
struct ctdb_context * ctdb ;
uint32_t db_id ;
const char * db_name ;
2007-04-27 01:10:35 +04:00
const char * db_path ;
2007-04-03 13:41:00 +04:00
struct tdb_wrap * ltdb ;
struct ctdb_registered_call * calls ; /* list of registered calls */
2007-05-04 16:18:00 +04:00
uint32_t seqnum ;
2007-05-08 15:16:29 +04:00
struct timed_event * te ;
2006-11-18 02:41:20 +03:00
} ;
2007-04-09 05:51:27 +04:00
2006-11-27 13:38:13 +03:00
# define CTDB_NO_MEMORY(ctdb, p) do { if (!(p)) { \
2007-05-10 07:15:58 +04:00
DEBUG ( 0 , ( " Out of memory for %s at %s \n " , # p , __location__ ) ) ; \
2006-11-27 13:38:13 +03:00
ctdb_set_error ( ctdb , " Out of memory at %s:%d " , __FILE__ , __LINE__ ) ; \
return - 1 ; } } while ( 0 )
2007-04-26 16:27:49 +04:00
# define CTDB_NO_MEMORY_VOID(ctdb, p) do { if (!(p)) { \
2007-05-10 07:15:58 +04:00
DEBUG ( 0 , ( " Out of memory for %s at %s \n " , # p , __location__ ) ) ; \
2007-04-26 16:27:49 +04:00
ctdb_set_error ( ctdb , " Out of memory at %s:%d " , __FILE__ , __LINE__ ) ; \
} } while ( 0 )
2006-12-01 12:26:21 +03:00
# define CTDB_NO_MEMORY_NULL(ctdb, p) do { if (!(p)) { \
2007-05-10 07:15:58 +04:00
DEBUG ( 0 , ( " Out of memory for %s at %s \n " , # p , __location__ ) ) ; \
2006-12-01 12:26:21 +03:00
ctdb_set_error ( ctdb , " Out of memory at %s:%d " , __FILE__ , __LINE__ ) ; \
return NULL ; } } while ( 0 )
2006-12-18 08:26:57 +03:00
# define CTDB_NO_MEMORY_FATAL(ctdb, p) do { if (!(p)) { \
2007-05-10 07:15:58 +04:00
DEBUG ( 0 , ( " Out of memory for %s at %s \n " , # p , __location__ ) ) ; \
2006-12-18 08:26:57 +03:00
ctdb_fatal ( ctdb , " Out of memory in " __location__ ) ; \
} } while ( 0 )
2006-12-18 05:24:02 +03:00
/*
the extended header for records in the ltdb
*/
struct ctdb_ltdb_header {
uint64_t rsn ;
uint32_t dmaster ;
uint32_t laccessor ;
uint32_t lacount ;
} ;
2007-06-04 11:46:37 +04:00
enum ctdb_controls { CTDB_CONTROL_PROCESS_EXISTS = 0 ,
CTDB_CONTROL_STATISTICS = 1 ,
/* #2 removed */
CTDB_CONTROL_PING = 3 ,
CTDB_CONTROL_GETDBPATH = 4 ,
CTDB_CONTROL_GETVNNMAP = 5 ,
CTDB_CONTROL_SETVNNMAP = 6 ,
CTDB_CONTROL_GET_DEBUG = 7 ,
CTDB_CONTROL_SET_DEBUG = 8 ,
CTDB_CONTROL_GET_DBMAP = 9 ,
CTDB_CONTROL_GET_NODEMAP = 10 ,
CTDB_CONTROL_SET_DMASTER = 11 ,
CTDB_CONTROL_CLEAR_DB = 12 ,
CTDB_CONTROL_PULL_DB = 13 ,
CTDB_CONTROL_PUSH_DB = 14 ,
CTDB_CONTROL_GET_RECMODE = 15 ,
CTDB_CONTROL_SET_RECMODE = 16 ,
CTDB_CONTROL_STATISTICS_RESET = 17 ,
CTDB_CONTROL_DB_ATTACH = 18 ,
CTDB_CONTROL_SET_CALL = 19 ,
CTDB_CONTROL_TRAVERSE_START = 20 ,
CTDB_CONTROL_TRAVERSE_ALL = 21 ,
CTDB_CONTROL_TRAVERSE_DATA = 22 ,
CTDB_CONTROL_REGISTER_SRVID = 23 ,
CTDB_CONTROL_DEREGISTER_SRVID = 24 ,
CTDB_CONTROL_GET_DBNAME = 25 ,
CTDB_CONTROL_ENABLE_SEQNUM = 26 ,
CTDB_CONTROL_UPDATE_SEQNUM = 27 ,
/* #28 removed */
CTDB_CONTROL_DUMP_MEMORY = 29 ,
CTDB_CONTROL_GET_PID = 30 ,
CTDB_CONTROL_GET_RECMASTER = 31 ,
CTDB_CONTROL_SET_RECMASTER = 32 ,
CTDB_CONTROL_FREEZE = 33 ,
CTDB_CONTROL_THAW = 34 ,
CTDB_CONTROL_GET_VNN = 35 ,
CTDB_CONTROL_SHUTDOWN = 36 ,
CTDB_CONTROL_GET_MONMODE = 37 ,
CTDB_CONTROL_SET_MONMODE = 38 ,
CTDB_CONTROL_MAX_RSN = 39 ,
CTDB_CONTROL_SET_RSN_NONEMPTY = 40 ,
CTDB_CONTROL_DELETE_LOW_RSN = 41 ,
CTDB_CONTROL_TAKEOVER_IP = 42 ,
CTDB_CONTROL_RELEASE_IP = 43 ,
CTDB_CONTROL_TCP_CLIENT = 44 ,
CTDB_CONTROL_TCP_ADD = 45 ,
CTDB_CONTROL_TCP_REMOVE = 46 ,
CTDB_CONTROL_STARTUP = 47 ,
2007-05-25 07:05:25 +04:00
} ;
2007-05-23 11:21:14 +04:00
/*
structure passed in ctdb_control_set_rsn_nonempty
*/
struct ctdb_control_set_rsn_nonempty {
uint32_t db_id ;
uint64_t rsn ;
} ;
/*
structure passed in ctdb_control_delete_low_rsn
*/
struct ctdb_control_delete_low_rsn {
uint32_t db_id ;
uint64_t rsn ;
} ;
2007-04-30 17:31:40 +04:00
/*
structure passed in set_call control
*/
struct ctdb_control_set_call {
uint32_t db_id ;
ctdb_fn_t fn ;
uint32_t id ;
} ;
2007-05-27 09:26:29 +04:00
/*
2007-05-27 18:34:40 +04:00
struct for tcp_client control
2007-05-27 09:26:29 +04:00
*/
struct ctdb_control_tcp {
struct sockaddr_in src ;
struct sockaddr_in dest ;
} ;
2007-05-27 18:34:40 +04:00
/*
struct for tcp_add and tcp_remove controls
*/
struct ctdb_control_tcp_vnn {
uint32_t vnn ;
struct sockaddr_in src ;
struct sockaddr_in dest ;
} ;
2007-04-09 05:51:27 +04:00
enum call_state { CTDB_CALL_WAIT , CTDB_CALL_DONE , CTDB_CALL_ERROR } ;
2007-05-02 04:20:34 +04:00
# define CTDB_LMASTER_ANY 0xffffffff
2007-04-09 05:51:27 +04:00
/*
state of a in - progress ctdb call
*/
struct ctdb_call_state {
2007-05-18 18:56:49 +04:00
struct ctdb_call_state * next , * prev ;
2007-04-09 05:51:27 +04:00
enum call_state state ;
2007-04-23 12:19:50 +04:00
uint32_t reqid ;
2007-04-09 05:51:27 +04:00
struct ctdb_req_call * c ;
struct ctdb_db_context * ctdb_db ;
const char * errmsg ;
struct ctdb_call call ;
2007-05-10 08:06:48 +04:00
uint32_t generation ;
2007-04-12 09:46:50 +04:00
struct {
void ( * fn ) ( struct ctdb_call_state * ) ;
2007-04-13 14:38:24 +04:00
void * private_data ;
2007-04-12 09:46:50 +04:00
} async ;
2007-04-09 05:51:27 +04:00
} ;
2006-11-28 12:48:34 +03:00
2007-04-17 06:36:31 +04:00
/* used for fetch_lock */
2007-04-18 05:20:24 +04:00
struct ctdb_fetch_handle {
2007-04-17 06:36:31 +04:00
struct ctdb_db_context * ctdb_db ;
TDB_DATA key ;
TDB_DATA * data ;
2007-04-17 08:52:51 +04:00
struct ctdb_ltdb_header header ;
2007-04-17 06:36:31 +04:00
} ;
2006-11-28 09:56:10 +03:00
/*
operation IDs
*/
enum ctdb_operation {
2007-04-11 08:54:47 +04:00
CTDB_REQ_CALL = 0 ,
2007-06-04 11:46:37 +04:00
CTDB_REPLY_CALL = 1 ,
CTDB_REQ_DMASTER = 2 ,
CTDB_REPLY_DMASTER = 3 ,
CTDB_REPLY_ERROR = 4 ,
CTDB_REQ_MESSAGE = 5 ,
/* #6 removed */
CTDB_REQ_CONTROL = 7 ,
CTDB_REPLY_CONTROL = 8 ,
CTDB_REQ_KEEPALIVE = 9 ,
2006-11-28 09:56:10 +03:00
} ;
2007-04-06 08:41:05 +04:00
# define CTDB_MAGIC 0x43544442 /* CTDB */
# define CTDB_VERSION 1
2006-11-28 09:56:10 +03:00
/*
packet structures
*/
struct ctdb_req_header {
2006-12-01 07:45:24 +03:00
uint32_t length ;
2007-04-06 08:41:05 +04:00
uint32_t ctdb_magic ;
uint32_t ctdb_version ;
2007-04-27 19:06:26 +04:00
uint32_t generation ;
2006-11-28 09:56:10 +03:00
uint32_t operation ;
uint32_t destnode ;
uint32_t srcnode ;
uint32_t reqid ;
} ;
struct ctdb_req_call {
struct ctdb_req_header hdr ;
2007-04-04 15:15:56 +04:00
uint32_t flags ;
2007-04-03 13:41:00 +04:00
uint32_t db_id ;
2006-11-28 09:56:10 +03:00
uint32_t callid ;
2007-05-01 07:25:02 +04:00
uint32_t hopcount ;
2006-11-28 09:56:10 +03:00
uint32_t keylen ;
uint32_t calldatalen ;
2007-01-23 03:38:45 +03:00
uint8_t data [ 1 ] ; /* key[] followed by calldata[] */
2006-11-28 09:56:10 +03:00
} ;
struct ctdb_reply_call {
2006-12-01 07:45:24 +03:00
struct ctdb_req_header hdr ;
2007-01-29 14:30:06 +03:00
uint32_t status ;
2006-11-28 09:56:10 +03:00
uint32_t datalen ;
2007-01-23 03:38:45 +03:00
uint8_t data [ 1 ] ;
2006-11-28 09:56:10 +03:00
} ;
2006-11-27 13:38:13 +03:00
2006-12-18 06:27:20 +03:00
struct ctdb_reply_error {
struct ctdb_req_header hdr ;
uint32_t status ;
uint32_t msglen ;
2007-01-23 03:38:45 +03:00
uint8_t msg [ 1 ] ;
2006-12-18 06:27:20 +03:00
} ;
2006-12-18 08:01:11 +03:00
struct ctdb_req_dmaster {
struct ctdb_req_header hdr ;
2007-04-03 13:41:00 +04:00
uint32_t db_id ;
2007-04-29 18:19:40 +04:00
uint64_t rsn ;
2006-12-18 08:01:11 +03:00
uint32_t dmaster ;
uint32_t keylen ;
uint32_t datalen ;
2007-01-23 03:38:45 +03:00
uint8_t data [ 1 ] ;
2006-12-18 08:01:11 +03:00
} ;
struct ctdb_reply_dmaster {
struct ctdb_req_header hdr ;
2007-04-29 18:19:40 +04:00
uint32_t db_id ;
uint64_t rsn ;
uint32_t keylen ;
2006-12-18 08:01:11 +03:00
uint32_t datalen ;
2007-01-23 03:38:45 +03:00
uint8_t data [ 1 ] ;
2006-12-18 08:01:11 +03:00
} ;
2007-02-09 01:42:04 +03:00
struct ctdb_req_message {
struct ctdb_req_header hdr ;
2007-04-27 18:31:45 +04:00
uint64_t srvid ;
2007-02-09 01:42:04 +03:00
uint32_t datalen ;
uint8_t data [ 1 ] ;
} ;
2007-04-23 18:06:48 +04:00
struct ctdb_req_getdbpath {
struct ctdb_req_header hdr ;
uint32_t db_id ;
} ;
struct ctdb_reply_getdbpath {
struct ctdb_req_header hdr ;
uint32_t datalen ;
uint8_t data [ 1 ] ;
} ;
2007-04-26 16:27:49 +04:00
struct ctdb_req_control {
struct ctdb_req_header hdr ;
uint32_t opcode ;
2007-04-27 18:31:45 +04:00
uint64_t srvid ;
2007-05-04 05:41:29 +04:00
uint32_t client_id ;
2007-05-16 06:34:30 +04:00
# define CTDB_CTRL_FLAG_NOREPLY 1
2007-04-30 17:31:40 +04:00
uint32_t flags ;
2007-04-26 16:27:49 +04:00
uint32_t datalen ;
uint8_t data [ 1 ] ;
} ;
struct ctdb_reply_control {
struct ctdb_req_header hdr ;
int32_t status ;
uint32_t datalen ;
2007-05-12 15:25:26 +04:00
uint32_t errorlen ;
2007-04-26 16:27:49 +04:00
uint8_t data [ 1 ] ;
} ;
2007-05-18 13:19:35 +04:00
struct ctdb_req_keepalive {
struct ctdb_req_header hdr ;
} ;
2007-04-26 16:27:49 +04:00
2006-11-27 13:38:13 +03:00
/* internal prototypes */
2007-01-23 03:38:45 +03:00
void ctdb_set_error ( struct ctdb_context * ctdb , const char * fmt , . . . ) PRINTF_ATTRIBUTE ( 2 , 3 ) ;
2006-12-18 08:01:11 +03:00
void ctdb_fatal ( struct ctdb_context * ctdb , const char * msg ) ;
2006-11-27 13:38:13 +03:00
bool ctdb_same_address ( struct ctdb_address * a1 , struct ctdb_address * a2 ) ;
2006-11-28 09:56:10 +03:00
int ctdb_parse_address ( struct ctdb_context * ctdb ,
TALLOC_CTX * mem_ctx , const char * str ,
struct ctdb_address * address ) ;
2006-12-18 08:01:11 +03:00
uint32_t ctdb_hash ( const TDB_DATA * key ) ;
2007-04-30 17:31:40 +04:00
uint32_t ctdb_hash_string ( const char * str ) ;
2006-12-01 07:45:24 +03:00
void ctdb_request_call ( struct ctdb_context * ctdb , struct ctdb_req_header * hdr ) ;
2006-12-18 08:01:11 +03:00
void ctdb_request_dmaster ( struct ctdb_context * ctdb , struct ctdb_req_header * hdr ) ;
2007-02-09 01:42:04 +03:00
void ctdb_request_message ( struct ctdb_context * ctdb , struct ctdb_req_header * hdr ) ;
2006-12-18 08:01:11 +03:00
void ctdb_reply_dmaster ( struct ctdb_context * ctdb , struct ctdb_req_header * hdr ) ;
2006-12-01 07:45:24 +03:00
void ctdb_reply_call ( struct ctdb_context * ctdb , struct ctdb_req_header * hdr ) ;
2006-12-18 06:27:20 +03:00
void ctdb_reply_error ( struct ctdb_context * ctdb , struct ctdb_req_header * hdr ) ;
2006-11-18 02:41:20 +03:00
2006-12-18 08:01:11 +03:00
uint32_t ctdb_lmaster ( struct ctdb_context * ctdb , const TDB_DATA * key ) ;
2007-04-03 13:41:00 +04:00
int ctdb_ltdb_fetch ( struct ctdb_db_context * ctdb_db ,
2007-04-07 04:45:00 +04:00
TDB_DATA key , struct ctdb_ltdb_header * header ,
TALLOC_CTX * mem_ctx , TDB_DATA * data ) ;
2007-04-03 13:41:00 +04:00
int ctdb_ltdb_store ( struct ctdb_db_context * ctdb_db , TDB_DATA key ,
2006-12-18 05:24:02 +03:00
struct ctdb_ltdb_header * header , TDB_DATA data ) ;
2007-02-09 01:42:04 +03:00
void ctdb_queue_packet ( struct ctdb_context * ctdb , struct ctdb_req_header * hdr ) ;
2007-04-19 11:43:27 +04:00
int ctdb_ltdb_lock_requeue ( struct ctdb_db_context * ctdb_db ,
TDB_DATA key , struct ctdb_req_header * hdr ,
2007-05-19 07:45:24 +04:00
void ( * recv_pkt ) ( void * , struct ctdb_req_header * ) ,
2007-05-12 12:08:50 +04:00
void * recv_context , bool ignore_generation ) ;
2007-04-16 17:52:14 +04:00
int ctdb_ltdb_lock_fetch_requeue ( struct ctdb_db_context * ctdb_db ,
TDB_DATA key , struct ctdb_ltdb_header * header ,
2007-04-19 10:27:56 +04:00
struct ctdb_req_header * hdr , TDB_DATA * data ,
2007-05-19 07:45:24 +04:00
void ( * recv_pkt ) ( void * , struct ctdb_req_header * ) ,
2007-05-12 12:08:50 +04:00
void * recv_context , bool ignore_generation ) ;
2007-05-19 07:45:24 +04:00
void ctdb_input_pkt ( struct ctdb_context * ctdb , struct ctdb_req_header * ) ;
2006-12-18 05:24:02 +03:00
2007-04-09 05:51:27 +04:00
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 ) ;
2006-12-18 05:24:02 +03:00
2007-04-10 00:03:39 +04:00
int ctdbd_start ( struct ctdb_context * ctdb ) ;
struct ctdb_call_state * ctdbd_call_send ( struct ctdb_db_context * ctdb_db , struct ctdb_call * call ) ;
int ctdbd_call_recv ( struct ctdb_call_state * state , struct ctdb_call * call ) ;
2007-04-10 13:33:21 +04:00
/*
queue a packet for sending
*/
int ctdb_queue_send ( struct ctdb_queue * queue , uint8_t * data , uint32_t length ) ;
/*
setup the fd used by the queue
*/
int ctdb_queue_set_fd ( struct ctdb_queue * queue , int fd ) ;
/*
setup a packet queue on a socket
*/
struct ctdb_queue * ctdb_queue_setup ( struct ctdb_context * ctdb ,
TALLOC_CTX * mem_ctx , int fd , int alignment ,
ctdb_queue_cb_fn_t callback ,
2007-04-11 22:12:15 +04:00
void * private_data ) ;
2007-04-10 13:33:21 +04:00
2007-04-11 05:01:42 +04:00
/*
allocate a packet for use in client < - > daemon communication
*/
2007-04-28 12:50:32 +04:00
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 )
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 )
2007-04-11 05:01:42 +04:00
/*
lock a record in the ltdb , given a key
*/
int ctdb_ltdb_lock ( struct ctdb_db_context * ctdb_db , TDB_DATA key ) ;
/*
unlock a record in the ltdb , given a key
*/
int ctdb_ltdb_unlock ( struct ctdb_db_context * ctdb_db , TDB_DATA key ) ;
/*
make a ctdb call to the local daemon - async send . Called from client context .
2007-04-10 13:33:21 +04:00
2007-04-11 05:01:42 +04:00
This constructs a ctdb_call request and queues it for processing .
This call never blocks .
*/
struct ctdb_call_state * ctdb_client_call_send ( struct ctdb_db_context * ctdb_db ,
struct ctdb_call * call ) ;
/*
make a recv call to the local ctdb daemon - called from client context
This is called when the program wants to wait for a ctdb_call to complete and get the
results . This call will block unless the call has already completed .
*/
int ctdb_client_call_recv ( struct ctdb_call_state * state , struct ctdb_call * call ) ;
2007-04-10 00:03:39 +04:00
2007-04-27 18:31:45 +04:00
int ctdb_daemon_set_message_handler ( struct ctdb_context * ctdb , uint64_t srvid ,
2007-04-11 07:43:15 +04:00
ctdb_message_fn_t handler ,
2007-04-11 22:12:15 +04:00
void * private_data ) ;
2007-04-11 07:43:15 +04:00
int ctdb_client_send_message ( struct ctdb_context * ctdb , uint32_t vnn ,
2007-04-27 18:31:45 +04:00
uint64_t srvid , TDB_DATA data ) ;
2007-04-11 07:43:15 +04:00
2007-04-11 08:05:01 +04:00
/*
send a ctdb message
*/
int ctdb_daemon_send_message ( struct ctdb_context * ctdb , uint32_t vnn ,
2007-04-27 18:31:45 +04:00
uint64_t srvid , TDB_DATA data ) ;
2007-04-11 08:05:01 +04:00
2007-04-11 08:26:14 +04:00
2007-04-16 17:52:14 +04:00
struct lockwait_handle * ctdb_lockwait ( struct ctdb_db_context * ctdb_db ,
TDB_DATA key ,
void ( * callback ) ( void * ) , void * private_data ) ;
2007-04-17 08:52:51 +04:00
struct ctdb_call_state * ctdb_daemon_call_send ( struct ctdb_db_context * ctdb_db ,
struct ctdb_call * call ) ;
int ctdb_daemon_call_recv ( struct ctdb_call_state * state , struct ctdb_call * call ) ;
2007-04-17 10:20:32 +04:00
struct ctdb_call_state * ctdb_daemon_call_send_remote ( struct ctdb_db_context * ctdb_db ,
struct ctdb_call * call ,
struct ctdb_ltdb_header * header ) ;
2007-04-19 05:28:01 +04:00
int ctdb_call_local ( struct ctdb_db_context * ctdb_db , struct ctdb_call * call ,
2007-05-16 12:10:26 +04:00
struct ctdb_ltdb_header * header , TALLOC_CTX * mem_ctx , TDB_DATA * data ,
2007-04-19 05:28:01 +04:00
uint32_t caller ) ;
2007-04-23 12:19:50 +04:00
# define ctdb_reqid_find(ctdb, reqid, type) (type *)_ctdb_reqid_find(ctdb, reqid, #type, __location__)
2007-04-19 05:28:01 +04:00
2007-04-19 10:27:56 +04:00
void ctdb_recv_raw_pkt ( void * p , uint8_t * data , uint32_t length ) ;
2007-04-20 14:07:47 +04:00
int ctdb_socket_connect ( struct ctdb_context * ctdb ) ;
void ctdb_latency ( double * latency , struct timeval t ) ;
2007-04-23 12:19:50 +04:00
uint32_t ctdb_reqid_new ( struct ctdb_context * ctdb , void * state ) ;
void * _ctdb_reqid_find ( struct ctdb_context * ctdb , uint32_t reqid , const char * type , const char * location ) ;
void ctdb_reqid_remove ( struct ctdb_context * ctdb , uint32_t reqid ) ;
2007-04-26 16:27:49 +04:00
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 ,
2007-05-04 05:41:29 +04:00
uint64_t srvid , uint32_t opcode , uint32_t client_id , uint32_t flags ,
2007-04-30 17:31:40 +04:00
TDB_DATA data ,
2007-04-26 16:27:49 +04:00
ctdb_control_callback_fn_t callback ,
void * private_data ) ;
2007-04-30 17:31:40 +04:00
int32_t ctdb_control_db_attach ( struct ctdb_context * ctdb , TDB_DATA indata ,
TDB_DATA * outdata ) ;
int ctdb_daemon_set_call ( struct ctdb_context * ctdb , uint32_t db_id ,
ctdb_fn_t fn , int id ) ;
2007-05-02 06:43:35 +04:00
int ctdb_control ( struct ctdb_context * ctdb , uint32_t destnode , uint64_t srvid ,
uint32_t opcode , uint32_t flags , TDB_DATA data ,
2007-05-04 02:30:18 +04:00
TALLOC_CTX * mem_ctx , TDB_DATA * outdata , int32_t * status ,
2007-05-12 15:25:26 +04:00
struct timeval * timeout , char * * errormsg ) ;
2007-05-02 06:43:35 +04:00
2007-05-03 05:06:24 +04:00
# 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 " , \
2007-05-29 07:58:41 +04:00
opcode , ( unsigned ) indata . dsize , ( unsigned ) size ) ) ; \
2007-05-03 05:06:24 +04:00
return - 1 ; \
} \
} while ( 0 )
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 ) ;
2007-05-03 07:07:34 +04:00
int ctdb_control_getdbmap ( struct ctdb_context * ctdb , uint32_t opcode , TDB_DATA indata , TDB_DATA * outdata ) ;
2007-05-03 07:30:38 +04:00
int ctdb_control_getnodemap ( struct ctdb_context * ctdb , uint32_t opcode , TDB_DATA indata , TDB_DATA * outdata ) ;
2007-05-03 10:18:03 +04:00
int ctdb_control_writerecord ( struct ctdb_context * ctdb , uint32_t opcode , TDB_DATA indata , TDB_DATA * outdata ) ;
2007-05-03 05:06:24 +04:00
2007-05-03 11:12:23 +04:00
struct ctdb_traverse_start {
uint32_t db_id ;
uint32_t reqid ;
uint64_t srvid ;
} ;
/*
2007-05-10 11:43:45 +04:00
structure used to pass record data between the child and parent
2007-05-03 11:12:23 +04:00
*/
2007-05-10 11:43:45 +04:00
struct ctdb_rec_data {
2007-05-03 11:12:23 +04:00
uint32_t length ;
uint32_t reqid ;
uint32_t keylen ;
uint32_t datalen ;
uint8_t data [ 1 ] ;
} ;
2007-05-10 11:43:45 +04:00
/* structure used for pulldb control */
struct ctdb_control_pulldb {
uint32_t db_id ;
uint32_t lmaster ;
} ;
/* structure used for pulldb control */
struct ctdb_control_pulldb_reply {
uint32_t db_id ;
uint32_t count ;
uint8_t data [ 1 ] ;
} ;
/* set dmaster control structure */
struct ctdb_control_set_dmaster {
uint32_t db_id ;
uint32_t dmaster ;
} ;
2007-06-04 07:26:07 +04:00
/* table that contains a list of all nodes a ctdb knows about and their
status
*/
struct ctdb_node_and_flags {
uint32_t vnn ;
uint32_t flags ;
struct sockaddr_in sin ;
} ;
struct ctdb_node_map {
uint32_t num ;
struct ctdb_node_and_flags nodes [ 1 ] ;
} ;
2007-05-03 11:12:23 +04:00
int32_t ctdb_control_traverse_start ( struct ctdb_context * ctdb , TDB_DATA indata ,
TDB_DATA * outdata , uint32_t srcnode ) ;
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 ) ;
int ctdb_dispatch_message ( struct ctdb_context * ctdb , uint64_t srvid , TDB_DATA data ) ;
2007-05-04 05:41:29 +04:00
int daemon_register_message_handler ( struct ctdb_context * ctdb , uint32_t client_id , uint64_t srvid ) ;
int ctdb_deregister_message_handler ( struct ctdb_context * ctdb , uint64_t srvid , void * private_data ) ;
int daemon_deregister_message_handler ( struct ctdb_context * ctdb , uint32_t client_id , uint64_t srvid ) ;
2007-05-03 11:12:23 +04:00
2007-05-04 16:18:00 +04:00
int32_t ctdb_ltdb_enable_seqnum ( struct ctdb_context * ctdb , uint32_t db_id ) ;
int32_t ctdb_ltdb_update_seqnum ( struct ctdb_context * ctdb , uint32_t db_id , uint32_t srcnode ) ;
int32_t ctdb_ltdb_set_seqnum_frequency ( struct ctdb_context * ctdb , uint32_t frequency ) ;
2007-05-10 11:43:45 +04:00
struct ctdb_rec_data * ctdb_marshall_record ( TALLOC_CTX * mem_ctx , uint32_t reqid , TDB_DATA key , TDB_DATA data ) ;
int32_t ctdb_control_pull_db ( struct ctdb_context * ctdb , TDB_DATA indata , TDB_DATA * outdata ) ;
int32_t ctdb_control_push_db ( struct ctdb_context * ctdb , TDB_DATA indata ) ;
int32_t ctdb_control_set_dmaster ( struct ctdb_context * ctdb , TDB_DATA indata ) ;
int32_t ctdb_control_clear_db ( struct ctdb_context * ctdb , TDB_DATA indata ) ;
2007-06-02 02:41:19 +04:00
int32_t ctdb_control_set_recmode ( struct ctdb_context * ctdb ,
struct ctdb_req_control * c ,
TDB_DATA indata , bool * async_reply ,
const char * * errormsg ) ;
2007-05-12 08:34:21 +04:00
void ctdb_request_control_reply ( struct ctdb_context * ctdb , struct ctdb_req_control * c ,
2007-05-12 15:25:26 +04:00
TDB_DATA * outdata , int32_t status , const char * errormsg ) ;
2007-05-12 08:34:21 +04:00
2007-05-12 09:15:27 +04:00
int32_t ctdb_control_freeze ( struct ctdb_context * ctdb , struct ctdb_req_control * c , bool * async_reply ) ;
int32_t ctdb_control_thaw ( struct ctdb_context * ctdb ) ;
2007-05-15 09:13:36 +04:00
int ctdb_start_recoverd ( struct ctdb_context * ctdb ) ;
2007-05-17 17:23:41 +04:00
uint32_t ctdb_get_num_connected_nodes ( struct ctdb_context * ctdb ) ;
2007-05-18 13:19:35 +04:00
int ctdb_start_monitoring ( struct ctdb_context * ctdb ) ;
2007-05-18 17:23:36 +04:00
void ctdb_send_keepalive ( struct ctdb_context * ctdb , uint32_t destnode ) ;
2007-05-18 13:19:35 +04:00
2007-05-18 17:48:29 +04:00
void ctdb_daemon_cancel_controls ( struct ctdb_context * ctdb , struct ctdb_node * node ) ;
2007-05-18 18:56:49 +04:00
void ctdb_call_resend_all ( struct ctdb_context * ctdb ) ;
2007-05-19 10:59:10 +04:00
void ctdb_node_dead ( struct ctdb_node * node ) ;
2007-05-19 11:21:58 +04:00
void ctdb_node_connected ( struct ctdb_node * node ) ;
2007-05-23 06:23:07 +04:00
bool ctdb_blocking_freeze ( struct ctdb_context * ctdb ) ;
2007-05-23 11:21:14 +04:00
int32_t ctdb_control_max_rsn ( struct ctdb_context * ctdb , TDB_DATA indata , TDB_DATA * outdata ) ;
int32_t ctdb_control_set_rsn_nonempty ( struct ctdb_context * ctdb , TDB_DATA indata , TDB_DATA * outdata ) ;
int32_t ctdb_control_delete_low_rsn ( struct ctdb_context * ctdb , TDB_DATA indata , TDB_DATA * outdata ) ;
int ctdb_ctrl_get_max_rsn ( struct ctdb_context * ctdb , struct timeval timeout ,
uint32_t destnode , uint32_t db_id , uint64_t * max_rsn ) ;
int ctdb_ctrl_set_rsn_nonempty ( struct ctdb_context * ctdb , struct timeval timeout ,
uint32_t destnode , uint32_t db_id , uint64_t rsn ) ;
int ctdb_ctrl_delete_low_rsn ( struct ctdb_context * ctdb , struct timeval timeout ,
uint32_t destnode , uint32_t db_id , uint64_t rsn ) ;
2007-06-02 02:46:49 +04:00
void ctdb_set_realtime ( bool enable ) ;
2007-06-01 13:05:41 +04:00
int32_t ctdb_control_takeover_ip ( struct ctdb_context * ctdb ,
struct ctdb_req_control * c ,
TDB_DATA indata ,
bool * async_reply ) ;
2007-05-25 07:05:25 +04:00
int ctdb_ctrl_takeover_ip ( struct ctdb_context * ctdb , struct timeval timeout ,
2007-05-25 11:04:13 +04:00
uint32_t destnode , const char * ip ) ;
2007-06-01 13:05:41 +04:00
int32_t ctdb_control_release_ip ( struct ctdb_context * ctdb ,
struct ctdb_req_control * c ,
TDB_DATA indata ,
bool * async_reply ) ;
2007-05-25 07:05:25 +04:00
int ctdb_ctrl_release_ip ( struct ctdb_context * ctdb , struct timeval timeout ,
2007-05-25 11:04:13 +04:00
uint32_t destnode , const char * ip ) ;
/* from takeover/system.c */
int ctdb_sys_send_arp ( const struct sockaddr_in * saddr , const char * iface ) ;
2007-05-27 18:34:40 +04:00
bool ctdb_sys_have_ip ( const char * ip ) ;
2007-05-27 09:26:29 +04:00
int ctdb_sys_send_ack ( const struct sockaddr_in * dest ,
const struct sockaddr_in * src ) ;
2007-05-25 11:04:13 +04:00
int ctdb_set_public_addresses ( struct ctdb_context * ctdb , const char * alist ) ;
2007-05-29 06:49:25 +04:00
int ctdb_set_event_script ( struct ctdb_context * ctdb , const char * script ) ;
2007-05-25 11:04:13 +04:00
int ctdb_takeover_run ( struct ctdb_context * ctdb , struct ctdb_node_map * nodemap ) ;
2007-05-18 17:48:29 +04:00
2007-05-27 09:26:29 +04:00
int32_t ctdb_control_tcp_client ( struct ctdb_context * ctdb , uint32_t client_id ,
2007-05-27 18:34:40 +04:00
uint32_t srcnode , TDB_DATA indata ) ;
2007-05-27 09:26:29 +04:00
int32_t ctdb_control_tcp_add ( struct ctdb_context * ctdb , TDB_DATA indata ) ;
int32_t ctdb_control_tcp_remove ( struct ctdb_context * ctdb , TDB_DATA indata ) ;
2007-05-27 18:34:40 +04:00
int32_t ctdb_control_startup ( struct ctdb_context * ctdb , uint32_t vnn ) ;
2007-05-27 09:26:29 +04:00
void ctdb_takeover_client_destructor_hook ( struct ctdb_client * client ) ;
2007-05-29 07:48:30 +04:00
int ctdb_event_script ( struct ctdb_context * ctdb , const char * fmt , . . . ) PRINTF_ATTRIBUTE ( 2 , 3 ) ;
2007-05-30 07:26:50 +04:00
int ctdb_event_script_callback ( struct ctdb_context * ctdb ,
2007-06-01 13:05:41 +04:00
TALLOC_CTX * mem_ctx ,
void ( * callback ) ( struct ctdb_context * , int , void * ) ,
void * private_data ,
const char * fmt , . . . ) PRINTF_ATTRIBUTE ( 5 , 6 ) ;
2007-05-29 07:33:59 +04:00
void ctdb_release_all_ips ( struct ctdb_context * ctdb ) ;
2007-05-29 06:49:25 +04:00
2007-05-30 09:43:25 +04:00
void set_nonblocking ( int fd ) ;
void set_close_on_exec ( int fd ) ;
2007-05-29 07:48:30 +04:00
2007-06-02 05:36:42 +04:00
bool ctdb_recovery_lock ( struct ctdb_context * ctdb , bool keep ) ;
2007-06-02 04:03:28 +04:00
2007-06-02 05:36:42 +04:00
int ctdb_set_recovery_lock_file ( struct ctdb_context * ctdb , const char * file ) ;
2007-05-29 07:48:30 +04:00
2007-01-23 03:38:45 +03:00
# endif