Add a new tunable : DisableIPFailover that when set to non 0

[metze/ctdb/wip.git] / include / ctdb_private.h

diff --git a/include/ctdb_private.h b/include/ctdb_private.h
index 9f62132bbff6251603311ccaecbfcde5866e4a23..5fc583cb6c898ee4892147ac602e07b5c2e6bf05 100644 (file)
--- a/include/ctdb_private.h
+++ b/include/ctdb_private.h
@@ -101,6 +101,7 @@ struct ctdb_tunable {
        uint32_t deterministic_public_ips;
        uint32_t reclock_ping_period;
        uint32_t no_ip_failback;
+       uint32_t disable_ip_failover;
        uint32_t verbose_memory_names;
        uint32_t recd_ping_timeout;
        uint32_t recd_ping_failcount;
@@ -117,6 +118,7 @@ struct ctdb_tunable {
        uint32_t max_queue_depth_drop_msg;
        uint32_t use_status_events_for_monitoring;
        uint32_t allow_unhealthy_db_read;
+       uint32_t stat_history_interval;
 };
 
 /*
@@ -303,10 +305,21 @@ struct ctdb_daemon_data {
 
 #define CTDB_UPDATE_RECLOCK_LATENCY(ctdb, name, counter, value) \
        {                                                                               \
-               if (value > ctdb->statistics.counter)                                   \
-                       ctdb->statistics.counter = value;                               \
-               if (value > ctdb->statistics_current.counter)                           \
-                       ctdb->statistics_current.counter = value;                       \
+               if (value > ctdb->statistics.counter.max)                                       \
+                       ctdb->statistics.counter.max = value;                           \
+               if (value > ctdb->statistics_current.counter.max)                               \
+                       ctdb->statistics_current.counter.max = value;                   \
+                                                                                       \
+               if (ctdb->statistics.counter.num == 0 || value < ctdb->statistics.counter.min)  \
+                       ctdb->statistics.counter.min = value;                           \
+               if (ctdb->statistics_current.counter.num == 0 || value < ctdb->statistics_current.counter.min)  \
+                       ctdb->statistics_current.counter.min = value;                   \
+                                                                                       \
+               ctdb->statistics.counter.total += value;                                        \
+               ctdb->statistics_current.counter.total += value;                                \
+                                                                                       \
+               ctdb->statistics.counter.num++;                                         \
+               ctdb->statistics_current.counter.num++;                                 \
                                                                                        \
                if (ctdb->tunable.reclock_latency_ms != 0) {                            \
                        if (value*1000 > ctdb->tunable.reclock_latency_ms) {            \
@@ -319,10 +332,22 @@ struct ctdb_daemon_data {
 #define CTDB_UPDATE_LATENCY(ctdb, db, operation, counter, t) \
        {                                                                               \
                double l = timeval_elapsed(&t);                                         \
-               if (l > ctdb->statistics.counter)                                       \
-                       ctdb->statistics.counter = l;                                   \
-               if (l > ctdb->statistics_current.counter)                               \
-                       ctdb->statistics_current.counter = l;                           \
+                                                                                       \
+               if (l > ctdb->statistics.counter.max)                                   \
+                       ctdb->statistics.counter.max = l;                               \
+               if (l > ctdb->statistics_current.counter.max)                           \
+                       ctdb->statistics_current.counter.max = l;                       \
+                                                                                       \
+               if (ctdb->statistics.counter.num == 0 || l < ctdb->statistics.counter.min)      \
+                       ctdb->statistics.counter.min = l;                               \
+               if (ctdb->statistics_current.counter.num == 0 || l < ctdb->statistics_current.counter.min)      \
+                       ctdb->statistics_current.counter.min = l;                       \
+                                                                                       \
+               ctdb->statistics.counter.total += l;                                    \
+               ctdb->statistics_current.counter.total += l;                            \
+                                                                                       \
+               ctdb->statistics.counter.num++;                                         \
+               ctdb->statistics_current.counter.num++;                                 \
                                                                                        \
                if (ctdb->tunable.log_latency_ms !=0) {                                 \
                        if (l*1000 > ctdb->tunable.log_latency_ms) {                    \
@@ -334,60 +359,6 @@ struct ctdb_daemon_data {
 
 
 
-/*
-  ctdb statistics information
- */
-struct ctdb_statistics {
-       uint32_t num_clients;
-       uint32_t frozen;
-       uint32_t recovering;
-       uint32_t client_packets_sent;
-       uint32_t client_packets_recv;
-       uint32_t node_packets_sent;
-       uint32_t node_packets_recv;
-       uint32_t keepalive_packets_sent;
-       uint32_t keepalive_packets_recv;
-       struct {
-               uint32_t req_call;
-               uint32_t reply_call;
-               uint32_t req_dmaster;
-               uint32_t reply_dmaster;
-               uint32_t reply_error;
-               uint32_t req_message;
-               uint32_t req_control;
-               uint32_t reply_control;
-       } node;
-       struct {
-               uint32_t req_call;
-               uint32_t req_message;
-               uint32_t req_control;
-       } client;
-       struct {
-               uint32_t call;
-               uint32_t control;
-               uint32_t traverse;
-       } timeouts;
-       struct {
-               double ctdbd;
-               double recd;
-       } reclock;
-       uint32_t total_calls;
-       uint32_t pending_calls;
-       uint32_t lockwait_calls;
-       uint32_t pending_lockwait_calls;
-       uint32_t childwrite_calls;
-       uint32_t pending_childwrite_calls;
-       uint32_t memory_used;
-       uint32_t __last_counter; /* hack for control_statistics_all */
-       uint32_t max_hop_count;
-       double max_call_latency;
-       double max_lockwait_latency;
-       double max_childwrite_latency;
-       uint32_t num_recoveries;
-       struct timeval statistics_start_time;
-       struct timeval statistics_current_time;
-};
-
 
 #define INVALID_GENERATION 1
 /* table that contains the mapping between a hash value and lmaster
@@ -477,12 +448,13 @@ struct ctdb_context {
        struct ctdb_daemon_data daemon;
        struct ctdb_statistics statistics;
        struct ctdb_statistics statistics_current;
+#define MAX_STAT_HISTORY 100
+       struct ctdb_statistics statistics_history[MAX_STAT_HISTORY];
        struct ctdb_vnn_map *vnn_map;
        uint32_t num_clients;
        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;   
        const char *event_script_dir;
        const char *notification_script;
@@ -1395,6 +1367,12 @@ int update_ip_assignment_tree(struct ctdb_context *ctdb,
 
 int ctdb_init_tevent_logging(struct ctdb_context *ctdb);
 
-int ctdb_update_stat_counter(struct ctdb_context *ctdb, uint32_t *counter, uint32_t value);
+int ctdb_statistics_init(struct ctdb_context *ctdb);
+
+int32_t ctdb_control_get_stat_history(struct ctdb_context *ctdb,
+                                     struct ctdb_req_control *c,
+                                     TDB_DATA *outdata);
+
+int ctdb_deferred_drop_all_ips(struct ctdb_context *ctdb);
 
 #endif