Dont allow client processes to attach to databases while we are still in recovery...

[sahlberg/ctdb.git] / include / ctdb_private.h

diff --git a/include/ctdb_private.h b/include/ctdb_private.h
index 6341ab06f97d24bc71d2b6f680af8a051800876b..5a1c15b1827419dfd19b3dbd8d7f8f172fbe6512 100644 (file)
--- a/include/ctdb_private.h
+++ b/include/ctdb_private.h
@@ -82,7 +82,6 @@ struct ctdb_tunable {
        uint32_t traverse_timeout;
        uint32_t keepalive_interval;
        uint32_t keepalive_limit;
-       uint32_t max_lacount;
        uint32_t recover_timeout;
        uint32_t recover_interval;
        uint32_t election_timeout;
@@ -101,6 +100,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 +117,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 +304,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 +331,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) {                    \
@@ -430,8 +454,9 @@ struct ctdb_context {
        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;   
+       struct trbt_tree *server_ids; 
+       bool do_setsched;
+       void *saved_scheduler_param;
        const char *event_script_dir;
        const char *notification_script;
        const char *default_public_interface;
@@ -481,6 +506,9 @@ struct ctdb_db_context {
        bool transaction_active;
        struct ctdb_vacuum_handle *vacuum_handle;
        char *unhealthy_reason;
+       int pending_requests;
+       struct lockwait_handle *lockwait_active;
+       struct lockwait_handle *lockwait_overflow;
 };
 
 
@@ -624,6 +652,7 @@ int ctdb_ltdb_fetch(struct ctdb_db_context *ctdb_db,
                    TALLOC_CTX *mem_ctx, TDB_DATA *data);
 int ctdb_ltdb_store(struct ctdb_db_context *ctdb_db, TDB_DATA key, 
                    struct ctdb_ltdb_header *header, TDB_DATA data);
+int ctdb_ltdb_delete(struct ctdb_db_context *ctdb_db, TDB_DATA key);
 int32_t ctdb_control_start_persistent_update(struct ctdb_context *ctdb, 
                        struct ctdb_req_control *c,
                        TDB_DATA recdata);
@@ -746,8 +775,8 @@ struct ctdb_call_state *ctdb_daemon_call_send_remote(struct ctdb_db_context *ctd
                                                     struct ctdb_ltdb_header *header);
 
 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,
-                   uint32_t caller);
+                   struct ctdb_ltdb_header *header, TALLOC_CTX *mem_ctx,
+                   TDB_DATA *data);
 
 #define ctdb_reqid_find(ctdb, reqid, type)     (type *)_ctdb_reqid_find(ctdb, reqid, #type, __location__)
 
@@ -770,7 +799,7 @@ int ctdb_daemon_send_control(struct ctdb_context *ctdb, uint32_t destnode,
                             void *private_data);
 
 int32_t ctdb_control_db_attach(struct ctdb_context *ctdb, TDB_DATA indata, 
-                              TDB_DATA *outdata, uint64_t tdb_flags, bool persistent);
+                              TDB_DATA *outdata, uint64_t tdb_flags, bool persistent, uint32_t client_id);
 
 int ctdb_daemon_set_call(struct ctdb_context *ctdb, uint32_t db_id,
                         ctdb_fn_t fn, int id);
@@ -811,24 +840,6 @@ int ctdb_control_getnodemap(struct ctdb_context *ctdb, uint32_t opcode, TDB_DATA
 int ctdb_control_writerecord(struct ctdb_context *ctdb, uint32_t opcode, TDB_DATA indata, TDB_DATA *outdata);
 
 
-struct ctdb_traverse_start {
-       uint32_t db_id;
-       uint32_t reqid;
-       uint64_t srvid;
-};
-
-/*
-  structure used to pass record data between the child and parent
- */
-struct ctdb_rec_data {
-       uint32_t length;
-       uint32_t reqid;
-       uint32_t keylen;
-       uint32_t datalen;
-       uint8_t  data[1];
-};
-                                  
-
 /* structure used for pulldb control */
 struct ctdb_control_pulldb {
        uint32_t db_id;
@@ -965,8 +976,9 @@ void ctdb_call_resend_all(struct ctdb_context *ctdb);
 void ctdb_node_dead(struct ctdb_node *node);
 void ctdb_node_connected(struct ctdb_node *node);
 bool ctdb_blocking_freeze(struct ctdb_context *ctdb);
-void ctdb_high_priority(struct ctdb_context *ctdb);
-void ctdb_reduce_priority(struct ctdb_context *ctdb);
+void ctdb_set_scheduler(struct ctdb_context *ctdb);
+void ctdb_restore_scheduler(struct ctdb_context *ctdb);
+pid_t ctdb_fork(struct ctdb_context *ctdb);
 int32_t ctdb_control_takeover_ip(struct ctdb_context *ctdb, 
                                 struct ctdb_req_control *c,
                                 TDB_DATA indata, 
@@ -1348,4 +1360,6 @@ 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