ctdb/protocol/protocol.h

   1 /*
   2    CTDB protocol marshalling
   3
   4    Copyright (C) Amitay Isaacs  2015
   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_PROTOCOL_H__
  21 #define __CTDB_PROTOCOL_H__
  22
  23 #include <tdb.h>
  24
  25 #define CTDB_MAGIC      0x43544442 /* CTDB */
  26 #define CTDB_PROTOCOL   1
  27
  28 enum ctdb_operation {
  29         CTDB_REQ_CALL           = 0,
  30         CTDB_REPLY_CALL         = 1,
  31         CTDB_REQ_DMASTER        = 2,
  32         CTDB_REPLY_DMASTER      = 3,
  33         CTDB_REPLY_ERROR        = 4,
  34         CTDB_REQ_MESSAGE        = 5,
  35         /* #6 removed */
  36         CTDB_REQ_CONTROL        = 7,
  37         CTDB_REPLY_CONTROL      = 8,
  38         CTDB_REQ_KEEPALIVE      = 9,
  39 };
  40
  41 /* used on the domain socket, send a pdu to the local daemon */
  42 #define CTDB_CURRENT_NODE     0xF0000001
  43 /* send a broadcast to all nodes in the cluster, active or not */
  44 #define CTDB_BROADCAST_ALL    0xF0000002
  45 /* send a broadcast to all nodes in the current vnn map */
  46 #define CTDB_BROADCAST_VNNMAP 0xF0000003
  47 /* send a broadcast to all connected nodes */
  48 #define CTDB_BROADCAST_CONNECTED 0xF0000004
  49 /* send a broadcast to selected connected nodes */
  50 #define CTDB_MULTICAST 0xF0000005
  51
  52 #define CTDB_UNKNOWN_PNN        0xFFFFFFFF
  53
  54 /* the key used to store persistent db sequence number */
  55 #define CTDB_DB_SEQNUM_KEY "__db_sequence_number__"
  56
  57 struct ctdb_req_header {
  58         uint32_t length;
  59         uint32_t ctdb_magic;
  60         uint32_t ctdb_version;
  61         uint32_t generation;
  62         uint32_t operation;
  63         uint32_t destnode;
  64         uint32_t srcnode;
  65         uint32_t reqid;
  66 };
  67
  68 struct ctdb_req_call {
  69         uint32_t flags;
  70         uint32_t db_id;
  71         uint32_t callid;
  72         uint32_t hopcount;
  73         TDB_DATA key;
  74         TDB_DATA calldata;
  75 };
  76
  77 struct ctdb_reply_call {
  78         int32_t status;
  79         TDB_DATA data;
  80 };
  81
  82 struct ctdb_reply_error {
  83         int32_t status;
  84         TDB_DATA msg;
  85 };
  86
  87 struct ctdb_req_dmaster {
  88         uint32_t db_id;
  89         uint64_t rsn;
  90         uint32_t dmaster;
  91         TDB_DATA key;
  92         TDB_DATA data;
  93 };
  94
  95 struct ctdb_reply_dmaster {
  96         uint32_t db_id;
  97         uint64_t rsn;
  98         TDB_DATA key;
  99         TDB_DATA data;
 100 };
 101
 102 #define CTDB_NULL_FUNC                  0xFF000001
 103 #define CTDB_FETCH_FUNC                 0xFF000002
 104 #define CTDB_FETCH_WITH_HEADER_FUNC     0xFF000003
 105
 106 struct ctdb_call {
 107         int call_id;
 108         TDB_DATA key;
 109         TDB_DATA call_data;
 110         TDB_DATA reply_data;
 111         uint32_t status;
 112 #define CTDB_IMMEDIATE_MIGRATION                0x00000001
 113 #define CTDB_CALL_FLAG_VACUUM_MIGRATION         0x00000002
 114 #define CTDB_WANT_READONLY                      0x00000004
 115         uint32_t flags;
 116 };
 117
 118 /* SRVID to catch all messages */
 119 #define CTDB_SRVID_ALL (~(uint64_t)0)
 120
 121 /* SRVID prefix used by CTDB */
 122 #define CTDB_SRVID_PREFIX       0xF000000000000000LL
 123
 124 /* SRVID to inform of election data */
 125 #define CTDB_SRVID_ELECTION     0xF100000000000000LL
 126
 127 /* SRVID to inform clients that the cluster has been reconfigured */
 128 #define CTDB_SRVID_RECONFIGURE 0xF200000000000000LL
 129
 130 /* SRVID to inform clients an IP address has been released */
 131 #define CTDB_SRVID_RELEASE_IP 0xF300000000000000LL
 132
 133 /* SRVID to inform clients that an IP address has been taken over */
 134 #define CTDB_SRVID_TAKE_IP 0xF301000000000000LL
 135
 136 /* SRVID to inform recovery daemon of the node flags */
 137 #define CTDB_SRVID_SET_NODE_FLAGS 0xF400000000000000LL
 138
 139 /* SRVID to inform recovery daemon to update public ip assignment */
 140 #define CTDB_SRVID_RECD_UPDATE_IP 0xF500000000000000LL
 141
 142 /* SRVID to inform recovery daemon to migrate a set of records */
 143 #define CTDB_SRVID_VACUUM_FETCH 0xF700000000000000LL
 144
 145 /* SRVID to inform recovery daemon to detach a database */
 146 #define CTDB_SRVID_DETACH_DATABASE 0xF701000000000000LL
 147
 148 /* SRVID to inform recovery daemon to dump talloc memdump to the log */
 149 #define CTDB_SRVID_MEM_DUMP 0xF800000000000000LL
 150
 151 /* SRVID to inform recovery daemon to send logs */
 152 #define CTDB_SRVID_GETLOG  0xF801000000000000LL
 153
 154 /* SRVID to inform recovery daemon to clear logs */
 155 #define CTDB_SRVID_CLEARLOG  0xF802000000000000LL
 156
 157 /* SRVID to inform recovery daemon to push the node flags to other nodes */
 158 #define CTDB_SRVID_PUSH_NODE_FLAGS 0xF900000000000000LL
 159
 160 /* SRVID to inform recovery daemon to reload the nodes file */
 161 #define CTDB_SRVID_RELOAD_NODES 0xFA00000000000000LL
 162
 163 /* SRVID to inform recovery daemon to perform a takeover run */
 164 #define CTDB_SRVID_TAKEOVER_RUN 0xFB00000000000000LL
 165
 166 /* SRVID to inform recovery daemon to rebalance ips for a node.  */
 167 #define CTDB_SRVID_REBALANCE_NODE 0xFB01000000000000LL
 168
 169 /* SRVID to inform recovery daemon to stop takeover runs from occurring */
 170 #define CTDB_SRVID_DISABLE_TAKEOVER_RUNS 0xFB03000000000000LL
 171
 172 /* SRVID to inform recovery daemon to stop recoveries from occurring */
 173 #define CTDB_SRVID_DISABLE_RECOVERIES 0xFB04000000000000LL
 174
 175 /* SRVID to inform recovery daemon to disable the public ip checks */
 176 #define CTDB_SRVID_DISABLE_IP_CHECK  0xFC00000000000000LL
 177
 178 /* SRVID to inform recovery daemon of ipreallocate resposnes from ctdbd */
 179 #define CTDB_SRVID_TAKEOVER_RUN_RESPONSE  0xFD00000000000000LL
 180
 181 /* A range of ports reserved for registering a PID (top 8 bits)
 182  * All ports matching the 8 top bits are reserved for exclusive use by
 183  * registering a SRVID that matches the process-id of the requesting process
 184  */
 185 #define CTDB_SRVID_PID_RANGE   0x0000000000000000LL
 186
 187 /* A range of ports reserved for samba (top 8 bits)
 188  * All ports matching the 8 top bits are reserved for exclusive use by
 189  * CIFS server
 190  */
 191 #define CTDB_SRVID_SAMBA_NOTIFY  0xFE00000000000000LL
 192 #define CTDB_SRVID_SAMBA_RANGE   0xFE00000000000000LL
 193
 194 /* A range of ports reserved for a CTDB NFS server (top 8 bits)
 195  * All ports matching the 8 top bits are reserved for exclusive use by
 196  * NFS server
 197  */
 198 #define CTDB_SRVID_NFSD_RANGE  0xEE00000000000000LL
 199
 200 /* A range of ports reserved for a CTDB ISCSI server (top 8 bits)
 201  * All ports matching the 8 top bits are reserved for exclusive use by
 202  * ISCSI server
 203  */
 204 #define CTDB_SRVID_ISCSID_RANGE  0xDE00000000000000LL
 205
 206 /* A range of ports reserved for testing (top 8 bits)
 207  * All ports matching the 8 top bits are reserved for exclusive use by
 208  * test applications
 209  */
 210 #define CTDB_SRVID_TEST_RANGE  0xCE00000000000000LL
 211
 212 /* Range of ports reserved for traversals */
 213 #define CTDB_SRVID_TRAVERSE_RANGE  0xBE00000000000000LL
 214
 215
 216 enum ctdb_controls {CTDB_CONTROL_PROCESS_EXISTS          = 0,
 217                     CTDB_CONTROL_STATISTICS              = 1,
 218                     /* #2 removed */
 219                     CTDB_CONTROL_PING                    = 3,
 220                     CTDB_CONTROL_GETDBPATH               = 4,
 221                     CTDB_CONTROL_GETVNNMAP               = 5,
 222                     CTDB_CONTROL_SETVNNMAP               = 6,
 223                     CTDB_CONTROL_GET_DEBUG               = 7,
 224                     CTDB_CONTROL_SET_DEBUG               = 8,
 225                     CTDB_CONTROL_GET_DBMAP               = 9,
 226                     CTDB_CONTROL_GET_NODEMAPv4           = 10, /* obsolete */
 227                     CTDB_CONTROL_SET_DMASTER             = 11, /* obsolete */
 228                     /* #12 removed */
 229                     CTDB_CONTROL_PULL_DB                 = 13,
 230                     CTDB_CONTROL_PUSH_DB                 = 14,
 231                     CTDB_CONTROL_GET_RECMODE             = 15,
 232                     CTDB_CONTROL_SET_RECMODE             = 16,
 233                     CTDB_CONTROL_STATISTICS_RESET        = 17,
 234                     CTDB_CONTROL_DB_ATTACH               = 18,
 235                     CTDB_CONTROL_SET_CALL                = 19, /* obsolete */
 236                     CTDB_CONTROL_TRAVERSE_START          = 20,
 237                     CTDB_CONTROL_TRAVERSE_ALL            = 21,
 238                     CTDB_CONTROL_TRAVERSE_DATA           = 22,
 239                     CTDB_CONTROL_REGISTER_SRVID          = 23,
 240                     CTDB_CONTROL_DEREGISTER_SRVID        = 24,
 241                     CTDB_CONTROL_GET_DBNAME              = 25,
 242                     CTDB_CONTROL_ENABLE_SEQNUM           = 26,
 243                     CTDB_CONTROL_UPDATE_SEQNUM           = 27,
 244                     /* #28 removed */
 245                     CTDB_CONTROL_DUMP_MEMORY             = 29,
 246                     CTDB_CONTROL_GET_PID                 = 30,
 247                     CTDB_CONTROL_GET_RECMASTER           = 31,
 248                     CTDB_CONTROL_SET_RECMASTER           = 32,
 249                     CTDB_CONTROL_FREEZE                  = 33,
 250                     CTDB_CONTROL_THAW                    = 34,
 251                     CTDB_CONTROL_GET_PNN                 = 35,
 252                     CTDB_CONTROL_SHUTDOWN                = 36,
 253                     CTDB_CONTROL_GET_MONMODE             = 37,
 254                     /* #38 removed */
 255                     /* #39 removed */
 256                     /* #40 removed */
 257                     /* #41 removed */
 258                     CTDB_CONTROL_TAKEOVER_IPv4           = 42, /* obsolete */
 259                     CTDB_CONTROL_RELEASE_IPv4            = 43, /* obsolete */
 260                     CTDB_CONTROL_TCP_CLIENT              = 44,
 261                     CTDB_CONTROL_TCP_ADD                 = 45,
 262                     CTDB_CONTROL_TCP_REMOVE              = 46,
 263                     CTDB_CONTROL_STARTUP                 = 47,
 264                     CTDB_CONTROL_SET_TUNABLE             = 48,
 265                     CTDB_CONTROL_GET_TUNABLE             = 49,
 266                     CTDB_CONTROL_LIST_TUNABLES           = 50,
 267                     CTDB_CONTROL_GET_PUBLIC_IPSv4        = 51, /* obsolete */
 268                     CTDB_CONTROL_MODIFY_FLAGS            = 52,
 269                     CTDB_CONTROL_GET_ALL_TUNABLES        = 53,
 270                     CTDB_CONTROL_KILL_TCP                = 54,
 271                     CTDB_CONTROL_GET_TCP_TICKLE_LIST     = 55,
 272                     CTDB_CONTROL_SET_TCP_TICKLE_LIST     = 56,
 273                     CTDB_CONTROL_REGISTER_SERVER_ID      = 57,
 274                     CTDB_CONTROL_UNREGISTER_SERVER_ID    = 58,
 275                     CTDB_CONTROL_CHECK_SERVER_ID         = 59,
 276                     CTDB_CONTROL_GET_SERVER_ID_LIST      = 60,
 277                     CTDB_CONTROL_DB_ATTACH_PERSISTENT    = 61,
 278                     CTDB_CONTROL_PERSISTENT_STORE        = 62, /* obsolete */
 279                     CTDB_CONTROL_UPDATE_RECORD           = 63,
 280                     CTDB_CONTROL_SEND_GRATUITOUS_ARP     = 64,
 281                     CTDB_CONTROL_TRANSACTION_START       = 65,
 282                     CTDB_CONTROL_TRANSACTION_COMMIT      = 66,
 283                     CTDB_CONTROL_WIPE_DATABASE           = 67,
 284                     /* #68 removed */
 285                     CTDB_CONTROL_UPTIME                  = 69,
 286                     CTDB_CONTROL_START_RECOVERY          = 70,
 287                     CTDB_CONTROL_END_RECOVERY            = 71,
 288                     CTDB_CONTROL_RELOAD_NODES_FILE       = 72,
 289                     /* #73 removed */
 290                     CTDB_CONTROL_TRY_DELETE_RECORDS      = 74,
 291                     CTDB_CONTROL_ENABLE_MONITOR          = 75,
 292                     CTDB_CONTROL_DISABLE_MONITOR         = 76,
 293                     CTDB_CONTROL_ADD_PUBLIC_IP           = 77,
 294                     CTDB_CONTROL_DEL_PUBLIC_IP           = 78,
 295                     CTDB_CONTROL_RUN_EVENTSCRIPTS        = 79,
 296                     CTDB_CONTROL_GET_CAPABILITIES        = 80,
 297                     CTDB_CONTROL_START_PERSISTENT_UPDATE = 81, /* obsolete */
 298                     CTDB_CONTROL_CANCEL_PERSISTENT_UPDATE= 82, /* obsolete */
 299                     CTDB_CONTROL_TRANS2_COMMIT           = 83, /* obsolete */
 300                     CTDB_CONTROL_TRANS2_FINISHED         = 84, /* obsolete */
 301                     CTDB_CONTROL_TRANS2_ERROR            = 85, /* obsolete */
 302                     CTDB_CONTROL_TRANS2_COMMIT_RETRY     = 86, /* obsolete */
 303                     CTDB_CONTROL_RECD_PING               = 87,
 304                     CTDB_CONTROL_RELEASE_IP              = 88,
 305                     CTDB_CONTROL_TAKEOVER_IP             = 89,
 306                     CTDB_CONTROL_GET_PUBLIC_IPS          = 90,
 307                     CTDB_CONTROL_GET_NODEMAP             = 91,
 308                     /* missing */
 309                     CTDB_CONTROL_GET_EVENT_SCRIPT_STATUS = 96,
 310                     CTDB_CONTROL_TRAVERSE_KILL           = 97,
 311                     CTDB_CONTROL_RECD_RECLOCK_LATENCY    = 98,
 312                     CTDB_CONTROL_GET_RECLOCK_FILE        = 99,
 313                     CTDB_CONTROL_SET_RECLOCK_FILE        = 100,
 314                     CTDB_CONTROL_STOP_NODE               = 101,
 315                     CTDB_CONTROL_CONTINUE_NODE           = 102,
 316                     CTDB_CONTROL_SET_NATGWSTATE          = 103, /* obsolete */
 317                     CTDB_CONTROL_SET_LMASTERROLE         = 104,
 318                     CTDB_CONTROL_SET_RECMASTERROLE       = 105,
 319                     CTDB_CONTROL_ENABLE_SCRIPT           = 107,
 320                     CTDB_CONTROL_DISABLE_SCRIPT          = 108,
 321                     CTDB_CONTROL_SET_BAN_STATE           = 109,
 322                     CTDB_CONTROL_GET_BAN_STATE           = 110,
 323                     CTDB_CONTROL_SET_DB_PRIORITY         = 111,
 324                     CTDB_CONTROL_GET_DB_PRIORITY         = 112,
 325                     CTDB_CONTROL_TRANSACTION_CANCEL      = 113,
 326                     CTDB_CONTROL_REGISTER_NOTIFY         = 114,
 327                     CTDB_CONTROL_DEREGISTER_NOTIFY       = 115,
 328                     CTDB_CONTROL_TRANS2_ACTIVE           = 116, /* obsolete */
 329                     CTDB_CONTROL_GET_LOG                 = 117, /* obsolete */
 330                     CTDB_CONTROL_CLEAR_LOG               = 118, /* obsolete */
 331                     CTDB_CONTROL_TRANS3_COMMIT           = 119,
 332                     CTDB_CONTROL_GET_DB_SEQNUM           = 120,
 333                     CTDB_CONTROL_DB_SET_HEALTHY          = 121,
 334                     CTDB_CONTROL_DB_GET_HEALTH           = 122,
 335                     CTDB_CONTROL_GET_PUBLIC_IP_INFO      = 123,
 336                     CTDB_CONTROL_GET_IFACES              = 124,
 337                     CTDB_CONTROL_SET_IFACE_LINK_STATE    = 125,
 338                     CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE  = 126,
 339                     CTDB_CONTROL_GET_STAT_HISTORY        = 127,
 340                     CTDB_CONTROL_SCHEDULE_FOR_DELETION   = 128,
 341                     CTDB_CONTROL_SET_DB_READONLY         = 129,
 342                     CTDB_CONTROL_CHECK_SRVIDS            = 130,
 343                     CTDB_CONTROL_TRAVERSE_START_EXT      = 131,
 344                     CTDB_CONTROL_GET_DB_STATISTICS       = 132,
 345                     CTDB_CONTROL_SET_DB_STICKY           = 133,
 346                     CTDB_CONTROL_RELOAD_PUBLIC_IPS       = 134,
 347                     CTDB_CONTROL_TRAVERSE_ALL_EXT        = 135,
 348                     CTDB_CONTROL_RECEIVE_RECORDS         = 136,
 349                     CTDB_CONTROL_IPREALLOCATED           = 137,
 350                     CTDB_CONTROL_GET_RUNSTATE            = 138,
 351                     CTDB_CONTROL_DB_DETACH               = 139,
 352                     CTDB_CONTROL_GET_NODES_FILE          = 140,
 353                     CTDB_CONTROL_DB_FREEZE               = 141,
 354                     CTDB_CONTROL_DB_THAW                 = 142,
 355                     CTDB_CONTROL_DB_TRANSACTION_START    = 143,
 356                     CTDB_CONTROL_DB_TRANSACTION_COMMIT   = 144,
 357                     CTDB_CONTROL_DB_TRANSACTION_CANCEL   = 145,
 358 };
 359
 360 #define CTDB_MONITORING_ACTIVE          0
 361 #define CTDB_MONITORING_DISABLED        1
 362
 363 #define MAX_COUNT_BUCKETS 16
 364 #define MAX_HOT_KEYS      10
 365
 366 struct ctdb_latency_counter {
 367         int num;
 368         double min;
 369         double max;
 370         double total;
 371 };
 372
 373 struct ctdb_statistics {
 374         uint32_t num_clients;
 375         uint32_t frozen;
 376         uint32_t recovering;
 377         uint32_t client_packets_sent;
 378         uint32_t client_packets_recv;
 379         uint32_t node_packets_sent;
 380         uint32_t node_packets_recv;
 381         uint32_t keepalive_packets_sent;
 382         uint32_t keepalive_packets_recv;
 383         struct {
 384                 uint32_t req_call;
 385                 uint32_t reply_call;
 386                 uint32_t req_dmaster;
 387                 uint32_t reply_dmaster;
 388                 uint32_t reply_error;
 389                 uint32_t req_message;
 390                 uint32_t req_control;
 391                 uint32_t reply_control;
 392         } node;
 393         struct {
 394                 uint32_t req_call;
 395                 uint32_t req_message;
 396                 uint32_t req_control;
 397         } client;
 398         struct {
 399                 uint32_t call;
 400                 uint32_t control;
 401                 uint32_t traverse;
 402         } timeouts;
 403         struct {
 404                 struct ctdb_latency_counter ctdbd;
 405                 struct ctdb_latency_counter recd;
 406         } reclock;
 407         struct {
 408                 uint32_t num_calls;
 409                 uint32_t num_current;
 410                 uint32_t num_pending;
 411                 uint32_t num_failed;
 412                 struct ctdb_latency_counter latency;
 413                 uint32_t buckets[MAX_COUNT_BUCKETS];
 414         } locks;
 415         uint32_t total_calls;
 416         uint32_t pending_calls;
 417         uint32_t childwrite_calls;
 418         uint32_t pending_childwrite_calls;
 419         uint32_t memory_used;
 420         uint32_t __last_counter; /* hack */
 421         uint32_t max_hop_count;
 422         uint32_t hop_count_bucket[MAX_COUNT_BUCKETS];
 423         struct ctdb_latency_counter call_latency;
 424         struct ctdb_latency_counter childwrite_latency;
 425         uint32_t num_recoveries;
 426         struct timeval statistics_start_time;
 427         struct timeval statistics_current_time;
 428         uint32_t total_ro_delegations;
 429         uint32_t total_ro_revokes;
 430 };
 431
 432 #define INVALID_GENERATION 1
 433 /* table that contains the mapping between a hash value and lmaster
 434  */
 435 struct ctdb_vnn_map {
 436         uint32_t generation;
 437         uint32_t size;
 438         uint32_t *map;
 439 };
 440
 441 struct ctdb_dbid {
 442         uint32_t db_id;
 443 #define CTDB_DB_FLAGS_PERSISTENT        0x01
 444 #define CTDB_DB_FLAGS_READONLY          0x02
 445 #define CTDB_DB_FLAGS_STICKY            0x04
 446         uint8_t flags;
 447 };
 448
 449 struct ctdb_dbid_map {
 450         uint32_t num;
 451         struct ctdb_dbid *dbs;
 452 };
 453
 454 struct ctdb_pulldb {
 455         uint32_t db_id;
 456 #define CTDB_LMASTER_ANY        0xffffffff
 457         uint32_t lmaster;
 458 };
 459
 460 #define CTDB_RECOVERY_NORMAL            0
 461 #define CTDB_RECOVERY_ACTIVE            1
 462
 463 #define CTDB_NUM_DB_PRIORITIES          3
 464
 465 /*
 466   the extended header for records in the ltdb
 467 */
 468 struct ctdb_ltdb_header {
 469         uint64_t rsn;
 470         uint32_t dmaster;
 471         uint32_t reserved1;
 472 #define CTDB_REC_FLAG_DEFAULT                   0x00000000
 473 #define CTDB_REC_FLAG_MIGRATED_WITH_DATA        0x00010000
 474 #define CTDB_REC_FLAG_VACUUM_MIGRATED           0x00020000
 475 #define CTDB_REC_FLAG_AUTOMATIC                 0x00040000
 476 #define CTDB_REC_RO_HAVE_DELEGATIONS            0x01000000
 477 #define CTDB_REC_RO_HAVE_READONLY               0x02000000
 478 #define CTDB_REC_RO_REVOKING_READONLY           0x04000000
 479 #define CTDB_REC_RO_REVOKE_COMPLETE             0x08000000
 480 #define CTDB_REC_RO_FLAGS                       (CTDB_REC_RO_HAVE_DELEGATIONS|\
 481                                                  CTDB_REC_RO_HAVE_READONLY|\
 482                                                  CTDB_REC_RO_REVOKING_READONLY|\
 483                                                  CTDB_REC_RO_REVOKE_COMPLETE)
 484         uint32_t flags;
 485 };
 486
 487 struct ctdb_rec_data {
 488         uint32_t reqid;
 489         struct ctdb_ltdb_header *header;
 490         TDB_DATA key, data;
 491 };
 492
 493 struct ctdb_rec_buffer {
 494         uint32_t db_id;
 495         uint32_t count;
 496         uint8_t *buf;
 497         size_t buflen;
 498 };
 499
 500 typedef int (*ctdb_rec_parser_func_t)(uint32_t reqid,
 501                                       struct ctdb_ltdb_header *header,
 502                                       TDB_DATA key, TDB_DATA data,
 503                                       void *private_data);
 504
 505 struct ctdb_traverse_start {
 506         uint32_t db_id;
 507         uint32_t reqid;
 508         uint64_t srvid;
 509 };
 510
 511 struct ctdb_traverse_all {
 512         uint32_t db_id;
 513         uint32_t reqid;
 514         uint32_t pnn;
 515         uint32_t client_reqid;
 516         uint64_t srvid;
 517 };
 518
 519 struct ctdb_traverse_start_ext {
 520         uint32_t db_id;
 521         uint32_t reqid;
 522         uint64_t srvid;
 523         bool withemptyrecords;
 524 };
 525
 526 struct ctdb_traverse_all_ext {
 527         uint32_t db_id;
 528         uint32_t reqid;
 529         uint32_t pnn;
 530         uint32_t client_reqid;
 531         uint64_t srvid;
 532         bool withemptyrecords;
 533 };
 534
 535 typedef union {
 536         struct sockaddr sa;
 537         struct sockaddr_in ip;
 538         struct sockaddr_in6 ip6;
 539 } ctdb_sock_addr;
 540
 541 struct ctdb_connection {
 542         ctdb_sock_addr src;
 543         ctdb_sock_addr dst;
 544 };
 545
 546 struct ctdb_tunable {
 547         const char *name;
 548         uint32_t value;
 549 };
 550
 551 struct ctdb_var_list {
 552         int count;
 553         const char **var;
 554 };
 555
 556 struct ctdb_node_flag_change {
 557         uint32_t pnn;
 558         uint32_t new_flags;
 559         uint32_t old_flags;
 560 };
 561
 562 /* all tunable variables go in here */
 563 struct ctdb_tunable_list {
 564         uint32_t max_redirect_count;
 565         uint32_t seqnum_interval; /* unit is ms */
 566         uint32_t control_timeout;
 567         uint32_t traverse_timeout;
 568         uint32_t keepalive_interval;
 569         uint32_t keepalive_limit;
 570         uint32_t recover_timeout;
 571         uint32_t recover_interval;
 572         uint32_t election_timeout;
 573         uint32_t takeover_timeout;
 574         uint32_t monitor_interval;
 575         uint32_t tickle_update_interval;
 576         uint32_t script_timeout;
 577         uint32_t monitor_timeout_count; /* allow dodgy scripts to hang this many times in a row before we mark the node unhealthy */
 578         uint32_t script_unhealthy_on_timeout; /* obsolete */
 579         uint32_t recovery_grace_period;
 580         uint32_t recovery_ban_period;
 581         uint32_t database_hash_size;
 582         uint32_t database_max_dead;
 583         uint32_t rerecovery_timeout;
 584         uint32_t enable_bans;
 585         uint32_t deterministic_public_ips;
 586         uint32_t reclock_ping_period;
 587         uint32_t no_ip_failback;
 588         uint32_t disable_ip_failover;
 589         uint32_t verbose_memory_names;
 590         uint32_t recd_ping_timeout;
 591         uint32_t recd_ping_failcount;
 592         uint32_t log_latency_ms;
 593         uint32_t reclock_latency_ms;
 594         uint32_t recovery_drop_all_ips;
 595         uint32_t verify_recovery_lock;
 596         uint32_t vacuum_interval;
 597         uint32_t vacuum_max_run_time;
 598         uint32_t repack_limit;
 599         uint32_t vacuum_limit;
 600         uint32_t max_queue_depth_drop_msg;
 601         uint32_t allow_unhealthy_db_read;
 602         uint32_t stat_history_interval;
 603         uint32_t deferred_attach_timeout;
 604         uint32_t vacuum_fast_path_count;
 605         uint32_t lcp2_public_ip_assignment;
 606         uint32_t allow_client_db_attach;
 607         uint32_t recover_pdb_by_seqnum;
 608         uint32_t deferred_rebalance_on_node_add;
 609         uint32_t fetch_collapse;
 610         uint32_t hopcount_make_sticky;
 611         uint32_t sticky_duration;
 612         uint32_t sticky_pindown;
 613         uint32_t no_ip_takeover;
 614         uint32_t db_record_count_warn;
 615         uint32_t db_record_size_warn;
 616         uint32_t db_size_warn;
 617         uint32_t pulldb_preallocation_size;
 618         uint32_t no_ip_host_on_all_disabled;
 619         uint32_t samba3_hack;
 620         uint32_t mutex_enabled;
 621         uint32_t lock_processes_per_db;
 622         uint32_t rec_buffer_size_limit;
 623 };
 624
 625 struct ctdb_tickle_list {
 626         ctdb_sock_addr addr;
 627         uint32_t num;
 628         struct ctdb_connection *conn;
 629 };
 630
 631 enum ctdb_client_type {
 632         SERVER_TYPE_CTDB = 0,
 633         SERVER_TYPE_SAMBA = 1,
 634         SERVER_TYPE_NFSD = 2,
 635         SERVER_TYPE_ISCSID = 3
 636 };
 637
 638 struct ctdb_client_id {
 639         enum ctdb_client_type type;
 640         uint32_t pnn;
 641         uint32_t server_id;
 642 };
 643
 644 struct ctdb_client_id_list {
 645         uint32_t num;
 646         struct ctdb_client_id *cid;
 647 };
 648
 649 struct ctdb_client_id_map {
 650         int count;
 651         struct ctdb_client_id_list *list;
 652 };
 653
 654 struct ctdb_addr_info {
 655         ctdb_sock_addr addr;
 656         uint32_t mask;
 657         const char *iface;
 658 };
 659
 660 struct ctdb_transdb {
 661         uint32_t db_id;
 662         uint32_t tid;
 663 };
 664
 665 struct ctdb_uptime {
 666         struct timeval current_time;
 667         struct timeval ctdbd_start_time;
 668         struct timeval last_recovery_started;
 669         struct timeval last_recovery_finished;
 670 };
 671
 672 struct ctdb_public_ip {
 673         uint32_t pnn;
 674         ctdb_sock_addr addr;
 675 };
 676
 677 struct ctdb_public_ip_list {
 678         uint32_t num;
 679         struct ctdb_public_ip *ip;
 680 };
 681
 682 /*
 683  * Node flags
 684  */
 685 #define NODE_FLAGS_DISCONNECTED         0x00000001 /* node isn't connected */
 686 #define NODE_FLAGS_UNHEALTHY            0x00000002 /* monitoring says node is unhealthy */
 687 #define NODE_FLAGS_PERMANENTLY_DISABLED 0x00000004 /* administrator has disabled node */
 688 #define NODE_FLAGS_BANNED               0x00000008 /* recovery daemon has banned the node */
 689 #define NODE_FLAGS_DELETED              0x00000010 /* this node has been deleted */
 690 #define NODE_FLAGS_STOPPED              0x00000020 /* this node has been stopped */
 691 #define NODE_FLAGS_DISABLED             (NODE_FLAGS_UNHEALTHY|NODE_FLAGS_PERMANENTLY_DISABLED)
 692 #define NODE_FLAGS_INACTIVE             (NODE_FLAGS_DELETED|NODE_FLAGS_DISCONNECTED|NODE_FLAGS_BANNED|NODE_FLAGS_STOPPED)
 693
 694 /*
 695  * Node capabilities
 696  */
 697 #define CTDB_CAP_RECMASTER              0x00000001
 698 #define CTDB_CAP_LMASTER                0x00000002
 699 /* This capability is set if CTDB_LVS_PUBLIC_IP is set */
 700 #define CTDB_CAP_LVS                    0x00000004
 701 #define CTDB_CAP_NATGW                  0x00000008 /* obsolete */
 702
 703 /*
 704  * Node features
 705  */
 706 #define CTDB_CAP_PARALLEL_RECOVERY      0x00010000
 707
 708 #define CTDB_CAP_FEATURES               (CTDB_CAP_PARALLEL_RECOVERY)
 709
 710 #define CTDB_CAP_DEFAULT                (CTDB_CAP_RECMASTER | \
 711                                          CTDB_CAP_LMASTER   | \
 712                                          CTDB_CAP_FEATURES)
 713
 714 struct ctdb_node_and_flags {
 715         uint32_t pnn;
 716         uint32_t flags;
 717         ctdb_sock_addr addr;
 718 };
 719
 720 struct ctdb_node_map {
 721         uint32_t num;
 722         struct ctdb_node_and_flags *node;
 723 };
 724
 725 enum ctdb_event {
 726         CTDB_EVENT_INIT,                /* CTDB starting up: no args */
 727         CTDB_EVENT_SETUP,               /* CTDB starting up after transport is readdy: no args. */
 728         CTDB_EVENT_STARTUP,             /* CTDB starting up after initial recovery: no args. */
 729         CTDB_EVENT_START_RECOVERY,      /* CTDB recovery starting: no args. */
 730         CTDB_EVENT_RECOVERED,           /* CTDB recovery finished: no args. */
 731         CTDB_EVENT_TAKE_IP,             /* IP taken: interface, IP address, netmask bits. */
 732         CTDB_EVENT_RELEASE_IP,          /* IP released: interface, IP address, netmask bits. */
 733         CTDB_EVENT_STOPPED,             /* Deprecated, do not use. */
 734         CTDB_EVENT_MONITOR,             /* Please check if service is healthy: no args. */
 735         CTDB_EVENT_STATUS,              /* Deprecated, do not use. */
 736         CTDB_EVENT_SHUTDOWN,            /* CTDB shutting down: no args. */
 737         CTDB_EVENT_RELOAD,              /* Deprecated, do not use */
 738         CTDB_EVENT_UPDATE_IP,           /* IP updating: old interface, new interface, IP address, netmask bits. */
 739         CTDB_EVENT_IPREALLOCATED,       /* when a takeover_run() completes */
 740         CTDB_EVENT_MAX
 741 };
 742
 743 #define MAX_SCRIPT_NAME 31
 744 #define MAX_SCRIPT_OUTPUT 511
 745
 746 struct ctdb_script {
 747         char name[MAX_SCRIPT_NAME+1];
 748         struct timeval start;
 749         struct timeval finished;
 750         int32_t status;
 751         char output[MAX_SCRIPT_OUTPUT+1];
 752 };
 753
 754 struct ctdb_script_list {
 755         uint32_t num_scripts;
 756         struct ctdb_script *script;
 757 };
 758
 759 struct ctdb_ban_state {
 760         uint32_t pnn;
 761         uint32_t time;
 762 };
 763
 764 struct ctdb_db_priority {
 765         uint32_t db_id;
 766         uint32_t priority;
 767 };
 768
 769 struct ctdb_notify_data {
 770         uint64_t srvid;
 771         TDB_DATA data;
 772 };
 773
 774 #ifdef IFNAMSIZ
 775 #define CTDB_IFACE_SIZE IFNAMSIZ
 776 #else
 777 #define CTDB_IFACE_SIZE 16
 778 #endif
 779
 780 struct ctdb_iface {
 781         char name[CTDB_IFACE_SIZE+2];
 782         uint16_t link_state;
 783         uint32_t references;
 784 };
 785
 786 struct ctdb_iface_list {
 787         uint32_t num;
 788         struct ctdb_iface *iface;
 789 };
 790
 791 struct ctdb_public_ip_info {
 792         struct ctdb_public_ip ip;
 793         uint32_t active_idx;
 794         struct ctdb_iface_list *ifaces;
 795 };
 796
 797 struct ctdb_statistics_list {
 798         int num;
 799         struct ctdb_statistics *stats;
 800 };
 801
 802 struct ctdb_key_data {
 803         uint32_t db_id;
 804         struct ctdb_ltdb_header header;
 805         TDB_DATA key;
 806 };
 807
 808 struct ctdb_uint8_array {
 809         int num;
 810         uint8_t *val;
 811 };
 812
 813 struct ctdb_uint64_array {
 814         int num;
 815         uint64_t *val;
 816 };
 817
 818 struct ctdb_db_statistics {
 819         struct {
 820                 uint32_t num_calls;
 821                 uint32_t num_current;
 822                 uint32_t num_pending;
 823                 uint32_t num_failed;
 824                 struct ctdb_latency_counter latency;
 825                 uint32_t buckets[MAX_COUNT_BUCKETS];
 826         } locks;
 827         struct {
 828                 struct ctdb_latency_counter latency;
 829         } vacuum;
 830         uint32_t db_ro_delegations;
 831         uint32_t db_ro_revokes;
 832         uint32_t hop_count_bucket[MAX_COUNT_BUCKETS];
 833         uint32_t num_hot_keys;
 834         struct {
 835                 uint32_t count;
 836                 TDB_DATA key;
 837         } hot_keys[MAX_HOT_KEYS];
 838 };
 839
 840 enum ctdb_runstate {
 841         CTDB_RUNSTATE_UNKNOWN,
 842         CTDB_RUNSTATE_INIT,
 843         CTDB_RUNSTATE_SETUP,
 844         CTDB_RUNSTATE_FIRST_RECOVERY,
 845         CTDB_RUNSTATE_STARTUP,
 846         CTDB_RUNSTATE_RUNNING,
 847         CTDB_RUNSTATE_SHUTDOWN,
 848 };
 849
 850 struct ctdb_req_control_data {
 851         uint32_t opcode;
 852         union {
 853                 pid_t pid;
 854                 uint32_t db_id;
 855                 struct ctdb_vnn_map *vnnmap;
 856                 uint32_t loglevel;
 857                 struct ctdb_pulldb *pulldb;
 858                 struct ctdb_rec_buffer *recbuf;
 859                 uint32_t recmode;
 860                 const char *db_name;
 861                 struct ctdb_traverse_start *traverse_start;
 862                 struct ctdb_traverse_all *traverse_all;
 863                 struct ctdb_rec_data *rec_data;
 864                 uint32_t recmaster;
 865                 struct ctdb_connection *conn;
 866                 struct ctdb_tunable *tunable;
 867                 const char *tun_var;
 868                 struct ctdb_node_flag_change *flag_change;
 869                 ctdb_sock_addr *addr;
 870                 struct ctdb_tickle_list *tickles;
 871                 struct ctdb_client_id *cid;
 872                 struct ctdb_addr_info *addr_info;
 873                 uint32_t tid;
 874                 struct ctdb_transdb *transdb;
 875                 const char *event_str;
 876                 struct ctdb_public_ip *pubip;
 877                 enum ctdb_event event;
 878                 double reclock_latency;
 879                 const char *reclock_file;
 880                 uint32_t role;
 881                 const char *script;
 882                 struct ctdb_ban_state *ban_state;
 883                 struct ctdb_db_priority *db_prio;
 884                 struct ctdb_notify_data *notify;
 885                 uint64_t srvid;
 886                 struct ctdb_iface *iface;
 887                 struct ctdb_key_data *key;
 888                 struct ctdb_uint64_array *u64_array;
 889                 struct ctdb_traverse_start_ext *traverse_start_ext;
 890                 struct ctdb_traverse_all_ext *traverse_all_ext;
 891         } data;
 892 };
 893
 894 struct ctdb_reply_control_data {
 895         uint32_t opcode;
 896         union {
 897                 struct ctdb_statistics *stats;
 898                 const char *db_path;
 899                 struct ctdb_vnn_map *vnnmap;
 900                 uint32_t loglevel;
 901                 struct ctdb_dbid_map *dbmap;
 902                 struct ctdb_rec_buffer *recbuf;
 903                 uint32_t db_id;
 904                 const char *db_name;
 905                 const char *mem_str;
 906                 uint32_t tun_value;
 907                 struct ctdb_var_list *tun_var_list;
 908                 struct ctdb_tunable_list *tun_list;
 909                 struct ctdb_tickle_list *tickles;
 910                 struct ctdb_client_id_map *cid_map;
 911                 struct ctdb_uptime *uptime;
 912                 uint32_t caps;
 913                 struct ctdb_public_ip_list *pubip_list;
 914                 struct ctdb_node_map *nodemap;
 915                 struct ctdb_script_list *script_list;
 916                 const char *reclock_file;
 917                 struct ctdb_ban_state *ban_state;
 918                 uint64_t seqnum;
 919                 const char *reason;
 920                 struct ctdb_public_ip_info *ipinfo;
 921                 struct ctdb_iface_list *iface_list;
 922                 struct ctdb_statistics_list *stats_list;
 923                 struct ctdb_uint8_array *u8_array;
 924                 struct ctdb_db_statistics *dbstats;
 925                 enum ctdb_runstate runstate;
 926         } data;
 927 };
 928
 929 struct ctdb_req_control {
 930         uint32_t opcode;
 931         uint32_t pad;
 932         uint64_t srvid;
 933         uint32_t client_id;
 934 #define CTDB_CTRL_FLAG_NOREPLY   1
 935 #define CTDB_CTRL_FLAG_OPCODE_SPECIFIC   0xFFFF0000
 936         uint32_t flags;
 937         struct ctdb_req_control_data rdata;
 938 };
 939
 940 struct ctdb_reply_control {
 941         int32_t status;
 942         const char *errmsg;
 943         struct ctdb_reply_control_data rdata;
 944 };
 945
 946 struct ctdb_election_message {
 947         uint32_t num_connected;
 948         struct timeval priority_time;
 949         uint32_t pnn;
 950         uint32_t node_flags;
 951 };
 952
 953 struct ctdb_srvid_message {
 954         uint32_t pnn;
 955         uint64_t srvid;
 956 };
 957
 958 struct ctdb_disable_message {
 959         uint32_t pnn;
 960         uint64_t srvid;
 961         uint32_t timeout;
 962 };
 963
 964 union ctdb_message_data {
 965         /* SRVID_ELECTION */
 966         struct ctdb_election_message *election;
 967         /* SRVID_RELEASE_IP, SRVID_TAKE_IP */
 968         const char *ipaddr;
 969         /* SRVID_SET_NODE_FLAGS, SERVID_PUSH_NODE_FLAGS */
 970         struct ctdb_node_flag_change *flag_change;
 971         /* SRVID_RECD_UPDATE_IP */
 972         struct ctdb_public_ip *pubip;
 973         /* SRVID_VACUUM_FETCH */
 974         struct ctdb_rec_buffer *recbuf;
 975         /* SRVID_DETACH_DATABASE */
 976         uint32_t db_id;
 977         /* SRVID_MEM_DUMP, SRVID_TAKEOVER_RUN */
 978         struct ctdb_srvid_message *msg;
 979         /* SRVID_REBALANCE_NODE */
 980         uint32_t pnn;
 981         /* SRVID_DISABLE_TAKEOVER_RUNS, SRVID_DISABLE_RECOVERIES */
 982         struct ctdb_disable_message *disable;
 983         /* SRVID_DISABLE_IP_CHECK */
 984         uint32_t timeout;
 985         /* Other */
 986         TDB_DATA data;
 987 };
 988
 989 struct ctdb_req_message {
 990         uint64_t srvid;
 991         union ctdb_message_data data;
 992 };
 993
 994 struct ctdb_req_message_data {
 995         uint64_t srvid;
 996         TDB_DATA data;
 997 };
 998
 999 /* This is equivalent to server_id */
1000 struct ctdb_server_id {
1001         uint64_t pid;
1002         uint32_t task_id;
1003         uint32_t vnn;
1004         uint64_t unique_id;
1005 };
1006
1007 enum ctdb_g_lock_type {
1008         CTDB_G_LOCK_READ = 0,
1009         CTDB_G_LOCK_WRITE = 1,
1010 };
1011
1012 struct ctdb_g_lock {
1013         enum ctdb_g_lock_type type;
1014         struct ctdb_server_id sid;
1015 };
1016
1017 struct ctdb_g_lock_list {
1018         unsigned int num;
1019         struct ctdb_g_lock *lock;
1020 };
1021
1022 #endif /* __CTDB_PROTOCOL_H__ */