deba46b215883decb8ef5aa9da0b027fe1e5c60c
[sahlberg/ctdb.git] / include / ctdb_private.h
1 /* 
2    ctdb database library
3
4    Copyright (C) Andrew Tridgell  2006
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 3 of the License, or
9    (at your option) any later version.
10    
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15    
16    You should have received a copy of the GNU General Public License
17    along with this program; if not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #ifndef _CTDB_PRIVATE_H
21 #define _CTDB_PRIVATE_H
22
23 #include "ctdb_client.h"
24 #include <sys/socket.h>
25
26 /*
27   recovery daemon memdump reply address
28  */
29 struct rd_memdump_reply {
30         uint32_t pnn;
31         uint64_t srvid;
32 };
33
34 /*
35   description for a TAKEOVER_RUN message reply address
36  */
37 struct takeover_run_reply {
38         uint32_t pnn;
39         uint64_t srvid;
40 };
41
42 /*
43  * pid of the ctdbd daemon
44  */
45 extern pid_t ctdbd_pid;
46
47 /*
48   a tcp connection description
49   also used by tcp_add and tcp_remove controls
50  */
51 struct ctdb_tcp_connection {
52         ctdb_sock_addr src_addr;
53         ctdb_sock_addr dst_addr;
54 };
55
56 /* the wire representation for a tcp tickle array */
57 struct ctdb_tcp_wire_array {
58         uint32_t num;
59         struct ctdb_tcp_connection connections[1];
60 };      
61
62 /* the list of tcp tickles used by get/set tcp tickle list */
63 struct ctdb_control_tcp_tickle_list {
64         ctdb_sock_addr addr;
65         struct ctdb_tcp_wire_array tickles;
66 };
67
68 /*
69   array of tcp connections
70  */
71 struct ctdb_tcp_array {
72         uint32_t num;
73         struct ctdb_tcp_connection *connections;
74 };      
75
76
77 /* all tunable variables go in here */
78 struct ctdb_tunable {
79         uint32_t max_redirect_count;
80         uint32_t seqnum_interval; /* unit is ms */
81         uint32_t control_timeout;
82         uint32_t traverse_timeout;
83         uint32_t keepalive_interval;
84         uint32_t keepalive_limit;
85         uint32_t recover_timeout;
86         uint32_t recover_interval;
87         uint32_t election_timeout;
88         uint32_t takeover_timeout;
89         uint32_t monitor_interval;
90         uint32_t tickle_update_interval;
91         uint32_t script_timeout;
92         uint32_t script_timeout_count; /* allow dodgy scripts to hang this many times in a row before we mark the node unhealthy */
93         uint32_t script_unhealthy_on_timeout; /* obsolete */
94         uint32_t recovery_grace_period;
95         uint32_t recovery_ban_period;
96         uint32_t database_hash_size;
97         uint32_t database_max_dead;
98         uint32_t rerecovery_timeout;
99         uint32_t enable_bans;
100         uint32_t deterministic_public_ips;
101         uint32_t reclock_ping_period;
102         uint32_t no_ip_failback;
103         uint32_t disable_ip_failover;
104         uint32_t verbose_memory_names;
105         uint32_t recd_ping_timeout;
106         uint32_t recd_ping_failcount;
107         uint32_t log_latency_ms;
108         uint32_t reclock_latency_ms;
109         uint32_t recovery_drop_all_ips;
110         uint32_t verify_recovery_lock;
111         uint32_t vacuum_default_interval;
112         uint32_t vacuum_max_run_time;
113         uint32_t repack_limit;
114         uint32_t vacuum_limit;
115         uint32_t vacuum_min_interval;
116         uint32_t vacuum_max_interval;
117         uint32_t max_queue_depth_drop_msg;
118         uint32_t use_status_events_for_monitoring;
119         uint32_t allow_unhealthy_db_read;
120         uint32_t stat_history_interval;
121 };
122
123 /*
124   an installed ctdb remote call
125 */
126 struct ctdb_registered_call {
127         struct ctdb_registered_call *next, *prev;
128         uint32_t id;
129         ctdb_fn_t fn;
130 };
131
132 /*
133   this address structure might need to be generalised later for some
134   transports
135 */
136 struct ctdb_address {
137         const char *address;
138         int port;
139 };
140
141 /*
142   check that a pnn is valid
143  */
144 #define ctdb_validate_pnn(ctdb, pnn) (((uint32_t)(pnn)) < (ctdb)->num_nodes)
145
146
147 /* called from the queue code when a packet comes in. Called with data==NULL
148    on error */
149 typedef void (*ctdb_queue_cb_fn_t)(uint8_t *data, size_t length,
150                                    void *private_data);
151
152 /* used for callbacks in ctdb_control requests */
153 typedef void (*ctdb_control_callback_fn_t)(struct ctdb_context *,
154                                            int32_t status, TDB_DATA data, 
155                                            const char *errormsg,
156                                            void *private_data);
157 /*
158   structure describing a connected client in the daemon
159  */
160 struct ctdb_client {
161         struct ctdb_context *ctdb;
162         int fd;
163         struct ctdb_queue *queue;
164         uint32_t client_id;
165         pid_t pid;
166         struct ctdb_tcp_list *tcp_list;
167         uint32_t db_id;
168         uint32_t num_persistent_updates;
169         struct ctdb_client_notify_list *notify;
170 };
171
172 struct ctdb_iface;
173
174 /* state associated with a public ip address */
175 struct ctdb_vnn {
176         struct ctdb_vnn *prev, *next;
177
178         struct ctdb_iface *iface;
179         const char **ifaces;
180         ctdb_sock_addr public_address;
181         uint8_t public_netmask_bits;
182
183         /* the node number that is serving this public address, if any. 
184            If no node serves this ip it is set to -1 */
185         int32_t pnn;
186
187         /* List of clients to tickle for this public address */
188         struct ctdb_tcp_array *tcp_array;
189
190         /* whether we need to update the other nodes with changes to our list
191            of connected clients */
192         bool tcp_update_needed;
193
194         /* a context to hang sending gratious arp events off */
195         TALLOC_CTX *takeover_ctx;
196
197         struct ctdb_kill_tcp *killtcp;
198 };
199
200 /*
201   state associated with one node
202 */
203 struct ctdb_node {
204         struct ctdb_context *ctdb;
205         struct ctdb_address address;
206         const char *name; /* for debug messages */
207         void *private_data; /* private to transport */
208         uint32_t pnn;
209         uint32_t flags;
210
211         /* used by the dead node monitoring */
212         uint32_t dead_count;
213         uint32_t rx_cnt;
214         uint32_t tx_cnt;
215
216         /* used to track node capabilities, is only valid/tracked inside the
217            recovery daemon.
218         */
219         uint32_t capabilities;
220
221         /* a list of controls pending to this node, so we can time them out quickly
222            if the node becomes disconnected */
223         struct daemon_control_state *pending_controls;
224
225         /* used by the recovery daemon when distributing ip addresses 
226            across the nodes.  it needs to know which public ip's can be handled
227            by each node.
228         */
229         struct ctdb_all_public_ips *known_public_ips;
230         struct ctdb_all_public_ips *available_public_ips;
231         /* used by the recovery dameon to track when a node should be banned */
232         struct ctdb_banning_state *ban_state; 
233 };
234
235 /*
236   transport specific methods
237 */
238 struct ctdb_methods {
239         int (*initialise)(struct ctdb_context *); /* initialise transport structures */ 
240         int (*start)(struct ctdb_context *); /* start the transport */
241         int (*add_node)(struct ctdb_node *); /* setup a new node */     
242         int (*connect_node)(struct ctdb_node *); /* connect to node */
243         int (*queue_pkt)(struct ctdb_node *, uint8_t *data, uint32_t length);
244         void *(*allocate_pkt)(TALLOC_CTX *mem_ctx, size_t );
245         void (*shutdown)(struct ctdb_context *); /* shutdown transport */
246         void (*restart)(struct ctdb_node *); /* stop and restart the connection */
247 };
248
249 /*
250   transport calls up to the ctdb layer
251 */
252 struct ctdb_upcalls {
253         /* recv_pkt is called when a packet comes in */
254         void (*recv_pkt)(struct ctdb_context *, uint8_t *data, uint32_t length);
255
256         /* node_dead is called when an attempt to send to a node fails */
257         void (*node_dead)(struct ctdb_node *);
258
259         /* node_connected is called when a connection to a node is established */
260         void (*node_connected)(struct ctdb_node *);
261 };
262
263 /* list of message handlers - needs to be changed to a more efficient data
264    structure so we can find a message handler given a srvid quickly */
265 struct ctdb_message_list {
266         struct ctdb_context *ctdb;
267         struct ctdb_message_list *next, *prev;
268         uint64_t srvid;
269         ctdb_msg_fn_t message_handler;
270         void *message_private;
271 };
272
273 /* additional data required for the daemon mode */
274 struct ctdb_daemon_data {
275         int sd;
276         char *name;
277         struct ctdb_queue *queue;
278 };
279
280
281 #define CTDB_UPDATE_STAT(ctdb, counter, value) \
282         {                                                                               \
283                 if (value > ctdb->statistics.counter) {                                 \
284                         ctdb->statistics.counter = c->hopcount;                         \
285                 }                                                                       \
286                 if (value > ctdb->statistics_current.counter) {                         \
287                         ctdb->statistics_current.counter = c->hopcount;                 \
288                 }                                                                       \
289         }
290
291 #define CTDB_INCREMENT_STAT(ctdb, counter) \
292         {                                                                               \
293                 ctdb->statistics.counter++;                                             \
294                 ctdb->statistics_current.counter++;                                     \
295         }
296
297 #define CTDB_DECREMENT_STAT(ctdb, counter) \
298         {                                                                               \
299                 if (ctdb->statistics.counter > 0)                                       \
300                         ctdb->statistics.counter--;                                     \
301                 if (ctdb->statistics_current.counter > 0)                               \
302                         ctdb->statistics_current.counter--;                             \
303         }
304
305 #define CTDB_UPDATE_RECLOCK_LATENCY(ctdb, name, counter, value) \
306         {                                                                               \
307                 if (value > ctdb->statistics.counter.max)                                       \
308                         ctdb->statistics.counter.max = value;                           \
309                 if (value > ctdb->statistics_current.counter.max)                               \
310                         ctdb->statistics_current.counter.max = value;                   \
311                                                                                         \
312                 if (ctdb->statistics.counter.num == 0 || value < ctdb->statistics.counter.min)  \
313                         ctdb->statistics.counter.min = value;                           \
314                 if (ctdb->statistics_current.counter.num == 0 || value < ctdb->statistics_current.counter.min)  \
315                         ctdb->statistics_current.counter.min = value;                   \
316                                                                                         \
317                 ctdb->statistics.counter.total += value;                                        \
318                 ctdb->statistics_current.counter.total += value;                                \
319                                                                                         \
320                 ctdb->statistics.counter.num++;                                         \
321                 ctdb->statistics_current.counter.num++;                                 \
322                                                                                         \
323                 if (ctdb->tunable.reclock_latency_ms != 0) {                            \
324                         if (value*1000 > ctdb->tunable.reclock_latency_ms) {            \
325                                 DEBUG(DEBUG_ERR, ("High RECLOCK latency %fs for operation %s\n", value, name)); \
326                         }                                                               \
327                 }                                                                       \
328         }
329
330
331 #define CTDB_UPDATE_LATENCY(ctdb, db, operation, counter, t) \
332         {                                                                               \
333                 double l = timeval_elapsed(&t);                                         \
334                                                                                         \
335                 if (l > ctdb->statistics.counter.max)                                   \
336                         ctdb->statistics.counter.max = l;                               \
337                 if (l > ctdb->statistics_current.counter.max)                           \
338                         ctdb->statistics_current.counter.max = l;                       \
339                                                                                         \
340                 if (ctdb->statistics.counter.num == 0 || l < ctdb->statistics.counter.min)      \
341                         ctdb->statistics.counter.min = l;                               \
342                 if (ctdb->statistics_current.counter.num == 0 || l < ctdb->statistics_current.counter.min)      \
343                         ctdb->statistics_current.counter.min = l;                       \
344                                                                                         \
345                 ctdb->statistics.counter.total += l;                                    \
346                 ctdb->statistics_current.counter.total += l;                            \
347                                                                                         \
348                 ctdb->statistics.counter.num++;                                         \
349                 ctdb->statistics_current.counter.num++;                                 \
350                                                                                         \
351                 if (ctdb->tunable.log_latency_ms !=0) {                                 \
352                         if (l*1000 > ctdb->tunable.log_latency_ms) {                    \
353                                 DEBUG(DEBUG_WARNING, ("High latency %.6fs for operation %s on database %s\n", l, operation, db->db_name));\
354                         }                                                               \
355                 }                                                                       \
356         }
357
358
359
360
361
362 #define INVALID_GENERATION 1
363 /* table that contains the mapping between a hash value and lmaster
364  */
365 struct ctdb_vnn_map {
366         uint32_t generation;
367         uint32_t size;
368         uint32_t *map;
369 };
370
371 /* 
372    a wire representation of the vnn map
373  */
374 struct ctdb_vnn_map_wire {
375         uint32_t generation;
376         uint32_t size;
377         uint32_t map[1];
378 };
379
380 /* a structure that contains the elements required for the write record
381    control
382 */
383 struct ctdb_write_record {
384         uint32_t dbid;
385         uint32_t keylen;
386         uint32_t datalen;
387         unsigned char blob[1];
388 };
389
390 enum ctdb_freeze_mode {CTDB_FREEZE_NONE, CTDB_FREEZE_PENDING, CTDB_FREEZE_FROZEN};
391
392 #define CTDB_MONITORING_ACTIVE          0
393 #define CTDB_MONITORING_DISABLED        1
394
395 /* The different capabilities of the ctdb daemon. */
396 #define CTDB_CAP_RECMASTER              0x00000001
397 #define CTDB_CAP_LMASTER                0x00000002
398 /* This capability is set if CTDB_LVS_PUBLIC_IP is set */
399 #define CTDB_CAP_LVS                    0x00000004
400 /* This capability is set if NATGW is enabled */
401 #define CTDB_CAP_NATGW                  0x00000008
402
403 #define NUM_DB_PRIORITIES 3
404 /* main state of the ctdb daemon */
405 struct ctdb_context {
406         struct tevent_context *ev;
407         struct timeval ctdbd_start_time;
408         struct timeval last_recovery_started;
409         struct timeval last_recovery_finished;
410         uint32_t recovery_mode;
411         TALLOC_CTX *tickle_update_context;
412         TALLOC_CTX *keepalive_ctx;
413         struct ctdb_tunable tunable;
414         enum ctdb_freeze_mode freeze_mode[NUM_DB_PRIORITIES+1];
415         struct ctdb_freeze_handle *freeze_handles[NUM_DB_PRIORITIES+1];
416         bool freeze_transaction_started;
417         uint32_t freeze_transaction_id;
418         struct ctdb_address address;
419         const char *name;
420         const char *db_directory;
421         const char *db_directory_persistent;
422         const char *db_directory_state;
423         struct tdb_wrap *db_persistent_health;
424         uint32_t db_persistent_startup_generation;
425         uint64_t db_persistent_check_errors;
426         uint64_t max_persistent_check_errors;
427         const char *transport;
428         char *recovery_lock_file;
429         int recovery_lock_fd;
430         uint32_t pnn; /* our own pnn */
431         uint32_t num_nodes;
432         uint32_t num_connected;
433         unsigned flags;
434         uint32_t capabilities;
435         struct idr_context *idr;
436         int lastid;
437         struct ctdb_node **nodes; /* array of nodes in the cluster - indexed by vnn */
438         struct ctdb_vnn *vnn; /* list of public ip addresses and interfaces */
439         struct ctdb_vnn *single_ip_vnn; /* a structure for the single ip */
440         struct ctdb_iface *ifaces; /* list of local interfaces */
441         char *err_msg;
442         const struct ctdb_methods *methods; /* transport methods */
443         const struct ctdb_upcalls *upcalls; /* transport upcalls */
444         void *private_data; /* private to transport */
445         struct ctdb_db_context *db_list;
446         struct ctdb_message_list *message_list;
447         struct ctdb_daemon_data daemon;
448         struct ctdb_statistics statistics;
449         struct ctdb_statistics statistics_current;
450 #define MAX_STAT_HISTORY 100
451         struct ctdb_statistics statistics_history[MAX_STAT_HISTORY];
452         struct ctdb_vnn_map *vnn_map;
453         uint32_t num_clients;
454         uint32_t recovery_master;
455         struct ctdb_call_state *pending_calls;
456         struct ctdb_client_ip *client_ip_list;
457         struct trbt_tree *server_ids; 
458         bool do_setsched;
459         void *saved_scheduler_param;
460         const char *event_script_dir;
461         const char *notification_script;
462         const char *default_public_interface;
463         pid_t ctdbd_pid;
464         pid_t recoverd_pid;
465         pid_t syslogd_pid;
466         bool done_startup;
467         const char *node_ip;
468         struct ctdb_monitor_state *monitor;
469         struct ctdb_log_state *log;
470         int start_as_disabled;
471         int start_as_stopped;
472         bool valgrinding;
473         uint32_t event_script_timeouts; /* counting how many consecutive times an eventscript has timedout */
474         uint32_t *recd_ping_count;
475         TALLOC_CTX *release_ips_ctx; /* a context used to automatically drop all IPs if we fail to recover the node */
476
477         TALLOC_CTX *event_script_ctx;
478
479         struct ctdb_event_script_state *current_monitor;
480         struct ctdb_scripts_wire *last_status[CTDB_EVENT_MAX];
481
482         TALLOC_CTX *banning_ctx;
483
484         struct ctdb_vacuum_child_context *vacuumers;
485
486         /* mapping from pid to ctdb_client * */
487         struct ctdb_client_pid_list *client_pids;
488
489         /* used in the recovery daemon to remember the ip allocation */
490         struct trbt_tree *ip_tree;
491 };
492
493 struct ctdb_db_context {
494         struct ctdb_db_context *next, *prev;
495         struct ctdb_context *ctdb;
496         uint32_t db_id;
497         uint32_t priority;
498         bool persistent;
499         const char *db_name;
500         const char *db_path;
501         struct tdb_wrap *ltdb;
502         struct ctdb_registered_call *calls; /* list of registered calls */
503         uint32_t seqnum;
504         struct timed_event *seqnum_update;
505         struct ctdb_traverse_local_handle *traverse;
506         bool transaction_active;
507         struct ctdb_vacuum_handle *vacuum_handle;
508         char *unhealthy_reason;
509 };
510
511
512 #define CTDB_NO_MEMORY(ctdb, p) do { if (!(p)) { \
513           DEBUG(0,("Out of memory for %s at %s\n", #p, __location__)); \
514           ctdb_set_error(ctdb, "Out of memory at %s:%d", __FILE__, __LINE__); \
515           return -1; }} while (0)
516
517 #define CTDB_NO_MEMORY_VOID(ctdb, p) do { if (!(p)) { \
518           DEBUG(0,("Out of memory for %s at %s\n", #p, __location__)); \
519           ctdb_set_error(ctdb, "Out of memory at %s:%d", __FILE__, __LINE__); \
520           return; }} while (0)
521
522 #define CTDB_NO_MEMORY_NULL(ctdb, p) do { if (!(p)) { \
523           DEBUG(0,("Out of memory for %s at %s\n", #p, __location__)); \
524           ctdb_set_error(ctdb, "Out of memory at %s:%d", __FILE__, __LINE__); \
525           return NULL; }} while (0)
526
527 #define CTDB_NO_MEMORY_FATAL(ctdb, p) do { if (!(p)) { \
528           DEBUG(0,("Out of memory for %s at %s\n", #p, __location__)); \
529           ctdb_fatal(ctdb, "Out of memory in " __location__ ); \
530           }} while (0)
531
532 /*
533   structure passed in set_call control
534  */
535 struct ctdb_control_set_call {
536         uint32_t db_id;
537         ctdb_fn_t fn;
538         uint32_t id;
539 };
540
541 /*
542   struct for kill_tcp control
543  */
544 struct ctdb_control_killtcp {
545         ctdb_sock_addr src_addr;
546         ctdb_sock_addr dst_addr;
547 };
548
549 /*
550   struct holding a ctdb_sock_addr and an interface name,
551   used to add/remove public addresses
552  */
553 struct ctdb_control_ip_iface {
554         ctdb_sock_addr addr;
555         uint32_t mask;
556         uint32_t len;
557         char iface[1];
558 };
559
560 /*
561   struct holding a ctdb_sock_addr and an interface name,
562   used for send_gratious_arp
563  */
564 struct ctdb_control_gratious_arp {
565         ctdb_sock_addr addr;
566         uint32_t mask;
567         uint32_t len;
568         char iface[1];
569 };
570
571 /*
572   persistent store control - update this record on all other nodes
573  */
574 struct ctdb_control_persistent_store {
575         uint32_t db_id;
576         uint32_t len;
577         uint8_t  data[1];
578 };
579
580 /*
581   structure used for CTDB_SRVID_NODE_FLAGS_CHANGED
582  */
583 struct ctdb_node_flag_change {
584         uint32_t pnn;
585         uint32_t new_flags;
586         uint32_t old_flags;
587 };
588
589 /*
590   struct for admin setting a ban
591  */
592 struct ctdb_ban_info {
593         uint32_t pnn;
594         uint32_t ban_time;
595 };
596
597 enum call_state {CTDB_CALL_WAIT, CTDB_CALL_DONE, CTDB_CALL_ERROR};
598
599 #define CTDB_LMASTER_ANY        0xffffffff
600
601 /*
602   state of a in-progress ctdb call
603 */
604 struct ctdb_call_state {
605         struct ctdb_call_state *next, *prev;
606         enum call_state state;
607         uint32_t reqid;
608         struct ctdb_req_call *c;
609         struct ctdb_db_context *ctdb_db;
610         const char *errmsg;
611         struct ctdb_call *call;
612         uint32_t generation;
613         struct {
614                 void (*fn)(struct ctdb_call_state *);
615                 void *private_data;
616         } async;
617 };
618
619
620 /* used for fetch_lock */
621 struct ctdb_fetch_handle {
622         struct ctdb_db_context *ctdb_db;
623         TDB_DATA key;
624         TDB_DATA *data;
625         struct ctdb_ltdb_header header;
626 };
627
628 /* internal prototypes */
629 void ctdb_set_error(struct ctdb_context *ctdb, const char *fmt, ...) PRINTF_ATTRIBUTE(2,3);
630 void ctdb_fatal(struct ctdb_context *ctdb, const char *msg);
631 bool ctdb_same_address(struct ctdb_address *a1, struct ctdb_address *a2);
632 int ctdb_parse_address(struct ctdb_context *ctdb,
633                        TALLOC_CTX *mem_ctx, const char *str,
634                        struct ctdb_address *address);
635 bool ctdb_same_ip(const ctdb_sock_addr *ip1, const ctdb_sock_addr *ip2);
636 bool ctdb_same_sockaddr(const ctdb_sock_addr *ip1, const ctdb_sock_addr *ip2);
637 uint32_t ctdb_hash(const TDB_DATA *key);
638 uint32_t ctdb_hash_string(const char *str);
639 void ctdb_request_call(struct ctdb_context *ctdb, struct ctdb_req_header *hdr);
640 void ctdb_request_dmaster(struct ctdb_context *ctdb, struct ctdb_req_header *hdr);
641 void ctdb_request_message(struct ctdb_context *ctdb, struct ctdb_req_header *hdr);
642 void ctdb_reply_dmaster(struct ctdb_context *ctdb, struct ctdb_req_header *hdr);
643 void ctdb_reply_call(struct ctdb_context *ctdb, struct ctdb_req_header *hdr);
644 void ctdb_reply_error(struct ctdb_context *ctdb, struct ctdb_req_header *hdr);
645
646 uint32_t ctdb_lmaster(struct ctdb_context *ctdb, const TDB_DATA *key);
647 int ctdb_ltdb_fetch(struct ctdb_db_context *ctdb_db, 
648                     TDB_DATA key, struct ctdb_ltdb_header *header, 
649                     TALLOC_CTX *mem_ctx, TDB_DATA *data);
650 int ctdb_ltdb_store(struct ctdb_db_context *ctdb_db, TDB_DATA key, 
651                     struct ctdb_ltdb_header *header, TDB_DATA data);
652 int ctdb_ltdb_delete(struct ctdb_db_context *ctdb_db, TDB_DATA key);
653 int32_t ctdb_control_start_persistent_update(struct ctdb_context *ctdb, 
654                         struct ctdb_req_control *c,
655                         TDB_DATA recdata);
656 int32_t ctdb_control_cancel_persistent_update(struct ctdb_context *ctdb, 
657                         struct ctdb_req_control *c,
658                         TDB_DATA recdata);
659 void ctdb_queue_packet(struct ctdb_context *ctdb, struct ctdb_req_header *hdr);
660 void ctdb_queue_packet_opcode(struct ctdb_context *ctdb, struct ctdb_req_header *hdr, unsigned opcode);
661 int ctdb_ltdb_lock_requeue(struct ctdb_db_context *ctdb_db, 
662                            TDB_DATA key, struct ctdb_req_header *hdr,
663                            void (*recv_pkt)(void *, struct ctdb_req_header *),
664                            void *recv_context, bool ignore_generation);
665 int ctdb_ltdb_lock_fetch_requeue(struct ctdb_db_context *ctdb_db, 
666                                  TDB_DATA key, struct ctdb_ltdb_header *header, 
667                                  struct ctdb_req_header *hdr, TDB_DATA *data,
668                                  void (*recv_pkt)(void *, struct ctdb_req_header *),
669                                  void *recv_context, bool ignore_generation);
670 void ctdb_input_pkt(struct ctdb_context *ctdb, struct ctdb_req_header *);
671
672 struct ctdb_call_state *ctdb_call_local_send(struct ctdb_db_context *ctdb_db, 
673                                              struct ctdb_call *call,
674                                              struct ctdb_ltdb_header *header,
675                                              TDB_DATA *data);
676
677
678 int ctdbd_start(struct ctdb_context *ctdb);
679 struct ctdb_call_state *ctdbd_call_send(struct ctdb_db_context *ctdb_db, struct ctdb_call *call);
680 int ctdbd_call_recv(struct ctdb_call_state *state, struct ctdb_call *call);
681
682 /*
683   queue a packet for sending
684 */
685 int ctdb_queue_send(struct ctdb_queue *queue, uint8_t *data, uint32_t length);
686
687 /*
688   setup the fd used by the queue
689  */
690 int ctdb_queue_set_fd(struct ctdb_queue *queue, int fd);
691
692 /*
693   setup a packet queue on a socket
694  */
695 struct ctdb_queue *ctdb_queue_setup(struct ctdb_context *ctdb,
696                                     TALLOC_CTX *mem_ctx, int fd, int alignment,
697                                     
698                                     ctdb_queue_cb_fn_t callback,
699                                     void *private_data, const char *fmt, ...)
700         PRINTF_ATTRIBUTE(7,8);
701
702 /*
703   allocate a packet for use in client<->daemon communication
704  */
705 struct ctdb_req_header *_ctdbd_allocate_pkt(struct ctdb_context *ctdb,
706                                             TALLOC_CTX *mem_ctx, 
707                                             enum ctdb_operation operation, 
708                                             size_t length, size_t slength,
709                                             const char *type);
710 #define ctdbd_allocate_pkt(ctdb, mem_ctx, operation, length, type) \
711         (type *)_ctdbd_allocate_pkt(ctdb, mem_ctx, operation, length, sizeof(type), #type)
712
713 struct ctdb_req_header *_ctdb_transport_allocate(struct ctdb_context *ctdb,
714                                                  TALLOC_CTX *mem_ctx, 
715                                                  enum ctdb_operation operation, 
716                                                  size_t length, size_t slength,
717                                                  const char *type);
718 #define ctdb_transport_allocate(ctdb, mem_ctx, operation, length, type) \
719         (type *)_ctdb_transport_allocate(ctdb, mem_ctx, operation, length, sizeof(type), #type)
720
721 int ctdb_queue_length(struct ctdb_queue *queue);
722
723 /*
724   lock a record in the ltdb, given a key
725  */
726 int ctdb_ltdb_lock(struct ctdb_db_context *ctdb_db, TDB_DATA key);
727
728 /*
729   unlock a record in the ltdb, given a key
730  */
731 int ctdb_ltdb_unlock(struct ctdb_db_context *ctdb_db, TDB_DATA key);
732
733
734 /*
735   make a ctdb call to the local daemon - async send. Called from client context.
736
737   This constructs a ctdb_call request and queues it for processing. 
738   This call never blocks.
739 */
740 struct ctdb_call_state *ctdb_client_call_send(struct ctdb_db_context *ctdb_db, 
741                                               struct ctdb_call *call);
742
743 /*
744   make a recv call to the local ctdb daemon - called from client context
745
746   This is called when the program wants to wait for a ctdb_call to complete and get the 
747   results. This call will block unless the call has already completed.
748 */
749 int ctdb_client_call_recv(struct ctdb_call_state *state, struct ctdb_call *call);
750
751 int ctdb_client_send_message(struct ctdb_context *ctdb, uint32_t vnn,
752                              uint64_t srvid, TDB_DATA data);
753
754 /*
755   send a ctdb message
756 */
757 int ctdb_daemon_send_message(struct ctdb_context *ctdb, uint32_t pnn,
758                              uint64_t srvid, TDB_DATA data);
759
760
761 struct lockwait_handle *ctdb_lockwait(struct ctdb_db_context *ctdb_db,
762                                       TDB_DATA key,
763                                       void (*callback)(void *), void *private_data);
764
765 struct ctdb_call_state *ctdb_daemon_call_send(struct ctdb_db_context *ctdb_db, 
766                                               struct ctdb_call *call);
767
768 int ctdb_daemon_call_recv(struct ctdb_call_state *state, struct ctdb_call *call);
769
770 struct ctdb_call_state *ctdb_daemon_call_send_remote(struct ctdb_db_context *ctdb_db, 
771                                                      struct ctdb_call *call, 
772                                                      struct ctdb_ltdb_header *header);
773
774 int ctdb_call_local(struct ctdb_db_context *ctdb_db, struct ctdb_call *call,
775                     struct ctdb_ltdb_header *header, TALLOC_CTX *mem_ctx,
776                     TDB_DATA *data);
777
778 #define ctdb_reqid_find(ctdb, reqid, type)      (type *)_ctdb_reqid_find(ctdb, reqid, #type, __location__)
779
780 void ctdb_recv_raw_pkt(void *p, uint8_t *data, uint32_t length);
781
782 int ctdb_socket_connect(struct ctdb_context *ctdb);
783
784 #define CTDB_BAD_REQID ((uint32_t)-1)
785 uint32_t ctdb_reqid_new(struct ctdb_context *ctdb, void *state);
786 void *_ctdb_reqid_find(struct ctdb_context *ctdb, uint32_t reqid, const char *type, const char *location);
787 void ctdb_reqid_remove(struct ctdb_context *ctdb, uint32_t reqid);
788
789 void ctdb_request_control(struct ctdb_context *ctdb, struct ctdb_req_header *hdr);
790 void ctdb_reply_control(struct ctdb_context *ctdb, struct ctdb_req_header *hdr);
791
792 int ctdb_daemon_send_control(struct ctdb_context *ctdb, uint32_t destnode,
793                              uint64_t srvid, uint32_t opcode, uint32_t client_id, uint32_t flags,
794                              TDB_DATA data,
795                              ctdb_control_callback_fn_t callback,
796                              void *private_data);
797
798 int32_t ctdb_control_db_attach(struct ctdb_context *ctdb, TDB_DATA indata, 
799                                TDB_DATA *outdata, uint64_t tdb_flags, bool persistent);
800
801 int ctdb_daemon_set_call(struct ctdb_context *ctdb, uint32_t db_id,
802                          ctdb_fn_t fn, int id);
803
804 int ctdb_control(struct ctdb_context *ctdb, uint32_t destnode, uint64_t srvid, 
805                  uint32_t opcode, uint32_t flags, TDB_DATA data, 
806                  TALLOC_CTX *mem_ctx, TDB_DATA *outdata, int32_t *status,
807                  struct timeval *timeout, char **errormsg);
808 int ctdb_control_recv(struct ctdb_context *ctdb, 
809                 struct ctdb_client_control_state *state, 
810                 TALLOC_CTX *mem_ctx,
811                 TDB_DATA *outdata, int32_t *status, char **errormsg);
812
813 struct ctdb_client_control_state *
814 ctdb_control_send(struct ctdb_context *ctdb, 
815                 uint32_t destnode, uint64_t srvid, 
816                 uint32_t opcode, uint32_t flags, TDB_DATA data, 
817                 TALLOC_CTX *mem_ctx,
818                 struct timeval *timeout,
819                 char **errormsg);
820
821
822
823
824 #define CHECK_CONTROL_DATA_SIZE(size) do { \
825  if (indata.dsize != size) { \
826          DEBUG(0,(__location__ " Invalid data size in opcode %u. Got %u expected %u\n", \
827                   opcode, (unsigned)indata.dsize, (unsigned)size));     \
828          return -1; \
829  } \
830  } while (0)
831
832 int ctdb_control_getvnnmap(struct ctdb_context *ctdb, uint32_t opcode, TDB_DATA indata, TDB_DATA *outdata);
833 int ctdb_control_setvnnmap(struct ctdb_context *ctdb, uint32_t opcode, TDB_DATA indata, TDB_DATA *outdata);
834 int ctdb_control_getdbmap(struct ctdb_context *ctdb, uint32_t opcode, TDB_DATA indata, TDB_DATA *outdata);
835 int ctdb_control_getnodemapv4(struct ctdb_context *ctdb, uint32_t opcode, TDB_DATA indata, TDB_DATA *outdata);
836 int ctdb_control_getnodemap(struct ctdb_context *ctdb, uint32_t opcode, TDB_DATA indata, TDB_DATA *outdata);
837 int ctdb_control_writerecord(struct ctdb_context *ctdb, uint32_t opcode, TDB_DATA indata, TDB_DATA *outdata);
838
839
840 struct ctdb_traverse_start {
841         uint32_t db_id;
842         uint32_t reqid;
843         uint64_t srvid;
844 };
845
846 /*
847   structure used to pass record data between the child and parent
848  */
849 struct ctdb_rec_data {
850         uint32_t length;
851         uint32_t reqid;
852         uint32_t keylen;
853         uint32_t datalen;
854         uint8_t  data[1];
855 };
856                                    
857
858 /* structure used for pulldb control */
859 struct ctdb_control_pulldb {
860         uint32_t db_id;
861         uint32_t lmaster;
862 };
863
864 /* structure used for sending lists of records */
865 struct ctdb_marshall_buffer {
866         uint32_t db_id;
867         uint32_t count;
868         uint8_t data[1];
869 };
870
871 /* set dmaster control structure */
872 struct ctdb_control_set_dmaster {
873         uint32_t db_id;
874         uint32_t dmaster;
875 };
876
877 /*
878   structure for setting a tunable
879  */
880 struct ctdb_control_set_tunable {
881         uint32_t value;
882         uint32_t length;
883         uint8_t  name[1];
884 };
885
886 /*
887   structure for getting a tunable
888  */
889 struct ctdb_control_get_tunable {
890         uint32_t length;
891         uint8_t  name[1];
892 };
893
894 /*
895   structure for listing tunables
896  */
897 struct ctdb_control_list_tunable {
898         uint32_t length;
899         /* returns a : separated list of tunable names */
900         uint8_t  data[1];
901 };
902
903
904 struct ctdb_node_and_flagsv4 {
905         uint32_t pnn;
906         uint32_t flags;
907         struct sockaddr_in sin;
908 };
909
910 struct ctdb_node_mapv4 {
911         uint32_t num;
912         struct ctdb_node_and_flagsv4 nodes[1];
913 };
914
915 struct ctdb_control_wipe_database {
916         uint32_t db_id;
917         uint32_t transaction_id;
918 };
919
920 /*
921   state of a in-progress ctdb call in client
922 */
923 struct ctdb_client_call_state {
924         enum call_state state;
925         uint32_t reqid;
926         struct ctdb_db_context *ctdb_db;
927         struct ctdb_call *call;
928         struct {
929                 void (*fn)(struct ctdb_client_call_state *);
930                 void *private_data;
931         } async;
932 };
933
934
935 int32_t ctdb_control_traverse_start(struct ctdb_context *ctdb, TDB_DATA indata, 
936                                     TDB_DATA *outdata, uint32_t srcnode, uint32_t client_id);
937 int32_t ctdb_control_traverse_all(struct ctdb_context *ctdb, TDB_DATA data, TDB_DATA *outdata);
938 int32_t ctdb_control_traverse_data(struct ctdb_context *ctdb, TDB_DATA data, TDB_DATA *outdata);
939 int32_t ctdb_control_traverse_kill(struct ctdb_context *ctdb, TDB_DATA indata, 
940                                     TDB_DATA *outdata, uint32_t srcnode);
941
942 int ctdb_dispatch_message(struct ctdb_context *ctdb, uint64_t srvid, TDB_DATA data);
943
944 int daemon_register_message_handler(struct ctdb_context *ctdb, uint32_t client_id, uint64_t srvid);
945 int ctdb_deregister_message_handler(struct ctdb_context *ctdb, uint64_t srvid, void *private_data);
946 int daemon_deregister_message_handler(struct ctdb_context *ctdb, uint32_t client_id, uint64_t srvid);
947
948 int32_t ctdb_ltdb_enable_seqnum(struct ctdb_context *ctdb, uint32_t db_id);
949 int32_t ctdb_ltdb_update_seqnum(struct ctdb_context *ctdb, uint32_t db_id, uint32_t srcnode);
950
951 struct ctdb_rec_data *ctdb_marshall_record(TALLOC_CTX *mem_ctx, uint32_t reqid, 
952                                            TDB_DATA key, struct ctdb_ltdb_header *, TDB_DATA data);
953
954 struct ctdb_rec_data *ctdb_marshall_loop_next(struct ctdb_marshall_buffer *m, struct ctdb_rec_data *r,
955                                               uint32_t *reqid,
956                                               struct ctdb_ltdb_header *header,
957                                               TDB_DATA *key, TDB_DATA *data);
958
959 int32_t ctdb_control_pull_db(struct ctdb_context *ctdb, TDB_DATA indata, TDB_DATA *outdata);
960 int32_t ctdb_control_push_db(struct ctdb_context *ctdb, TDB_DATA indata);
961 int32_t ctdb_control_set_dmaster(struct ctdb_context *ctdb, TDB_DATA indata);
962
963 int32_t ctdb_control_set_recmode(struct ctdb_context *ctdb, 
964                                  struct ctdb_req_control *c,
965                                  TDB_DATA indata, bool *async_reply,
966                                  const char **errormsg);
967 void ctdb_request_control_reply(struct ctdb_context *ctdb, struct ctdb_req_control *c,
968                                 TDB_DATA *outdata, int32_t status, const char *errormsg);
969
970 int32_t ctdb_control_freeze(struct ctdb_context *ctdb, struct ctdb_req_control *c, bool *async_reply);
971 int32_t ctdb_control_thaw(struct ctdb_context *ctdb, uint32_t priority);
972
973 int ctdb_start_recoverd(struct ctdb_context *ctdb);
974 void ctdb_stop_recoverd(struct ctdb_context *ctdb);
975
976 uint32_t ctdb_get_num_active_nodes(struct ctdb_context *ctdb);
977
978 void ctdb_disable_monitoring(struct ctdb_context *ctdb);
979 void ctdb_enable_monitoring(struct ctdb_context *ctdb);
980 void ctdb_stop_monitoring(struct ctdb_context *ctdb);
981 void ctdb_start_monitoring(struct ctdb_context *ctdb);
982 void ctdb_start_tcp_tickle_update(struct ctdb_context *ctdb);
983 void ctdb_send_keepalive(struct ctdb_context *ctdb, uint32_t destnode);
984 void ctdb_start_keepalive(struct ctdb_context *ctdb);
985 void ctdb_stop_keepalive(struct ctdb_context *ctdb);
986 int32_t ctdb_run_eventscripts(struct ctdb_context *ctdb, struct ctdb_req_control *c, TDB_DATA data, bool *async_reply);
987
988
989 void ctdb_daemon_cancel_controls(struct ctdb_context *ctdb, struct ctdb_node *node);
990 void ctdb_call_resend_all(struct ctdb_context *ctdb);
991 void ctdb_node_dead(struct ctdb_node *node);
992 void ctdb_node_connected(struct ctdb_node *node);
993 bool ctdb_blocking_freeze(struct ctdb_context *ctdb);
994 void ctdb_set_scheduler(struct ctdb_context *ctdb);
995 void ctdb_restore_scheduler(struct ctdb_context *ctdb);
996 int32_t ctdb_control_takeover_ip(struct ctdb_context *ctdb, 
997                                  struct ctdb_req_control *c,
998                                  TDB_DATA indata, 
999                                  bool *async_reply);
1000 int32_t ctdb_control_takeover_ipv4(struct ctdb_context *ctdb, 
1001                                  struct ctdb_req_control *c,
1002                                  TDB_DATA indata, 
1003                                  bool *async_reply);
1004 int32_t ctdb_control_release_ip(struct ctdb_context *ctdb, 
1005                                  struct ctdb_req_control *c,
1006                                  TDB_DATA indata, 
1007                                  bool *async_reply);
1008 int32_t ctdb_control_release_ipv4(struct ctdb_context *ctdb, 
1009                                  struct ctdb_req_control *c,
1010                                  TDB_DATA indata, 
1011                                  bool *async_reply);
1012 int32_t ctdb_control_start_recovery(struct ctdb_context *ctdb, 
1013                                  struct ctdb_req_control *c,
1014                                  bool *async_reply);
1015 int32_t ctdb_control_end_recovery(struct ctdb_context *ctdb, 
1016                                  struct ctdb_req_control *c,
1017                                  bool *async_reply);
1018
1019 struct ctdb_public_ipv4 {
1020         uint32_t pnn;
1021         struct sockaddr_in sin;
1022 };
1023
1024 int ctdb_ctrl_takeover_ip(struct ctdb_context *ctdb, struct timeval timeout, 
1025                           uint32_t destnode, struct ctdb_public_ip *ip);
1026 int ctdb_ctrl_release_ip(struct ctdb_context *ctdb, struct timeval timeout, 
1027                          uint32_t destnode, struct ctdb_public_ip *ip);
1028
1029 struct ctdb_all_public_ipsv4 {
1030         uint32_t num;
1031         struct ctdb_public_ipv4 ips[1];
1032 };
1033
1034 int32_t ctdb_control_get_public_ipsv4(struct ctdb_context *ctdb, struct ctdb_req_control *c, TDB_DATA *outdata);
1035 int32_t ctdb_control_get_public_ips(struct ctdb_context *ctdb, struct ctdb_req_control *c, TDB_DATA *outdata);
1036 int ctdb_ctrl_get_public_ips(struct ctdb_context *ctdb, 
1037                              struct timeval timeout,
1038                              uint32_t destnode,
1039                              TALLOC_CTX *mem_ctx,
1040                              struct ctdb_all_public_ips **ips);
1041 #define CTDB_PUBLIC_IP_FLAGS_ONLY_AVAILABLE 0x00010000
1042 int ctdb_ctrl_get_public_ips_flags(struct ctdb_context *ctdb,
1043                                    struct timeval timeout, uint32_t destnode,
1044                                    TALLOC_CTX *mem_ctx,
1045                                    uint32_t flags,
1046                                    struct ctdb_all_public_ips **ips);
1047 int ctdb_ctrl_get_public_ipsv4(struct ctdb_context *ctdb, 
1048                         struct timeval timeout, uint32_t destnode, 
1049                         TALLOC_CTX *mem_ctx, struct ctdb_all_public_ips **ips);
1050
1051 #ifdef IFNAMSIZ
1052 #define CTDB_IFACE_SIZE IFNAMSIZ
1053 #else
1054 #define CTDB_IFACE_SIZE 16
1055 #endif
1056
1057 struct ctdb_control_iface_info {
1058         char name[CTDB_IFACE_SIZE+2];
1059         uint16_t link_state;
1060         uint32_t references;
1061 };
1062
1063 struct ctdb_control_public_ip_info {
1064         struct ctdb_public_ip ip;
1065         uint32_t active_idx;
1066         uint32_t num;
1067         struct ctdb_control_iface_info ifaces[1];
1068 };
1069
1070 struct ctdb_control_get_ifaces {
1071         uint32_t num;
1072         struct ctdb_control_iface_info ifaces[1];
1073 };
1074
1075 int32_t ctdb_control_get_public_ip_info(struct ctdb_context *ctdb,
1076                                         struct ctdb_req_control *c,
1077                                         TDB_DATA indata,
1078                                         TDB_DATA *outdata);
1079 int32_t ctdb_control_get_ifaces(struct ctdb_context *ctdb,
1080                                 struct ctdb_req_control *c,
1081                                 TDB_DATA *outdata);
1082 int32_t ctdb_control_set_iface_link(struct ctdb_context *ctdb,
1083                                     struct ctdb_req_control *c,
1084                                     TDB_DATA indata);
1085 int ctdb_ctrl_get_public_ip_info(struct ctdb_context *ctdb,
1086                                  struct timeval timeout, uint32_t destnode,
1087                                  TALLOC_CTX *mem_ctx,
1088                                  const ctdb_sock_addr *addr,
1089                                  struct ctdb_control_public_ip_info **info);
1090 int ctdb_ctrl_get_ifaces(struct ctdb_context *ctdb,
1091                          struct timeval timeout, uint32_t destnode,
1092                          TALLOC_CTX *mem_ctx,
1093                          struct ctdb_control_get_ifaces **ifaces);
1094 int ctdb_ctrl_set_iface_link(struct ctdb_context *ctdb,
1095                              struct timeval timeout, uint32_t destnode,
1096                              TALLOC_CTX *mem_ctx,
1097                              const struct ctdb_control_iface_info *info);
1098
1099 /* from takeover/system.c */
1100 uint32_t uint16_checksum(uint16_t *data, size_t n);
1101 int ctdb_sys_send_arp(const ctdb_sock_addr *addr, const char *iface);
1102 bool ctdb_sys_have_ip(ctdb_sock_addr *addr);
1103 int ctdb_sys_send_tcp(const ctdb_sock_addr *dest, 
1104                       const ctdb_sock_addr *src,
1105                       uint32_t seq, uint32_t ack, int rst);
1106
1107 int ctdb_set_public_addresses(struct ctdb_context *ctdb, const char *alist);
1108 int ctdb_set_single_public_ip(struct ctdb_context *ctdb,
1109                               const char *iface,
1110                               const char *ip);
1111 int ctdb_set_event_script(struct ctdb_context *ctdb, const char *script);
1112 int ctdb_set_event_script_dir(struct ctdb_context *ctdb, const char *script_dir);
1113 int ctdb_set_notification_script(struct ctdb_context *ctdb, const char *script);
1114 int ctdb_takeover_run(struct ctdb_context *ctdb, struct ctdb_node_map *nodemap);
1115
1116 int32_t ctdb_control_tcp_client(struct ctdb_context *ctdb, uint32_t client_id, 
1117                                 TDB_DATA indata);
1118 int32_t ctdb_control_tcp_add(struct ctdb_context *ctdb, TDB_DATA indata, bool tcp_update_needed);
1119 int32_t ctdb_control_tcp_remove(struct ctdb_context *ctdb, TDB_DATA indata);
1120 int32_t ctdb_control_startup(struct ctdb_context *ctdb, uint32_t vnn);
1121 int32_t ctdb_control_kill_tcp(struct ctdb_context *ctdb, TDB_DATA indata);
1122 int32_t ctdb_control_send_gratious_arp(struct ctdb_context *ctdb, TDB_DATA indata);
1123 int32_t ctdb_control_get_tcp_tickle_list(struct ctdb_context *ctdb, TDB_DATA indata, TDB_DATA *outdata);
1124 int32_t ctdb_control_set_tcp_tickle_list(struct ctdb_context *ctdb, TDB_DATA indata);
1125
1126 void ctdb_takeover_client_destructor_hook(struct ctdb_client *client);
1127 int ctdb_event_script(struct ctdb_context *ctdb, enum ctdb_eventscript_call call);
1128 int ctdb_event_script_args(struct ctdb_context *ctdb, enum ctdb_eventscript_call call,
1129                            const char *fmt, ...) PRINTF_ATTRIBUTE(3,4);
1130 int ctdb_event_script_callback(struct ctdb_context *ctdb, 
1131                                TALLOC_CTX *mem_ctx,
1132                                void (*callback)(struct ctdb_context *, int, void *),
1133                                void *private_data,
1134                                bool from_user,
1135                                enum ctdb_eventscript_call call,
1136                                const char *fmt, ...) PRINTF_ATTRIBUTE(7,8);
1137 void ctdb_release_all_ips(struct ctdb_context *ctdb);
1138
1139 void set_nonblocking(int fd);
1140 void set_close_on_exec(int fd);
1141
1142 bool ctdb_recovery_lock(struct ctdb_context *ctdb, bool keep);
1143
1144 int ctdb_set_recovery_lock_file(struct ctdb_context *ctdb, const char *file);
1145
1146 int32_t ctdb_control_get_tunable(struct ctdb_context *ctdb, TDB_DATA indata, 
1147                                  TDB_DATA *outdata);
1148 int32_t ctdb_control_set_tunable(struct ctdb_context *ctdb, TDB_DATA indata);
1149 int32_t ctdb_control_list_tunables(struct ctdb_context *ctdb, TDB_DATA *outdata);
1150 int32_t ctdb_control_try_delete_records(struct ctdb_context *ctdb, TDB_DATA indata, TDB_DATA *outdata);
1151 int32_t ctdb_control_add_public_address(struct ctdb_context *ctdb, TDB_DATA indata);
1152 int32_t ctdb_control_del_public_address(struct ctdb_context *ctdb, TDB_DATA indata);
1153
1154 void ctdb_tunables_set_defaults(struct ctdb_context *ctdb);
1155
1156 int32_t ctdb_control_modflags(struct ctdb_context *ctdb, TDB_DATA indata);
1157
1158 int ctdb_ctrl_get_all_tunables(struct ctdb_context *ctdb, 
1159                                struct timeval timeout, 
1160                                uint32_t destnode,
1161                                struct ctdb_tunable *tunables);
1162
1163 int ctdb_start_freeze(struct ctdb_context *ctdb, uint32_t priority);
1164
1165 bool parse_ip_mask(const char *s, const char *iface, ctdb_sock_addr *addr, unsigned *mask);
1166 bool parse_ip_port(const char *s, ctdb_sock_addr *addr);
1167 bool parse_ip(const char *s, const char *iface, unsigned port, ctdb_sock_addr *addr);
1168 bool parse_ipv4(const char *s, unsigned port, struct sockaddr_in *sin);
1169  
1170
1171 int ctdb_sys_open_capture_socket(const char *iface, void **private_data);
1172 int ctdb_sys_close_capture_socket(void *private_data);
1173 int ctdb_sys_read_tcp_packet(int s, void *private_data, ctdb_sock_addr *src, ctdb_sock_addr *dst, uint32_t *ack_seq, uint32_t *seq);
1174
1175 int ctdb_ctrl_killtcp(struct ctdb_context *ctdb, 
1176                       struct timeval timeout, 
1177                       uint32_t destnode,
1178                       struct ctdb_control_killtcp *killtcp);
1179
1180 int ctdb_ctrl_add_public_ip(struct ctdb_context *ctdb, 
1181                       struct timeval timeout, 
1182                       uint32_t destnode,
1183                       struct ctdb_control_ip_iface *pub);
1184
1185 int ctdb_ctrl_del_public_ip(struct ctdb_context *ctdb, 
1186                       struct timeval timeout, 
1187                       uint32_t destnode,
1188                       struct ctdb_control_ip_iface *pub);
1189
1190 int ctdb_ctrl_gratious_arp(struct ctdb_context *ctdb, 
1191                       struct timeval timeout, 
1192                       uint32_t destnode,
1193                       ctdb_sock_addr *addr,
1194                       const char *ifname);
1195
1196 int ctdb_ctrl_get_tcp_tickles(struct ctdb_context *ctdb, 
1197                       struct timeval timeout, 
1198                       uint32_t destnode,
1199                       TALLOC_CTX *mem_ctx,
1200                       ctdb_sock_addr *addr,
1201                       struct ctdb_control_tcp_tickle_list **list);
1202
1203
1204 int32_t ctdb_control_register_server_id(struct ctdb_context *ctdb, 
1205                       uint32_t client_id,
1206                       TDB_DATA indata);
1207 int32_t ctdb_control_check_server_id(struct ctdb_context *ctdb, 
1208                       TDB_DATA indata);
1209 int32_t ctdb_control_unregister_server_id(struct ctdb_context *ctdb, 
1210                       TDB_DATA indata);
1211 int32_t ctdb_control_get_server_id_list(struct ctdb_context *ctdb, 
1212                       TDB_DATA *outdata);
1213 int32_t ctdb_control_uptime(struct ctdb_context *ctdb, 
1214                       TDB_DATA *outdata);
1215
1216 int ctdb_attach_databases(struct ctdb_context *ctdb);
1217
1218 int32_t ctdb_control_persistent_store(struct ctdb_context *ctdb, 
1219                                       struct ctdb_req_control *c, 
1220                                       TDB_DATA recdata, bool *async_reply);
1221 int32_t ctdb_control_update_record(struct ctdb_context *ctdb, 
1222                                    struct ctdb_req_control *c, TDB_DATA recdata, 
1223                                    bool *async_reply);
1224 int32_t ctdb_control_trans2_commit(struct ctdb_context *ctdb, 
1225                                    struct ctdb_req_control *c, 
1226                                    TDB_DATA recdata, bool *async_reply);
1227
1228 int32_t ctdb_control_trans3_commit(struct ctdb_context *ctdb,
1229                                    struct ctdb_req_control *c,
1230                                    TDB_DATA recdata, bool *async_reply);
1231
1232 int32_t ctdb_control_transaction_start(struct ctdb_context *ctdb, uint32_t id);
1233 int32_t ctdb_control_transaction_commit(struct ctdb_context *ctdb, uint32_t id);
1234 int32_t ctdb_control_transaction_cancel(struct ctdb_context *ctdb);
1235 int32_t ctdb_control_wipe_database(struct ctdb_context *ctdb, TDB_DATA indata);
1236 int32_t ctdb_control_db_set_healthy(struct ctdb_context *ctdb, TDB_DATA indata);
1237 int32_t ctdb_control_db_get_health(struct ctdb_context *ctdb,
1238                                    TDB_DATA indata,
1239                                    TDB_DATA *outdata);
1240
1241
1242 int ctdb_vacuum(struct ctdb_context *ctdb, int argc, const char **argv);
1243 int ctdb_repack(struct ctdb_context *ctdb, int argc, const char **argv);
1244
1245 void ctdb_block_signal(int signum);
1246 void ctdb_unblock_signal(int signum);
1247 int32_t ctdb_monitoring_mode(struct ctdb_context *ctdb);
1248 int ctdb_set_child_logging(struct ctdb_context *ctdb);
1249 void ctdb_lockdown_memory(struct ctdb_context *ctdb);
1250
1251 typedef void (*client_async_callback)(struct ctdb_context *ctdb, uint32_t node_pnn, int32_t res, TDB_DATA outdata, void *callback_data);
1252
1253 struct client_async_data {
1254         enum ctdb_controls opcode;
1255         bool dont_log_errors;
1256         uint32_t count;
1257         uint32_t fail_count;
1258         client_async_callback callback;
1259         client_async_callback fail_callback;
1260         void *callback_data;
1261 };
1262 void ctdb_client_async_add(struct client_async_data *data, struct ctdb_client_control_state *state);
1263 int ctdb_client_async_wait(struct ctdb_context *ctdb, struct client_async_data *data);
1264 int ctdb_client_async_control(struct ctdb_context *ctdb,
1265                                 enum ctdb_controls opcode,
1266                                 uint32_t *nodes,
1267                                 uint64_t srvid,
1268                                 struct timeval timeout,
1269                                 bool dont_log_errors,
1270                                 TDB_DATA data,
1271                                 client_async_callback client_callback,
1272                                 client_async_callback fail_callback,
1273                                 void *callback_data);
1274
1275 void ctdb_load_nodes_file(struct ctdb_context *ctdb);
1276
1277 int ctdb_control_reload_nodes_file(struct ctdb_context *ctdb, uint32_t opcode);
1278
1279 int32_t ctdb_dump_memory(struct ctdb_context *ctdb, TDB_DATA *outdata);
1280 int32_t ctdb_control_get_capabilities(struct ctdb_context *ctdb, TDB_DATA *outdata);
1281
1282 int32_t ctdb_control_trans2_finished(struct ctdb_context *ctdb, 
1283                                      struct ctdb_req_control *c);
1284 int32_t ctdb_control_trans2_error(struct ctdb_context *ctdb, 
1285                                   struct ctdb_req_control *c);
1286 int32_t ctdb_control_trans2_active(struct ctdb_context *ctdb,
1287                                    struct ctdb_req_control *c,
1288                                    uint32_t db_id);
1289
1290 char *ctdb_addr_to_str(ctdb_sock_addr *addr);
1291 unsigned ctdb_addr_to_port(ctdb_sock_addr *addr);
1292 void ctdb_canonicalize_ip(const ctdb_sock_addr *ip, ctdb_sock_addr *cip);
1293
1294 int32_t ctdb_control_recd_ping(struct ctdb_context *ctdb);
1295 int32_t ctdb_control_set_recmaster(struct ctdb_context *ctdb, uint32_t opcode, TDB_DATA indata);
1296
1297 extern int script_log_level;
1298 extern bool fast_start;
1299
1300 int32_t ctdb_control_get_event_script_status(struct ctdb_context *ctdb,
1301                                              uint32_t call_type,
1302                                              TDB_DATA *outdata);
1303
1304 int ctdb_log_event_script_output(struct ctdb_context *ctdb, char *str, uint16_t len);
1305 int ctdb_ctrl_report_recd_lock_latency(struct ctdb_context *ctdb, struct timeval timeout, double latency);
1306
1307 int32_t ctdb_control_stop_node(struct ctdb_context *ctdb, struct ctdb_req_control *c, bool *async_reply);
1308 int32_t ctdb_control_continue_node(struct ctdb_context *ctdb);
1309
1310 void ctdb_stop_vacuuming(struct ctdb_context *ctdb);
1311 int ctdb_vacuum_init(struct ctdb_db_context *ctdb_db);
1312
1313 int32_t ctdb_control_enable_script(struct ctdb_context *ctdb, TDB_DATA indata);
1314 int32_t ctdb_control_disable_script(struct ctdb_context *ctdb, TDB_DATA indata);
1315
1316 int32_t ctdb_control_set_ban_state(struct ctdb_context *ctdb, TDB_DATA indata);
1317 int32_t ctdb_control_get_ban_state(struct ctdb_context *ctdb, TDB_DATA *outdata);
1318 int32_t ctdb_control_set_db_priority(struct ctdb_context *ctdb, TDB_DATA indata);
1319 void ctdb_ban_self(struct ctdb_context *ctdb);
1320
1321 int32_t ctdb_control_register_notify(struct ctdb_context *ctdb, uint32_t client_id, TDB_DATA indata);
1322
1323 int32_t ctdb_control_deregister_notify(struct ctdb_context *ctdb, uint32_t client_id, TDB_DATA indata);
1324
1325 int start_syslog_daemon(struct ctdb_context *ctdb);
1326
1327 /* Where to send the log messages back to */
1328 struct ctdb_get_log_addr {
1329         uint32_t pnn;
1330         uint64_t srvid;
1331         int32_t level;
1332 };
1333
1334 extern int log_ringbuf_size;
1335
1336 int32_t ctdb_control_get_log(struct ctdb_context *ctdb, TDB_DATA addr);
1337 int32_t ctdb_control_clear_log(struct ctdb_context *ctdb);
1338
1339
1340 struct ctdb_log_state *ctdb_fork_with_logging(TALLOC_CTX *mem_ctx,
1341                                               struct ctdb_context *ctdb,
1342                                               void (*logfn)(const char *, uint16_t, void *),
1343                                               void *logfn_private, pid_t *pid);
1344
1345 int32_t ctdb_control_process_exists(struct ctdb_context *ctdb, pid_t pid);
1346 struct ctdb_client *ctdb_find_client_by_pid(struct ctdb_context *ctdb, pid_t pid);
1347
1348 int32_t ctdb_control_get_db_seqnum(struct ctdb_context *ctdb,
1349                                    TDB_DATA indata,
1350                                    TDB_DATA *outdata);
1351
1352 int ctdb_load_persistent_health(struct ctdb_context *ctdb,
1353                                 struct ctdb_db_context *ctdb_db);
1354 int ctdb_update_persistent_health(struct ctdb_context *ctdb,
1355                                   struct ctdb_db_context *ctdb_db,
1356                                   const char *reason,/* NULL means healthy */
1357                                   int num_healthy_nodes);
1358 int ctdb_recheck_persistent_health(struct ctdb_context *ctdb);
1359
1360 void ctdb_run_notification_script(struct ctdb_context *ctdb, const char *event);
1361
1362 void ctdb_fault_setup(void);
1363
1364 int verify_remote_ip_allocation(struct ctdb_context *ctdb, 
1365                                 struct ctdb_all_public_ips *ips);
1366 int update_ip_assignment_tree(struct ctdb_context *ctdb,
1367                                 struct ctdb_public_ip *ip);
1368
1369 int ctdb_init_tevent_logging(struct ctdb_context *ctdb);
1370
1371 int ctdb_statistics_init(struct ctdb_context *ctdb);
1372
1373 int32_t ctdb_control_get_stat_history(struct ctdb_context *ctdb,
1374                                       struct ctdb_req_control *c,
1375                                       TDB_DATA *outdata);
1376
1377 int ctdb_deferred_drop_all_ips(struct ctdb_context *ctdb);
1378
1379 #endif