uint32_t lcp2_public_ip_assignment;
uint32_t allow_client_db_attach;
uint32_t recover_pdb_by_seqnum;
+ uint32_t deferred_rebalance_on_node_add;
+ uint32_t fetch_collapse;
+ uint32_t max_lacount;
+ uint32_t hopcount_make_sticky;
+ uint32_t sticky_duration;
+ uint32_t sticky_pindown;
+ uint32_t no_ip_takeover;
+ uint32_t db_record_count_warn;
+ uint32_t db_record_size_warn;
+ uint32_t db_size_warn;
+ uint32_t pulldb_preallocation_size;
+ uint32_t no_ip_host_on_all_disabled;
+ uint32_t deadlock_timeout;
+ uint32_t samba3_hack;
};
/*
TALLOC_CTX *takeover_ctx;
struct ctdb_kill_tcp *killtcp;
+
+ /* Set to true any time an update to this VNN is in flight.
+ This helps to avoid races. */
+ bool update_in_flight;
};
/*
/* list of message handlers - needs to be changed to a more efficient data
structure so we can find a message handler given a srvid quickly */
-struct ctdb_message_list {
+struct ctdb_message_list_header {
+ struct ctdb_message_list_header *next, *prev;
struct ctdb_context *ctdb;
- struct ctdb_message_list *next, *prev;
uint64_t srvid;
+ struct ctdb_message_list *m;
+};
+struct ctdb_message_list {
+ struct ctdb_message_list *next, *prev;
+ struct ctdb_message_list_header *h;
ctdb_msg_fn_t message_handler;
void *message_private;
};
ctdb->statistics_current.counter--; \
}
+#define CTDB_INCREMENT_DB_STAT(ctdb_db, counter) \
+ { \
+ ctdb_db->statistics.counter++; \
+ }
+
+#define CTDB_DECREMENT_DB_STAT(ctdb_db, counter) \
+ { \
+ if (ctdb_db->statistics.counter > 0) \
+ ctdb_db->statistics.counter--; \
+ }
+
#define CTDB_UPDATE_RECLOCK_LATENCY(ctdb, name, counter, value) \
{ \
- if (value > ctdb->statistics.counter.max) \
+ if (value > ctdb->statistics.counter.max) \
ctdb->statistics.counter.max = value; \
- if (value > ctdb->statistics_current.counter.max) \
+ if (value > ctdb->statistics_current.counter.max) \
ctdb->statistics_current.counter.max = value; \
\
- if (ctdb->statistics.counter.num == 0 || value < ctdb->statistics.counter.min) \
+ if (ctdb->statistics.counter.num == 0 || \
+ value < ctdb->statistics.counter.min) \
ctdb->statistics.counter.min = value; \
- if (ctdb->statistics_current.counter.num == 0 || value < ctdb->statistics_current.counter.min) \
+ if (ctdb->statistics_current.counter.num == 0 || \
+ value < ctdb->statistics_current.counter.min) \
ctdb->statistics_current.counter.min = value; \
\
- ctdb->statistics.counter.total += value; \
- ctdb->statistics_current.counter.total += value; \
+ ctdb->statistics.counter.total += value; \
+ ctdb->statistics_current.counter.total += value; \
\
ctdb->statistics.counter.num++; \
ctdb->statistics_current.counter.num++; \
\
if (ctdb->tunable.reclock_latency_ms != 0) { \
if (value*1000 > ctdb->tunable.reclock_latency_ms) { \
- DEBUG(DEBUG_ERR, ("High RECLOCK latency %fs for operation %s\n", value, name)); \
+ DEBUG(DEBUG_ERR, \
+ ("High RECLOCK latency %fs for operation %s\n", \
+ value, name)); \
} \
} \
}
+#define CTDB_UPDATE_DB_LATENCY(ctdb_db, operation, counter, value) \
+ { \
+ if (value > ctdb_db->statistics.counter.max) \
+ ctdb_db->statistics.counter.max = value; \
+ if (ctdb_db->statistics.counter.num == 0 || \
+ value < ctdb_db->statistics.counter.min) \
+ ctdb_db->statistics.counter.min = value; \
+ \
+ ctdb_db->statistics.counter.total += value; \
+ ctdb_db->statistics.counter.num++; \
+ \
+ if (ctdb_db->ctdb->tunable.log_latency_ms != 0) { \
+ if (value*1000 > ctdb_db->ctdb->tunable.log_latency_ms) { \
+ DEBUG(DEBUG_ERR, \
+ ("High latency %.6fs for operation %s on database %s\n",\
+ value, operation, ctdb_db->db_name)); \
+ } \
+ } \
+ }
#define CTDB_UPDATE_LATENCY(ctdb, db, operation, counter, t) \
{ \
if (l > ctdb->statistics_current.counter.max) \
ctdb->statistics_current.counter.max = l; \
\
- if (ctdb->statistics.counter.num == 0 || l < ctdb->statistics.counter.min) \
+ if (ctdb->statistics.counter.num == 0 || \
+ l < ctdb->statistics.counter.min) \
ctdb->statistics.counter.min = l; \
- if (ctdb->statistics_current.counter.num == 0 || l < ctdb->statistics_current.counter.min) \
+ if (ctdb->statistics_current.counter.num == 0 || \
+ l < ctdb->statistics_current.counter.min) \
ctdb->statistics_current.counter.min = l; \
\
ctdb->statistics.counter.total += l; \
ctdb->statistics.counter.num++; \
ctdb->statistics_current.counter.num++; \
\
- if (ctdb->tunable.log_latency_ms !=0) { \
+ if (ctdb->tunable.log_latency_ms != 0) { \
if (l*1000 > ctdb->tunable.log_latency_ms) { \
- DEBUG(DEBUG_WARNING, ("High latency %.6fs for operation %s on database %s\n", l, operation, db->db_name));\
+ DEBUG(DEBUG_WARNING, \
+ ("High latency %.6fs for operation %s on database %s\n",\
+ l, operation, db->db_name)); \
} \
} \
}
enum ctdb_freeze_mode {CTDB_FREEZE_NONE, CTDB_FREEZE_PENDING, CTDB_FREEZE_FROZEN};
+enum ctdb_runstate {
+ CTDB_RUNSTATE_UNKNOWN,
+ CTDB_RUNSTATE_INIT,
+ CTDB_RUNSTATE_SETUP,
+ CTDB_RUNSTATE_STARTUP,
+ CTDB_RUNSTATE_RUNNING,
+ CTDB_RUNSTATE_SHUTDOWN,
+};
+
+const char *runstate_to_string(enum ctdb_runstate runstate);
+enum ctdb_runstate runstate_from_string(const char *label);
+void ctdb_set_runstate(struct ctdb_context *ctdb, enum ctdb_runstate runstate);
+
#define CTDB_MONITORING_ACTIVE 0
#define CTDB_MONITORING_DISABLED 1
-/* The different capabilities of the ctdb daemon. */
-#define CTDB_CAP_RECMASTER 0x00000001
-#define CTDB_CAP_LMASTER 0x00000002
-/* This capability is set if CTDB_LVS_PUBLIC_IP is set */
-#define CTDB_CAP_LVS 0x00000004
-/* This capability is set if NATGW is enabled */
-#define CTDB_CAP_NATGW 0x00000008
-
#define NUM_DB_PRIORITIES 3
/* main state of the ctdb daemon */
struct ctdb_context {
const struct ctdb_upcalls *upcalls; /* transport upcalls */
void *private_data; /* private to transport */
struct ctdb_db_context *db_list;
- struct ctdb_message_list *message_list;
+ struct ctdb_message_list_header *message_list_header;
+ struct tdb_context *message_list_indexdb;
struct ctdb_daemon_data daemon;
struct ctdb_statistics statistics;
struct ctdb_statistics statistics_current;
uint32_t recovery_master;
struct ctdb_call_state *pending_calls;
struct ctdb_client_ip *client_ip_list;
+ bool do_checkpublicip;
struct trbt_tree *server_ids;
bool do_setsched;
void *saved_scheduler_param;
pid_t ctdbd_pid;
pid_t recoverd_pid;
pid_t syslogd_pid;
- bool done_startup;
- const char *node_ip;
+ enum ctdb_runstate runstate;
struct ctdb_monitor_state *monitor;
struct ctdb_log_state *log;
int start_as_disabled;
bool valgrinding;
uint32_t event_script_timeouts; /* counting how many consecutive times an eventscript has timedout */
uint32_t *recd_ping_count;
+ TALLOC_CTX *recd_ctx; /* a context used to track recoverd monitoring events */
TALLOC_CTX *release_ips_ctx; /* a context used to automatically drop all IPs if we fail to recover the node */
TALLOC_CTX *event_script_ctx;
/* Used to defer db attach requests while in recovery mode */
struct ctdb_deferred_attach_context *deferred_attach;
+
+ /* if we are a child process, do we have a domain socket to send controls on */
+ bool can_send_controls;
+
+ /* list of event script callback functions that are active */
+ struct event_script_callback *script_callbacks;
+
+ struct ctdb_reloadips_handle *reload_ips;
+
+ const char *public_addresses_file;
+ struct trbt_tree *child_processes;
+
+ /* Used for locking record/db/alldb */
+ int lock_num_current;
+ int lock_num_pending;
+ struct lock_context *lock_current;
+ struct lock_context *lock_pending;
};
struct ctdb_db_context {
uint32_t priority;
bool persistent;
bool readonly; /* Do we support read-only delegations ? */
+ bool sticky; /* Do we support sticky records ? */
const char *db_name;
const char *db_path;
struct tdb_wrap *ltdb;
struct ctdb_vacuum_handle *vacuum_handle;
char *unhealthy_reason;
int pending_requests;
- struct lockwait_handle *lockwait_active;
- struct lockwait_handle *lockwait_overflow;
struct revokechild_handle *revokechild_active;
struct ctdb_persistent_state *persistent_state;
struct trbt_tree *delete_queue;
+ struct trbt_tree *sticky_records;
int (*ctdb_ltdb_store_fn)(struct ctdb_db_context *ctdb_db,
TDB_DATA key,
struct ctdb_ltdb_header *header,
so we can avoid sending duplicate fetch requests
*/
struct trbt_tree *deferred_fetch;
+
+ struct ctdb_db_statistics statistics;
};
/* internal prototypes */
void ctdb_set_error(struct ctdb_context *ctdb, const char *fmt, ...) PRINTF_ATTRIBUTE(2,3);
void ctdb_fatal(struct ctdb_context *ctdb, const char *msg);
+void ctdb_external_trace(void);
bool ctdb_same_address(struct ctdb_address *a1, struct ctdb_address *a2);
int ctdb_parse_address(struct ctdb_context *ctdb,
TALLOC_CTX *mem_ctx, const char *str,
TDB_DATA *data);
-int ctdbd_start(struct ctdb_context *ctdb);
+int ctdb_start_daemon(struct ctdb_context *ctdb, bool do_fork,
+ bool use_syslog,
+ const char *public_address_list);
struct ctdb_call_state *ctdbd_call_send(struct ctdb_db_context *ctdb_db, struct ctdb_call *call);
int ctdbd_call_recv(struct ctdb_call_state *state, struct ctdb_call *call);
uint64_t srvid, TDB_DATA data);
-struct lockwait_handle *ctdb_lockwait(struct ctdb_db_context *ctdb_db,
- TDB_DATA key,
- void (*callback)(void *), void *private_data);
-
struct ctdb_call_state *ctdb_daemon_call_send(struct ctdb_db_context *ctdb_db,
struct ctdb_call *call);
int ctdb_call_local(struct ctdb_db_context *ctdb_db, struct ctdb_call *call,
struct ctdb_ltdb_header *header, TALLOC_CTX *mem_ctx,
- TDB_DATA *data, bool updatetdb);
+ TDB_DATA *data, bool updatetdb, uint32_t caller);
#define ctdb_reqid_find(ctdb, reqid, type) (type *)_ctdb_reqid_find(ctdb, reqid, #type, __location__)
int32_t ctdb_control_traverse_start(struct ctdb_context *ctdb, TDB_DATA indata,
TDB_DATA *outdata, uint32_t srcnode, uint32_t client_id);
int32_t ctdb_control_traverse_all(struct ctdb_context *ctdb, TDB_DATA data, TDB_DATA *outdata);
+int32_t ctdb_control_traverse_all_ext(struct ctdb_context *ctdb, TDB_DATA data, TDB_DATA *outdata);
int32_t ctdb_control_traverse_data(struct ctdb_context *ctdb, TDB_DATA data, TDB_DATA *outdata);
int32_t ctdb_control_traverse_kill(struct ctdb_context *ctdb, TDB_DATA indata,
TDB_DATA *outdata, uint32_t srcnode);
int ctdb_dispatch_message(struct ctdb_context *ctdb, uint64_t srvid, TDB_DATA data);
+bool ctdb_check_message_handler(struct ctdb_context *ctdb, uint64_t srvid);
int daemon_register_message_handler(struct ctdb_context *ctdb, uint32_t client_id, uint64_t srvid);
int ctdb_deregister_message_handler(struct ctdb_context *ctdb, uint64_t srvid, void *private_data);
int32_t ctdb_control_pull_db(struct ctdb_context *ctdb, TDB_DATA indata, TDB_DATA *outdata);
int32_t ctdb_control_push_db(struct ctdb_context *ctdb, TDB_DATA indata);
-int32_t ctdb_control_set_dmaster(struct ctdb_context *ctdb, TDB_DATA indata);
int32_t ctdb_control_set_recmode(struct ctdb_context *ctdb,
struct ctdb_req_control *c,
bool ctdb_blocking_freeze(struct ctdb_context *ctdb);
void ctdb_set_scheduler(struct ctdb_context *ctdb);
void ctdb_restore_scheduler(struct ctdb_context *ctdb);
+
+struct tevent_signal *ctdb_init_sigchld(struct ctdb_context *ctdb);
pid_t ctdb_fork(struct ctdb_context *ctdb);
+pid_t ctdb_fork_no_free_ringbuffer(struct ctdb_context *ctdb);
+void ctdb_set_child_info(TALLOC_CTX *mem_ctx, const char *child_name_fmt, ...);
+bool ctdb_is_child_process(void);
+int ctdb_kill(struct ctdb_context *ctdb, pid_t pid, int signum);
+
int32_t ctdb_control_takeover_ip(struct ctdb_context *ctdb,
struct ctdb_req_control *c,
TDB_DATA indata,
struct ctdb_req_control *c,
TDB_DATA indata,
bool *async_reply);
+int32_t ctdb_control_ipreallocated(struct ctdb_context *ctdb,
+ struct ctdb_req_control *c,
+ bool *async_reply);
int32_t ctdb_control_start_recovery(struct ctdb_context *ctdb,
struct ctdb_req_control *c,
bool *async_reply);
uint32_t uint16_checksum(uint16_t *data, size_t n);
int ctdb_sys_send_arp(const ctdb_sock_addr *addr, const char *iface);
bool ctdb_sys_have_ip(ctdb_sock_addr *addr);
+char *ctdb_sys_find_ifname(ctdb_sock_addr *addr);
bool ctdb_sys_check_iface_exists(const char *iface);
int ctdb_get_peer_pid(const int fd, pid_t *peer_pid);
int ctdb_sys_send_tcp(const ctdb_sock_addr *dest,
const ctdb_sock_addr *src,
uint32_t seq, uint32_t ack, int rst);
-int ctdb_set_public_addresses(struct ctdb_context *ctdb, const char *alist);
+/* Details of a byte range lock */
+struct ctdb_lock_info {
+ ino_t inode;
+ off_t start, end;
+ bool waiting;
+ bool read_only;
+};
+
+char *ctdb_get_process_name(pid_t pid);
+bool ctdb_get_lock_info(pid_t req_pid, struct ctdb_lock_info *lock_info);
+bool ctdb_get_blocker_pid(struct ctdb_lock_info *reqlock, pid_t *blocker_pid);
+
+typedef void (*client_async_callback)(struct ctdb_context *ctdb, uint32_t node_pnn, int32_t res, TDB_DATA outdata, void *callback_data);
+
+int ctdb_set_public_addresses(struct ctdb_context *ctdb, bool check_addresses);
int ctdb_set_single_public_ip(struct ctdb_context *ctdb,
const char *iface,
const char *ip);
int ctdb_set_event_script(struct ctdb_context *ctdb, const char *script);
int ctdb_set_event_script_dir(struct ctdb_context *ctdb, const char *script_dir);
int ctdb_set_notification_script(struct ctdb_context *ctdb, const char *script);
-int ctdb_takeover_run(struct ctdb_context *ctdb, struct ctdb_node_map *nodemap);
+void lcp2_forcerebalance(struct ctdb_context *ctdb, uint32_t pnn);
+int ctdb_takeover_run(struct ctdb_context *ctdb, struct ctdb_node_map *nodemap, client_async_callback fail_callback, void *callback_data);
int32_t ctdb_control_tcp_client(struct ctdb_context *ctdb, uint32_t client_id,
TDB_DATA indata);
int32_t ctdb_control_set_tunable(struct ctdb_context *ctdb, TDB_DATA indata);
int32_t ctdb_control_list_tunables(struct ctdb_context *ctdb, TDB_DATA *outdata);
int32_t ctdb_control_try_delete_records(struct ctdb_context *ctdb, TDB_DATA indata, TDB_DATA *outdata);
+int32_t ctdb_control_receive_records(struct ctdb_context *ctdb, TDB_DATA indata, TDB_DATA *outdata);
int32_t ctdb_control_add_public_address(struct ctdb_context *ctdb, TDB_DATA indata);
int32_t ctdb_control_del_public_address(struct ctdb_context *ctdb, TDB_DATA indata);
void ctdb_block_signal(int signum);
void ctdb_unblock_signal(int signum);
int32_t ctdb_monitoring_mode(struct ctdb_context *ctdb);
+bool ctdb_stopped_monitoring(struct ctdb_context *ctdb);
int ctdb_set_child_logging(struct ctdb_context *ctdb);
void ctdb_lockdown_memory(struct ctdb_context *ctdb);
-typedef void (*client_async_callback)(struct ctdb_context *ctdb, uint32_t node_pnn, int32_t res, TDB_DATA outdata, void *callback_data);
-
struct client_async_data {
enum ctdb_controls opcode;
bool dont_log_errors;
extern int script_log_level;
extern bool fast_start;
+extern const char *ctdbd_pidfile;
int32_t ctdb_control_get_event_script_status(struct ctdb_context *ctdb,
uint32_t call_type,
int ctdb_log_event_script_output(struct ctdb_context *ctdb, char *str, uint16_t len);
int ctdb_ctrl_report_recd_lock_latency(struct ctdb_context *ctdb, struct timeval timeout, double latency);
-int32_t ctdb_control_stop_node(struct ctdb_context *ctdb, struct ctdb_req_control *c, bool *async_reply);
+int32_t ctdb_control_stop_node(struct ctdb_context *ctdb);
int32_t ctdb_control_continue_node(struct ctdb_context *ctdb);
void ctdb_stop_vacuuming(struct ctdb_context *ctdb);
extern int log_ringbuf_size;
+void ctdb_collect_log(struct ctdb_context *ctdb, struct ctdb_get_log_addr *log_addr);
+void ctdb_clear_log(struct ctdb_context *ctdb);
int32_t ctdb_control_get_log(struct ctdb_context *ctdb, TDB_DATA addr);
int32_t ctdb_control_clear_log(struct ctdb_context *ctdb);
-
+void ctdb_log_ringbuffer_free(void);
struct ctdb_log_state *ctdb_fork_with_logging(TALLOC_CTX *mem_ctx,
struct ctdb_context *ctdb,
int ctdb_fetch_with_header_func(struct ctdb_call_info *call);
+int32_t ctdb_control_get_db_statistics(struct ctdb_context *ctdb,
+ uint32_t db_id,
+ TDB_DATA *outdata);
+
+int ctdb_set_db_sticky(struct ctdb_context *ctdb, struct ctdb_db_context *ctdb_db);
+
+/*
+ description for a message to reload all ips via recovery master/daemon
+ */
+struct reloadips_all_reply {
+ uint32_t pnn;
+ uint64_t srvid;
+};
+
+int32_t ctdb_control_reload_public_ips(struct ctdb_context *ctdb, struct ctdb_req_control *c, bool *async_reply);
+
+int ctdb_start_monitoring_interfaces(struct ctdb_context *ctdb);
+
+/* from server/ctdb_lock.c */
+struct lock_request;
+
+int ctdb_lockall_mark_prio(struct ctdb_context *ctdb, uint32_t priority);
+int ctdb_lockall_unmark_prio(struct ctdb_context *ctdb, uint32_t priority);
+
+void ctdb_lock_free_request_context(struct lock_request *lock_req);
+
+struct lock_request *ctdb_lock_record(struct ctdb_db_context *ctdb_db,
+ TDB_DATA key,
+ bool auto_mark,
+ void (*callback)(void *, bool),
+ void *private_data);
+
+struct lock_request *ctdb_lock_db(struct ctdb_db_context *ctdb_db,
+ bool auto_mark,
+ void (*callback)(void *, bool),
+ void *private_data);
+
+struct lock_request *ctdb_lock_alldb_prio(struct ctdb_context *ctdb,
+ uint32_t priority,
+ bool auto_mark,
+ void (*callback)(void *, bool),
+ void *private_data);
+
+struct lock_request *ctdb_lock_alldb(struct ctdb_context *ctdb,
+ bool auto_mark,
+ void (*callback)(void *, bool),
+ void *private_data);
+
#endif
git.samba.org / obnox / ctdb.git / blobdiff