4 Copyright (C) Andrew Tridgell 2006
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.
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.
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/>.
20 #ifndef _CTDB_PRIVATE_H
21 #define _CTDB_PRIVATE_H
23 #include "ctdb_client.h"
24 #include <sys/socket.h>
27 array of tcp connections
29 struct ctdb_tcp_array {
31 struct ctdb_connection *connections;
35 an installed ctdb remote call
37 struct ctdb_registered_call {
38 struct ctdb_registered_call *next, *prev;
44 check that a pnn is valid
46 #define ctdb_validate_pnn(ctdb, pnn) (((uint32_t)(pnn)) < (ctdb)->num_nodes)
48 /* used for callbacks in ctdb_control requests */
49 typedef void (*ctdb_control_callback_fn_t)(struct ctdb_context *,
50 int32_t status, TDB_DATA data,
54 structure describing a connected client in the daemon
57 struct ctdb_context *ctdb;
59 struct ctdb_queue *queue;
62 struct ctdb_tcp_list *tcp_list;
64 uint32_t num_persistent_updates;
65 struct ctdb_client_notify_list *notify;
69 state associated with one node
72 struct ctdb_context *ctdb;
73 ctdb_sock_addr address;
74 const char *name; /* for debug messages */
75 void *private_data; /* private to transport */
79 /* used by the dead node monitoring */
84 /* a list of controls pending to this node, so we can time them out quickly
85 if the node becomes disconnected */
86 struct daemon_control_state *pending_controls;
88 /* used by the recovery dameon to track when a node should be banned */
89 struct ctdb_banning_state *ban_state;
93 transport specific methods
96 int (*initialise)(struct ctdb_context *); /* initialise transport structures */
97 int (*start)(struct ctdb_context *); /* start the transport */
98 int (*add_node)(struct ctdb_node *); /* setup a new node */
99 int (*connect_node)(struct ctdb_node *); /* connect to node */
100 int (*queue_pkt)(struct ctdb_node *, uint8_t *data, uint32_t length);
101 void *(*allocate_pkt)(TALLOC_CTX *mem_ctx, size_t );
102 void (*shutdown)(struct ctdb_context *); /* shutdown transport */
103 void (*restart)(struct ctdb_node *); /* stop and restart the connection */
107 transport calls up to the ctdb layer
109 struct ctdb_upcalls {
110 /* recv_pkt is called when a packet comes in */
111 void (*recv_pkt)(struct ctdb_context *, uint8_t *data, uint32_t length);
113 /* node_dead is called when an attempt to send to a node fails */
114 void (*node_dead)(struct ctdb_node *);
116 /* node_connected is called when a connection to a node is established */
117 void (*node_connected)(struct ctdb_node *);
120 /* additional data required for the daemon mode */
121 struct ctdb_daemon_data {
124 struct ctdb_queue *queue;
128 #define CTDB_UPDATE_STAT(ctdb, counter, value) \
130 if (value > ctdb->statistics.counter) { \
131 ctdb->statistics.counter = value; \
133 if (value > ctdb->statistics_current.counter) { \
134 ctdb->statistics_current.counter = value; \
138 #define CTDB_INCREMENT_STAT(ctdb, counter) \
140 ctdb->statistics.counter++; \
141 ctdb->statistics_current.counter++; \
144 #define CTDB_DECREMENT_STAT(ctdb, counter) \
146 if (ctdb->statistics.counter > 0) \
147 ctdb->statistics.counter--; \
148 if (ctdb->statistics_current.counter > 0) \
149 ctdb->statistics_current.counter--; \
152 #define CTDB_INCREMENT_DB_STAT(ctdb_db, counter) \
154 ctdb_db->statistics.counter++; \
157 #define CTDB_DECREMENT_DB_STAT(ctdb_db, counter) \
159 if (ctdb_db->statistics.counter > 0) \
160 ctdb_db->statistics.counter--; \
163 #define CTDB_UPDATE_RECLOCK_LATENCY(ctdb, name, counter, value) \
165 if (value > ctdb->statistics.counter.max) \
166 ctdb->statistics.counter.max = value; \
167 if (value > ctdb->statistics_current.counter.max) \
168 ctdb->statistics_current.counter.max = value; \
170 if (ctdb->statistics.counter.num == 0 || \
171 value < ctdb->statistics.counter.min) \
172 ctdb->statistics.counter.min = value; \
173 if (ctdb->statistics_current.counter.num == 0 || \
174 value < ctdb->statistics_current.counter.min) \
175 ctdb->statistics_current.counter.min = value; \
177 ctdb->statistics.counter.total += value; \
178 ctdb->statistics_current.counter.total += value; \
180 ctdb->statistics.counter.num++; \
181 ctdb->statistics_current.counter.num++; \
183 if (ctdb->tunable.reclock_latency_ms != 0) { \
184 if (value*1000 > ctdb->tunable.reclock_latency_ms) { \
186 ("High RECLOCK latency %fs for operation %s\n", \
192 #define CTDB_UPDATE_DB_LATENCY(ctdb_db, operation, counter, value) \
194 if (value > ctdb_db->statistics.counter.max) \
195 ctdb_db->statistics.counter.max = value; \
196 if (ctdb_db->statistics.counter.num == 0 || \
197 value < ctdb_db->statistics.counter.min) \
198 ctdb_db->statistics.counter.min = value; \
200 ctdb_db->statistics.counter.total += value; \
201 ctdb_db->statistics.counter.num++; \
203 if (ctdb_db->ctdb->tunable.log_latency_ms != 0) { \
204 if (value*1000 > ctdb_db->ctdb->tunable.log_latency_ms) { \
206 ("High latency %.6fs for operation %s on database %s\n",\
207 value, operation, ctdb_db->db_name)); \
212 #define CTDB_UPDATE_LATENCY(ctdb, db, operation, counter, t) \
214 double l = timeval_elapsed(&t); \
216 if (l > ctdb->statistics.counter.max) \
217 ctdb->statistics.counter.max = l; \
218 if (l > ctdb->statistics_current.counter.max) \
219 ctdb->statistics_current.counter.max = l; \
221 if (ctdb->statistics.counter.num == 0 || \
222 l < ctdb->statistics.counter.min) \
223 ctdb->statistics.counter.min = l; \
224 if (ctdb->statistics_current.counter.num == 0 || \
225 l < ctdb->statistics_current.counter.min) \
226 ctdb->statistics_current.counter.min = l; \
228 ctdb->statistics.counter.total += l; \
229 ctdb->statistics_current.counter.total += l; \
231 ctdb->statistics.counter.num++; \
232 ctdb->statistics_current.counter.num++; \
234 if (ctdb->tunable.log_latency_ms != 0) { \
235 if (l*1000 > ctdb->tunable.log_latency_ms) { \
236 DEBUG(DEBUG_WARNING, \
237 ("High latency %.6fs for operation %s on database %s\n",\
238 l, operation, db->db_name)); \
244 struct ctdb_cluster_mutex_handle;
245 struct eventd_context;
247 enum ctdb_freeze_mode {CTDB_FREEZE_NONE, CTDB_FREEZE_PENDING, CTDB_FREEZE_FROZEN};
249 /* main state of the ctdb daemon */
250 struct ctdb_context {
251 struct tevent_context *ev;
252 struct timeval ctdbd_start_time;
253 struct timeval last_recovery_started;
254 struct timeval last_recovery_finished;
255 uint32_t recovery_mode;
256 TALLOC_CTX *tickle_update_context;
257 TALLOC_CTX *keepalive_ctx;
258 TALLOC_CTX *check_public_ifaces_ctx;
259 struct ctdb_tunable_list tunable;
260 enum ctdb_freeze_mode freeze_mode;
261 struct ctdb_freeze_handle *freeze_handle;
262 bool freeze_transaction_started;
263 uint32_t freeze_transaction_id;
264 ctdb_sock_addr *address;
266 const char *db_directory;
267 const char *db_directory_persistent;
268 const char *db_directory_state;
269 struct tdb_wrap *db_persistent_health;
270 uint32_t db_persistent_startup_generation;
271 uint64_t db_persistent_check_errors;
272 uint64_t max_persistent_check_errors;
273 const char *transport;
274 const char *recovery_lock;
275 uint32_t pnn; /* our own pnn */
277 uint32_t num_connected;
279 uint32_t capabilities;
280 struct reqid_context *idr;
281 struct ctdb_node **nodes; /* array of nodes in the cluster - indexed by vnn */
282 struct ctdb_vnn *vnn; /* list of public ip addresses and interfaces */
283 struct ctdb_interface *ifaces; /* list of local interfaces */
285 const struct ctdb_methods *methods; /* transport methods */
286 const struct ctdb_upcalls *upcalls; /* transport upcalls */
287 void *private_data; /* private to transport */
288 struct ctdb_db_context *db_list;
289 struct srvid_context *srv;
290 struct ctdb_daemon_data daemon;
291 struct ctdb_statistics statistics;
292 struct ctdb_statistics statistics_current;
293 #define MAX_STAT_HISTORY 100
294 struct ctdb_statistics statistics_history[MAX_STAT_HISTORY];
295 struct ctdb_vnn_map *vnn_map;
296 uint32_t num_clients;
297 uint32_t recovery_master;
298 struct ctdb_client_ip *client_ip_list;
299 bool do_checkpublicip;
301 const char *event_script_dir;
302 const char *notification_script;
303 const char *default_public_interface;
306 enum ctdb_runstate runstate;
307 struct ctdb_monitor_state *monitor;
308 int start_as_disabled;
309 int start_as_stopped;
311 uint32_t *recd_ping_count;
312 TALLOC_CTX *recd_ctx; /* a context used to track recoverd monitoring events */
313 TALLOC_CTX *release_ips_ctx; /* a context used to automatically drop all IPs if we fail to recover the node */
315 struct eventd_context *ectx;
317 TALLOC_CTX *banning_ctx;
319 struct ctdb_vacuum_child_context *vacuumers;
321 /* mapping from pid to ctdb_client * */
322 struct ctdb_client_pid_list *client_pids;
324 /* Used to defer db attach requests while in recovery mode */
325 struct ctdb_deferred_attach_context *deferred_attach;
327 /* if we are a child process, do we have a domain socket to send controls on */
328 bool can_send_controls;
330 struct ctdb_reloadips_handle *reload_ips;
332 const char *nodes_file;
333 const char *public_addresses_file;
334 struct trbt_tree *child_processes;
336 /* Used for locking record/db/alldb */
337 struct lock_context *lock_current;
338 struct lock_context *lock_pending;
341 struct ctdb_db_context {
342 struct ctdb_db_context *next, *prev;
343 struct ctdb_context *ctdb;
346 bool readonly; /* Do we support read-only delegations ? */
347 bool sticky; /* Do we support sticky records ? */
350 struct tdb_wrap *ltdb;
351 struct tdb_context *rottdb; /* ReadOnly tracking TDB */
352 struct ctdb_registered_call *calls; /* list of registered calls */
354 struct tevent_timer *seqnum_update;
355 struct ctdb_traverse_local_handle *traverse;
356 struct ctdb_vacuum_handle *vacuum_handle;
357 char *unhealthy_reason;
358 int pending_requests;
359 struct revokechild_handle *revokechild_active;
360 struct ctdb_persistent_state *persistent_state;
361 struct trbt_tree *delete_queue;
362 struct trbt_tree *sticky_records;
363 int (*ctdb_ltdb_store_fn)(struct ctdb_db_context *ctdb_db,
365 struct ctdb_ltdb_header *header,
368 /* used to track which records we are currently fetching
369 so we can avoid sending duplicate fetch requests
371 struct trbt_tree *deferred_fetch;
372 struct trbt_tree *defer_dmaster;
374 struct ctdb_db_statistics_old statistics;
376 struct lock_context *lock_current;
377 struct lock_context *lock_pending;
378 int lock_num_current;
380 struct ctdb_call_state *pending_calls;
382 enum ctdb_freeze_mode freeze_mode;
383 struct ctdb_db_freeze_handle *freeze_handle;
384 bool freeze_transaction_started;
385 uint32_t freeze_transaction_id;
391 struct hash_count_context *migratedb;
395 #define CTDB_NO_MEMORY(ctdb, p) do { if (!(p)) { \
396 DEBUG(0,("Out of memory for %s at %s\n", #p, __location__)); \
397 ctdb_set_error(ctdb, "Out of memory at %s:%d", __FILE__, __LINE__); \
398 return -1; }} while (0)
400 #define CTDB_NO_MEMORY_VOID(ctdb, p) do { if (!(p)) { \
401 DEBUG(0,("Out of memory for %s at %s\n", #p, __location__)); \
402 ctdb_set_error(ctdb, "Out of memory at %s:%d", __FILE__, __LINE__); \
405 #define CTDB_NO_MEMORY_NULL(ctdb, p) do { if (!(p)) { \
406 DEBUG(0,("Out of memory for %s at %s\n", #p, __location__)); \
407 ctdb_set_error(ctdb, "Out of memory at %s:%d", __FILE__, __LINE__); \
408 return NULL; }} while (0)
410 #define CTDB_NO_MEMORY_FATAL(ctdb, p) do { if (!(p)) { \
411 DEBUG(0,("Out of memory for %s at %s\n", #p, __location__)); \
412 ctdb_fatal(ctdb, "Out of memory in " __location__ ); \
416 enum call_state {CTDB_CALL_WAIT, CTDB_CALL_DONE, CTDB_CALL_ERROR};
419 state of a in-progress ctdb call
421 struct ctdb_call_state {
422 struct ctdb_call_state *next, *prev;
423 enum call_state state;
425 struct ctdb_req_call_old *c;
426 struct ctdb_db_context *ctdb_db;
428 struct ctdb_call *call;
431 void (*fn)(struct ctdb_call_state *);
436 /* internal prototypes */
438 #define CHECK_CONTROL_DATA_SIZE(size) do { \
439 if (indata.dsize != size) { \
440 DEBUG(0,(__location__ " Invalid data size in opcode %u. Got %u expected %u\n", \
441 opcode, (unsigned)indata.dsize, (unsigned)size)); \
446 #define CHECK_CONTROL_MIN_DATA_SIZE(size) do { \
447 if (indata.dsize < size) { \
448 DEBUG(0,(__location__ " Invalid data size in opcode %u. Got %u expected >= %u\n", \
449 opcode, (unsigned)indata.dsize, (unsigned)size)); \
455 state of a in-progress ctdb call in client
457 struct ctdb_client_call_state {
458 enum call_state state;
460 struct ctdb_db_context *ctdb_db;
461 struct ctdb_call *call;
463 void (*fn)(struct ctdb_client_call_state *);
468 extern int script_log_level;
469 extern bool fast_start;
470 extern const char *ctdbd_pidfile;
472 typedef void (*deferred_requeue_fn)(void *call_context, struct ctdb_req_header *hdr);
475 /* from tcp/ and ib/ */
477 int ctdb_tcp_init(struct ctdb_context *ctdb);
478 int ctdb_ibw_init(struct ctdb_context *ctdb);
480 /* from ctdb_banning.c */
482 void ctdb_local_node_got_banned(struct ctdb_context *ctdb);
483 int32_t ctdb_control_set_ban_state(struct ctdb_context *ctdb, TDB_DATA indata);
484 int32_t ctdb_control_get_ban_state(struct ctdb_context *ctdb, TDB_DATA *outdata);
485 void ctdb_ban_self(struct ctdb_context *ctdb);
487 /* from ctdb_call.c */
489 struct ctdb_db_context *find_ctdb_db(struct ctdb_context *ctdb, uint32_t id);
491 void ctdb_request_dmaster(struct ctdb_context *ctdb,
492 struct ctdb_req_header *hdr);
493 void ctdb_reply_dmaster(struct ctdb_context *ctdb,
494 struct ctdb_req_header *hdr);
495 void ctdb_request_call(struct ctdb_context *ctdb, struct ctdb_req_header *hdr);
496 void ctdb_reply_call(struct ctdb_context *ctdb, struct ctdb_req_header *hdr);
497 void ctdb_reply_error(struct ctdb_context *ctdb, struct ctdb_req_header *hdr);
499 void ctdb_call_resend_db(struct ctdb_db_context *ctdb);
500 void ctdb_call_resend_all(struct ctdb_context *ctdb);
502 struct ctdb_call_state *ctdb_call_local_send(struct ctdb_db_context *ctdb_db,
503 struct ctdb_call *call,
504 struct ctdb_ltdb_header *header,
507 struct ctdb_call_state *ctdb_daemon_call_send_remote(
508 struct ctdb_db_context *ctdb_db,
509 struct ctdb_call *call,
510 struct ctdb_ltdb_header *header);
511 int ctdb_daemon_call_recv(struct ctdb_call_state *state,
512 struct ctdb_call *call);
514 void ctdb_send_keepalive(struct ctdb_context *ctdb, uint32_t destnode);
516 int ctdb_start_revoke_ro_record(struct ctdb_context *ctdb,
517 struct ctdb_db_context *ctdb_db,
518 TDB_DATA key, struct ctdb_ltdb_header *header,
521 int ctdb_add_revoke_deferred_call(struct ctdb_context *ctdb,
522 struct ctdb_db_context *ctdb_db,
523 TDB_DATA key, struct ctdb_req_header *hdr,
524 deferred_requeue_fn fn, void *call_context);
526 int ctdb_migration_init(struct ctdb_db_context *ctdb_db);
528 /* from server/ctdb_control.c */
530 int32_t ctdb_dump_memory(struct ctdb_context *ctdb, TDB_DATA *outdata);
532 void ctdb_request_control_reply(struct ctdb_context *ctdb,
533 struct ctdb_req_control_old *c,
534 TDB_DATA *outdata, int32_t status,
535 const char *errormsg);
537 void ctdb_request_control(struct ctdb_context *ctdb,
538 struct ctdb_req_header *hdr);
539 void ctdb_reply_control(struct ctdb_context *ctdb,
540 struct ctdb_req_header *hdr);
542 int ctdb_daemon_send_control(struct ctdb_context *ctdb, uint32_t destnode,
543 uint64_t srvid, uint32_t opcode,
544 uint32_t client_id, uint32_t flags,
546 ctdb_control_callback_fn_t callback,
549 /* from server/ctdb_daemon.c */
551 int daemon_register_message_handler(struct ctdb_context *ctdb,
552 uint32_t client_id, uint64_t srvid);
553 int daemon_deregister_message_handler(struct ctdb_context *ctdb,
554 uint32_t client_id, uint64_t srvid);
555 int daemon_check_srvids(struct ctdb_context *ctdb, TDB_DATA indata,
558 int ctdb_start_daemon(struct ctdb_context *ctdb, bool do_fork);
560 struct ctdb_req_header *_ctdb_transport_allocate(struct ctdb_context *ctdb,
562 enum ctdb_operation operation,
563 size_t length, size_t slength,
566 #define ctdb_transport_allocate(ctdb, mem_ctx, operation, length, type) \
567 (type *)_ctdb_transport_allocate(ctdb, mem_ctx, operation, length, \
570 void ctdb_daemon_cancel_controls(struct ctdb_context *ctdb,
571 struct ctdb_node *node);
573 int ctdb_daemon_set_call(struct ctdb_context *ctdb, uint32_t db_id,
574 ctdb_fn_t fn, int id);
576 int ctdb_daemon_send_message(struct ctdb_context *ctdb, uint32_t pnn,
577 uint64_t srvid, TDB_DATA data);
579 int32_t ctdb_control_register_notify(struct ctdb_context *ctdb,
580 uint32_t client_id, TDB_DATA indata);
581 int32_t ctdb_control_deregister_notify(struct ctdb_context *ctdb,
582 uint32_t client_id, TDB_DATA indata);
584 struct ctdb_client *ctdb_find_client_by_pid(struct ctdb_context *ctdb,
587 int32_t ctdb_control_process_exists(struct ctdb_context *ctdb, pid_t pid);
589 int ctdb_control_getnodesfile(struct ctdb_context *ctdb, uint32_t opcode,
590 TDB_DATA indata, TDB_DATA *outdata);
592 void ctdb_shutdown_sequence(struct ctdb_context *ctdb, int exit_code);
594 int switch_from_server_to_client(struct ctdb_context *ctdb);
596 /* From server/ctdb_fork.c */
598 void ctdb_track_child(struct ctdb_context *ctdb, pid_t pid);
600 pid_t ctdb_fork(struct ctdb_context *ctdb);
601 pid_t ctdb_vfork_exec(TALLOC_CTX *mem_ctx, struct ctdb_context *ctdb,
602 const char *helper, int helper_argc,
603 const char **helper_argv);
605 struct tevent_signal *ctdb_init_sigchld(struct ctdb_context *ctdb);
607 int ctdb_kill(struct ctdb_context *ctdb, pid_t pid, int signum);
609 /* from server/ctdb_freeze.c */
611 int32_t ctdb_control_db_freeze(struct ctdb_context *ctdb,
612 struct ctdb_req_control_old *c,
613 uint32_t db_id, bool *async_reply);
614 int32_t ctdb_control_db_thaw(struct ctdb_context *ctdb, uint32_t db_id);
616 int32_t ctdb_control_freeze(struct ctdb_context *ctdb,
617 struct ctdb_req_control_old *c, bool *async_reply);
618 int32_t ctdb_control_thaw(struct ctdb_context *ctdb, bool check_recmode);
620 bool ctdb_blocking_freeze(struct ctdb_context *ctdb);
622 int32_t ctdb_control_db_transaction_start(struct ctdb_context *ctdb,
624 int32_t ctdb_control_db_transaction_cancel(struct ctdb_context *ctdb,
626 int32_t ctdb_control_db_transaction_commit(struct ctdb_context *ctdb,
629 int32_t ctdb_control_wipe_database(struct ctdb_context *ctdb, TDB_DATA indata);
631 bool ctdb_db_frozen(struct ctdb_db_context *ctdb_db);
632 bool ctdb_db_all_frozen(struct ctdb_context *ctdb);
634 /* from server/ctdb_keepalive.c */
636 void ctdb_start_keepalive(struct ctdb_context *ctdb);
637 void ctdb_stop_keepalive(struct ctdb_context *ctdb);
639 /* from server/ctdb_lock.c */
643 typedef int (*ctdb_db_handler_t)(struct ctdb_db_context *ctdb_db,
646 int ctdb_db_iterator(struct ctdb_context *ctdb, ctdb_db_handler_t handler,
649 int ctdb_lockdb_mark(struct ctdb_db_context *ctdb_db);
651 int ctdb_lockdb_unmark(struct ctdb_db_context *ctdb_db);
653 struct lock_request *ctdb_lock_record(TALLOC_CTX *mem_ctx,
654 struct ctdb_db_context *ctdb_db,
657 void (*callback)(void *, bool),
660 struct lock_request *ctdb_lock_db(TALLOC_CTX *mem_ctx,
661 struct ctdb_db_context *ctdb_db,
663 void (*callback)(void *, bool),
666 /* from ctdb_logging.c */
668 bool ctdb_logging_init(TALLOC_CTX *mem_ctx, const char *logging,
669 const char *debug_level);
671 struct ctdb_log_state *ctdb_vfork_with_logging(TALLOC_CTX *mem_ctx,
672 struct ctdb_context *ctdb,
673 const char *log_prefix,
676 const char **helper_argv,
677 void (*logfn)(const char *,
679 void *logfn_private, pid_t *pid);
681 int ctdb_set_child_logging(struct ctdb_context *ctdb);
683 /* from ctdb_logging_file.c */
685 void ctdb_log_init_file(void);
687 /* from ctdb_logging_syslog.c */
689 void ctdb_log_init_syslog(void);
691 /* from ctdb_ltdb_server.c */
693 int ctdb_ltdb_lock_requeue(struct ctdb_db_context *ctdb_db,
694 TDB_DATA key, struct ctdb_req_header *hdr,
695 void (*recv_pkt)(void *, struct ctdb_req_header *),
696 void *recv_context, bool ignore_generation);
698 int ctdb_ltdb_lock_fetch_requeue(struct ctdb_db_context *ctdb_db,
699 TDB_DATA key, struct ctdb_ltdb_header *header,
700 struct ctdb_req_header *hdr, TDB_DATA *data,
701 void (*recv_pkt)(void *, struct ctdb_req_header *),
702 void *recv_context, bool ignore_generation);
704 int ctdb_load_persistent_health(struct ctdb_context *ctdb,
705 struct ctdb_db_context *ctdb_db);
706 int ctdb_update_persistent_health(struct ctdb_context *ctdb,
707 struct ctdb_db_context *ctdb_db,
708 const char *reason,/* NULL means healthy */
709 int num_healthy_nodes);
710 int ctdb_recheck_persistent_health(struct ctdb_context *ctdb);
712 int32_t ctdb_control_db_set_healthy(struct ctdb_context *ctdb,
714 int32_t ctdb_control_db_get_health(struct ctdb_context *ctdb,
715 TDB_DATA indata, TDB_DATA *outdata);
717 int ctdb_set_db_readonly(struct ctdb_context *ctdb,
718 struct ctdb_db_context *ctdb_db);
720 int ctdb_process_deferred_attach(struct ctdb_context *ctdb);
722 int32_t ctdb_control_db_attach(struct ctdb_context *ctdb, TDB_DATA indata,
723 TDB_DATA *outdata, uint64_t tdb_flags,
724 bool persistent, uint32_t client_id,
725 struct ctdb_req_control_old *c,
727 int32_t ctdb_control_db_detach(struct ctdb_context *ctdb, TDB_DATA indata,
730 int ctdb_attach_databases(struct ctdb_context *ctdb);
732 int32_t ctdb_ltdb_update_seqnum(struct ctdb_context *ctdb, uint32_t db_id,
734 int32_t ctdb_ltdb_enable_seqnum(struct ctdb_context *ctdb, uint32_t db_id);
736 int ctdb_set_db_sticky(struct ctdb_context *ctdb,
737 struct ctdb_db_context *ctdb_db);
739 void ctdb_db_statistics_reset(struct ctdb_db_context *ctdb_db);
741 int32_t ctdb_control_get_db_statistics(struct ctdb_context *ctdb,
742 uint32_t db_id, TDB_DATA *outdata);
744 /* from ctdb_monitor.c */
746 int ctdb_set_notification_script(struct ctdb_context *ctdb, const char *script);
747 void ctdb_run_notification_script(struct ctdb_context *ctdb, const char *event);
749 void ctdb_disable_monitoring(struct ctdb_context *ctdb);
750 void ctdb_enable_monitoring(struct ctdb_context *ctdb);
751 void ctdb_stop_monitoring(struct ctdb_context *ctdb);
753 void ctdb_wait_for_first_recovery(struct ctdb_context *ctdb);
755 int32_t ctdb_control_modflags(struct ctdb_context *ctdb, TDB_DATA indata);
757 int32_t ctdb_monitoring_mode(struct ctdb_context *ctdb);
758 bool ctdb_stopped_monitoring(struct ctdb_context *ctdb);
760 /* from ctdb_persistent.c */
762 void ctdb_persistent_finish_trans3_commits(struct ctdb_context *ctdb);
764 int32_t ctdb_control_trans3_commit(struct ctdb_context *ctdb,
765 struct ctdb_req_control_old *c,
766 TDB_DATA recdata, bool *async_reply);
768 int32_t ctdb_control_start_persistent_update(struct ctdb_context *ctdb,
769 struct ctdb_req_control_old *c,
771 int32_t ctdb_control_cancel_persistent_update(struct ctdb_context *ctdb,
772 struct ctdb_req_control_old *c,
775 int32_t ctdb_control_get_db_seqnum(struct ctdb_context *ctdb,
776 TDB_DATA indata, TDB_DATA *outdata);
778 /* from ctdb_recover.c */
780 int ctdb_control_getvnnmap(struct ctdb_context *ctdb, uint32_t opcode,
781 TDB_DATA indata, TDB_DATA *outdata);
782 int ctdb_control_setvnnmap(struct ctdb_context *ctdb, uint32_t opcode,
783 TDB_DATA indata, TDB_DATA *outdata);
785 int ctdb_control_getdbmap(struct ctdb_context *ctdb, uint32_t opcode,
786 TDB_DATA indata, TDB_DATA *outdata);
787 int ctdb_control_getnodemap(struct ctdb_context *ctdb, uint32_t opcode,
788 TDB_DATA indata, TDB_DATA *outdata);
790 int ctdb_control_reload_nodes_file(struct ctdb_context *ctdb, uint32_t opcode);
792 int32_t ctdb_control_pull_db(struct ctdb_context *ctdb, TDB_DATA indata,
794 int32_t ctdb_control_push_db(struct ctdb_context *ctdb, TDB_DATA indata);
796 int32_t ctdb_control_db_pull(struct ctdb_context *ctdb,
797 struct ctdb_req_control_old *c,
798 TDB_DATA indata, TDB_DATA *outdata);
799 int32_t ctdb_control_db_push_start(struct ctdb_context *ctdb,
801 int32_t ctdb_control_db_push_confirm(struct ctdb_context *ctdb,
802 TDB_DATA indata, TDB_DATA *outdata);
804 int ctdb_deferred_drop_all_ips(struct ctdb_context *ctdb);
806 int32_t ctdb_control_set_recmode(struct ctdb_context *ctdb,
807 struct ctdb_req_control_old *c,
808 TDB_DATA indata, bool *async_reply,
809 const char **errormsg);
811 int32_t ctdb_control_end_recovery(struct ctdb_context *ctdb,
812 struct ctdb_req_control_old *c,
814 int32_t ctdb_control_start_recovery(struct ctdb_context *ctdb,
815 struct ctdb_req_control_old *c,
818 int32_t ctdb_control_try_delete_records(struct ctdb_context *ctdb,
819 TDB_DATA indata, TDB_DATA *outdata);
820 int32_t ctdb_control_receive_records(struct ctdb_context *ctdb,
821 TDB_DATA indata, TDB_DATA *outdata);
823 int32_t ctdb_control_get_capabilities(struct ctdb_context *ctdb,
826 int32_t ctdb_control_recd_ping(struct ctdb_context *ctdb);
827 int32_t ctdb_control_set_recmaster(struct ctdb_context *ctdb,
828 uint32_t opcode, TDB_DATA indata);
830 int32_t ctdb_control_stop_node(struct ctdb_context *ctdb);
831 int32_t ctdb_control_continue_node(struct ctdb_context *ctdb);
833 /* from ctdb_recoverd.c */
835 int ctdb_start_recoverd(struct ctdb_context *ctdb);
836 void ctdb_stop_recoverd(struct ctdb_context *ctdb);
838 /* from ctdb_server.c */
840 int ctdb_set_transport(struct ctdb_context *ctdb, const char *transport);
842 int ctdb_ip_to_nodeid(struct ctdb_context *ctdb, const ctdb_sock_addr *nodeip);
844 void ctdb_load_nodes_file(struct ctdb_context *ctdb);
846 int ctdb_set_address(struct ctdb_context *ctdb, const char *address);
848 uint32_t ctdb_get_num_active_nodes(struct ctdb_context *ctdb);
850 void ctdb_input_pkt(struct ctdb_context *ctdb, struct ctdb_req_header *);
852 void ctdb_node_dead(struct ctdb_node *node);
853 void ctdb_node_connected(struct ctdb_node *node);
855 void ctdb_queue_packet(struct ctdb_context *ctdb, struct ctdb_req_header *hdr);
856 void ctdb_queue_packet_opcode(struct ctdb_context *ctdb,
857 struct ctdb_req_header *hdr, unsigned opcode);
859 /* from ctdb_serverids.c */
861 int32_t ctdb_control_register_server_id(struct ctdb_context *ctdb,
862 uint32_t client_id, TDB_DATA indata);
863 int32_t ctdb_control_check_server_id(struct ctdb_context *ctdb,
865 int32_t ctdb_control_unregister_server_id(struct ctdb_context *ctdb,
867 int32_t ctdb_control_get_server_id_list(struct ctdb_context *ctdb,
870 /* from ctdb_statistics.c */
872 int ctdb_statistics_init(struct ctdb_context *ctdb);
874 int32_t ctdb_control_get_stat_history(struct ctdb_context *ctdb,
875 struct ctdb_req_control_old *c,
878 /* from ctdb_takeover.c */
880 int32_t ctdb_control_takeover_ip(struct ctdb_context *ctdb,
881 struct ctdb_req_control_old *c,
884 int32_t ctdb_control_release_ip(struct ctdb_context *ctdb,
885 struct ctdb_req_control_old *c,
888 int32_t ctdb_control_ipreallocated(struct ctdb_context *ctdb,
889 struct ctdb_req_control_old *c,
892 int ctdb_set_public_addresses(struct ctdb_context *ctdb, bool check_addresses);
894 int32_t ctdb_control_tcp_client(struct ctdb_context *ctdb, uint32_t client_id,
896 int32_t ctdb_control_tcp_add(struct ctdb_context *ctdb, TDB_DATA indata,
897 bool tcp_update_needed);
898 int32_t ctdb_control_tcp_remove(struct ctdb_context *ctdb, TDB_DATA indata);
899 int32_t ctdb_control_startup(struct ctdb_context *ctdb, uint32_t vnn);
901 void ctdb_takeover_client_destructor_hook(struct ctdb_client *client);
903 void ctdb_release_all_ips(struct ctdb_context *ctdb);
905 int32_t ctdb_control_get_public_ips(struct ctdb_context *ctdb,
906 struct ctdb_req_control_old *c,
908 int32_t ctdb_control_get_public_ip_info(struct ctdb_context *ctdb,
909 struct ctdb_req_control_old *c,
910 TDB_DATA indata, TDB_DATA *outdata);
912 int32_t ctdb_control_get_ifaces(struct ctdb_context *ctdb,
913 struct ctdb_req_control_old *c,
915 int32_t ctdb_control_set_iface_link(struct ctdb_context *ctdb,
916 struct ctdb_req_control_old *c,
919 int32_t ctdb_control_set_tcp_tickle_list(struct ctdb_context *ctdb,
921 int32_t ctdb_control_get_tcp_tickle_list(struct ctdb_context *ctdb,
922 TDB_DATA indata, TDB_DATA *outdata);
924 void ctdb_start_tcp_tickle_update(struct ctdb_context *ctdb);
926 int32_t ctdb_control_send_gratious_arp(struct ctdb_context *ctdb,
929 int32_t ctdb_control_add_public_address(struct ctdb_context *ctdb,
931 int32_t ctdb_control_del_public_address(struct ctdb_context *ctdb,
934 int32_t ctdb_control_reload_public_ips(struct ctdb_context *ctdb,
935 struct ctdb_req_control_old *c,
938 /* from ctdb_traverse.c */
940 int32_t ctdb_control_traverse_all_ext(struct ctdb_context *ctdb,
941 TDB_DATA data, TDB_DATA *outdata);
942 int32_t ctdb_control_traverse_all(struct ctdb_context *ctdb,
943 TDB_DATA data, TDB_DATA *outdata);
944 int32_t ctdb_control_traverse_data(struct ctdb_context *ctdb,
945 TDB_DATA data, TDB_DATA *outdata);
946 int32_t ctdb_control_traverse_kill(struct ctdb_context *ctdb, TDB_DATA indata,
947 TDB_DATA *outdata, uint32_t srcnode);
949 int32_t ctdb_control_traverse_start_ext(struct ctdb_context *ctdb,
950 TDB_DATA indata, TDB_DATA *outdata,
951 uint32_t srcnode, uint32_t client_id);
952 int32_t ctdb_control_traverse_start(struct ctdb_context *ctdb,
953 TDB_DATA indata, TDB_DATA *outdata,
954 uint32_t srcnode, uint32_t client_id);
956 /* from ctdb_tunables.c */
958 void ctdb_tunables_set_defaults(struct ctdb_context *ctdb);
960 int32_t ctdb_control_get_tunable(struct ctdb_context *ctdb, TDB_DATA indata,
962 int32_t ctdb_control_set_tunable(struct ctdb_context *ctdb, TDB_DATA indata);
963 int32_t ctdb_control_list_tunables(struct ctdb_context *ctdb,
966 /* from ctdb_update_record.c */
968 int32_t ctdb_control_update_record(struct ctdb_context *ctdb,
969 struct ctdb_req_control_old *c,
970 TDB_DATA recdata, bool *async_reply);
972 /* from ctdb_uptime.c */
974 int32_t ctdb_control_uptime(struct ctdb_context *ctdb, TDB_DATA *outdata);
976 /* from ctdb_vacuum.c */
978 void ctdb_stop_vacuuming(struct ctdb_context *ctdb);
979 int ctdb_vacuum_init(struct ctdb_db_context *ctdb_db);
981 int32_t ctdb_control_schedule_for_deletion(struct ctdb_context *ctdb,
983 int32_t ctdb_local_schedule_for_deletion(struct ctdb_db_context *ctdb_db,
984 const struct ctdb_ltdb_header *hdr,
987 void ctdb_local_remove_from_delete_queue(struct ctdb_db_context *ctdb_db,
988 const struct ctdb_ltdb_header *hdr,
991 /* from eventscript.c */
993 int ctdb_start_eventd(struct ctdb_context *ctdb);
994 void ctdb_stop_eventd(struct ctdb_context *ctdb);
996 int ctdb_event_script_callback(struct ctdb_context *ctdb,
998 void (*callback)(struct ctdb_context *,
1001 enum ctdb_event call,
1002 const char *fmt, ...) PRINTF_ATTRIBUTE(6,7);
1004 int ctdb_event_script_args(struct ctdb_context *ctdb,
1005 enum ctdb_event call,
1006 const char *fmt, ...) PRINTF_ATTRIBUTE(3,4);
1008 int ctdb_event_script(struct ctdb_context *ctdb,
1009 enum ctdb_event call);