ctdb/include/ctdb_protocol.h

   1 /*
   2    ctdb database library
   3
   4    Copyright (C) Andrew Tridgell  2006
   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 <sys/socket.h>
  24
  25 /* location of daemon socket, set at configure time */
  26 #ifdef SOCKPATH
  27 #define CTDB_SOCKET     SOCKPATH
  28 #else
  29 #define CTDB_SOCKET     "/var/run/ctdb/ctdbd.socket"
  30 #endif
  31
  32 /* default ctdb port number */
  33 #define CTDB_PORT 4379
  34
  35 /* we must align packets to ensure ctdb works on all architectures (eg. sparc) */
  36 #define CTDB_DS_ALIGNMENT 8
  37
  38
  39 #define CTDB_NULL_FUNC                  0xFF000001
  40 #define CTDB_FETCH_FUNC                 0xFF000002
  41 #define CTDB_FETCH_WITH_HEADER_FUNC     0xFF000003
  42
  43
  44 struct ctdb_call {
  45         int call_id;
  46         TDB_DATA key;
  47         TDB_DATA call_data;
  48         TDB_DATA reply_data;
  49         uint32_t status;
  50 #define CTDB_IMMEDIATE_MIGRATION                0x00000001
  51 #define CTDB_CALL_FLAG_VACUUM_MIGRATION         0x00000002
  52 #define CTDB_WANT_READONLY                      0x00000004
  53         uint32_t flags;
  54 };
  55
  56 /*
  57   structure passed to a ctdb call backend function
  58 */
  59 struct ctdb_call_info {
  60         TDB_DATA key;          /* record key */
  61         struct ctdb_ltdb_header *header;
  62         TDB_DATA record_data;  /* current data in the record */
  63         TDB_DATA *new_data;    /* optionally updated record data */
  64         TDB_DATA *call_data;   /* optionally passed from caller */
  65         TDB_DATA *reply_data;  /* optionally returned by function */
  66         uint32_t status;       /* optional reply status - defaults to zero */
  67 };
  68
  69 #define CTDB_ERR_INVALID 1
  70 #define CTDB_ERR_NOMEM 2
  71
  72 /*
  73   ctdb flags
  74 */
  75 #define CTDB_FLAG_TORTURE      (1<<1)
  76
  77 /*
  78    a message handler ID meaning "give me all messages"
  79  */
  80 #define CTDB_SRVID_ALL (~(uint64_t)0)
  81
  82 /*
  83   srvid type : RECOVERY
  84 */
  85 #define CTDB_SRVID_RECOVERY     0xF100000000000000LL
  86
  87 /*
  88    a message handler ID meaning that the cluster has been reconfigured
  89  */
  90 #define CTDB_SRVID_RECONFIGURE 0xF200000000000000LL
  91
  92 /*
  93    a message handler ID meaning that an IP address has been released
  94  */
  95 #define CTDB_SRVID_RELEASE_IP 0xF300000000000000LL
  96
  97 /*
  98    a message handler ID meaning that an IP address has been taken
  99  */
 100 #define CTDB_SRVID_TAKE_IP 0xF301000000000000LL
 101
 102 /*
 103    a message ID to set the node flags in the recovery daemon
 104  */
 105 #define CTDB_SRVID_SET_NODE_FLAGS 0xF400000000000000LL
 106
 107 /*
 108    a message ID to ask the recovery daemon to update the expected node
 109    assignment for a public ip
 110  */
 111 #define CTDB_SRVID_RECD_UPDATE_IP 0xF500000000000000LL
 112
 113 /*
 114   a message to tell the recovery daemon to fetch a set of records
 115  */
 116 #define CTDB_SRVID_VACUUM_FETCH 0xF700000000000000LL
 117
 118 /*
 119  * a message to tell recovery daemon to detach a database
 120  */
 121 #define CTDB_SRVID_DETACH_DATABASE 0xF701000000000000LL
 122 /*
 123   a message to tell the recovery daemon to write a talloc memdump
 124   to the log
 125  */
 126 #define CTDB_SRVID_MEM_DUMP 0xF800000000000000LL
 127
 128 /* A message id used to ask the recover daemon to send logs
 129 */
 130 #define CTDB_SRVID_GETLOG  0xF801000000000000LL
 131
 132 /* A message id used to ask the recover daemon to send logs
 133 */
 134 #define CTDB_SRVID_CLEARLOG  0xF802000000000000LL
 135
 136 /*
 137    a message ID to get the recovery daemon to push the node flags out
 138  */
 139 #define CTDB_SRVID_PUSH_NODE_FLAGS 0xF900000000000000LL
 140
 141 /*
 142    a message ID to get the recovery daemon to reload the nodes file
 143  */
 144 #define CTDB_SRVID_RELOAD_NODES 0xFA00000000000000LL
 145
 146 /*
 147    a message ID to get the recovery daemon to perform a takeover run
 148  */
 149 #define CTDB_SRVID_TAKEOVER_RUN 0xFB00000000000000LL
 150
 151 /* request recovery daemon to rebalance ips for a node.
 152    input is uint32_t for the node id.
 153 */
 154 #define CTDB_SRVID_REBALANCE_NODE 0xFB01000000000000LL
 155
 156 /* A message handler ID to stop takeover runs from occurring */
 157 #define CTDB_SRVID_DISABLE_TAKEOVER_RUNS 0xFB03000000000000LL
 158
 159 /* A message handler ID to stop recoveries from occurring */
 160 #define CTDB_SRVID_DISABLE_RECOVERIES 0xFB04000000000000LL
 161
 162 /* A message id to ask the recovery daemon to temporarily disable the
 163    public ip checks
 164 */
 165 #define CTDB_SRVID_DISABLE_IP_CHECK  0xFC00000000000000LL
 166
 167 /* A dummy port used for sending back ipreallocate resposnes to the main
 168    daemon
 169 */
 170 #define CTDB_SRVID_TAKEOVER_RUN_RESPONSE  0xFD00000000000000LL
 171
 172 /* A range of ports reserved for registering a PID (top 8 bits)
 173  * All ports matching the 8 top bits are reserved for exclusive use by
 174  * registering a SRVID that matches the process-id of the requesting process
 175  */
 176 #define CTDB_SRVID_PID_RANGE   0x0000000000000000LL
 177
 178 /* A range of ports reserved for samba (top 8 bits)
 179  * All ports matching the 8 top bits are reserved for exclusive use by
 180  * CIFS server
 181  */
 182 #define CTDB_SRVID_SAMBA_NOTIFY  0xFE00000000000000LL
 183 #define CTDB_SRVID_SAMBA_RANGE   0xFE00000000000000LL
 184
 185 /* A range of ports reserved for a CTDB NFS server (top 8 bits)
 186  * All ports matching the 8 top bits are reserved for exclusive use by
 187  * NFS server
 188  */
 189 #define CTDB_SRVID_NFSD_RANGE  0xEE00000000000000LL
 190
 191 /* A range of ports reserved for a CTDB ISCSI server (top 8 bits)
 192  * All ports matching the 8 top bits are reserved for exclusive use by
 193  * ISCSI server
 194  */
 195 #define CTDB_SRVID_ISCSID_RANGE  0xDE00000000000000LL
 196
 197 /* A range of ports reserved for testing (top 8 bits)
 198  * All ports matching the 8 top bits are reserved for exclusive use by
 199  * test applications
 200  */
 201 #define CTDB_SRVID_TEST_RANGE  0xCE00000000000000LL
 202
 203 /* Range of ports reserved for traversals */
 204 #define CTDB_SRVID_TRAVERSE_RANGE  0xBE00000000000000LL
 205
 206 /* used on the domain socket, send a pdu to the local daemon */
 207 #define CTDB_CURRENT_NODE     0xF0000001
 208 /* send a broadcast to all nodes in the cluster, active or not */
 209 #define CTDB_BROADCAST_ALL    0xF0000002
 210 /* send a broadcast to all nodes in the current vnn map */
 211 #define CTDB_BROADCAST_VNNMAP 0xF0000003
 212 /* send a broadcast to all connected nodes */
 213 #define CTDB_BROADCAST_CONNECTED 0xF0000004
 214 /* send a broadcast to selected connected nodes */
 215 #define CTDB_MULTICAST 0xF0000005
 216
 217 /* the key used for transaction locking on persistent databases */
 218 #define CTDB_TRANSACTION_LOCK_KEY "__transaction_lock__"
 219
 220 /* the key used to store persistent db sequence number */
 221 #define CTDB_DB_SEQNUM_KEY "__db_sequence_number__"
 222
 223 #define MONITOR_SCRIPT_OK      0
 224 #define MONITOR_SCRIPT_TIMEOUT 1
 225
 226 #define MAX_SCRIPT_NAME 31
 227 #define MAX_SCRIPT_OUTPUT 511
 228 struct ctdb_script_wire {
 229         char name[MAX_SCRIPT_NAME+1];
 230         struct timeval start;
 231         struct timeval finished;
 232         int32_t status;
 233         char output[MAX_SCRIPT_OUTPUT+1];
 234 };
 235
 236 struct ctdb_scripts_wire {
 237         uint32_t num_scripts;
 238         struct ctdb_script_wire scripts[1];
 239 };
 240
 241 /* different calls to event scripts. */
 242 enum ctdb_eventscript_call {
 243         CTDB_EVENT_INIT,                /* CTDB starting up: no args */
 244         CTDB_EVENT_SETUP,               /* CTDB starting up after transport is readdy: no args. */
 245         CTDB_EVENT_STARTUP,             /* CTDB starting up after initial recovery: no args. */
 246         CTDB_EVENT_START_RECOVERY,      /* CTDB recovery starting: no args. */
 247         CTDB_EVENT_RECOVERED,           /* CTDB recovery finished: no args. */
 248         CTDB_EVENT_TAKE_IP,             /* IP taken: interface, IP address, netmask bits. */
 249         CTDB_EVENT_RELEASE_IP,          /* IP released: interface, IP address, netmask bits. */
 250         CTDB_EVENT_STOPPED,             /* Deprecated, do not use. */
 251         CTDB_EVENT_MONITOR,             /* Please check if service is healthy: no args. */
 252         CTDB_EVENT_STATUS,              /* Deprecated, do not use. */
 253         CTDB_EVENT_SHUTDOWN,            /* CTDB shutting down: no args. */
 254         CTDB_EVENT_RELOAD,              /* Deprecated, do not use */
 255         CTDB_EVENT_UPDATE_IP,           /* IP updating: old interface, new interface, IP address, netmask bits. */
 256         CTDB_EVENT_IPREALLOCATED,       /* when a takeover_run() completes */
 257         CTDB_EVENT_MAX
 258 };
 259
 260 /* Mapping from enum to names. */
 261 extern const char *ctdb_eventscript_call_names[];
 262
 263 /*
 264   operation IDs
 265 */
 266 enum ctdb_operation {
 267         CTDB_REQ_CALL           = 0,
 268         CTDB_REPLY_CALL         = 1,
 269         CTDB_REQ_DMASTER        = 2,
 270         CTDB_REPLY_DMASTER      = 3,
 271         CTDB_REPLY_ERROR        = 4,
 272         CTDB_REQ_MESSAGE        = 5,
 273         /* #6 removed */
 274         CTDB_REQ_CONTROL        = 7,
 275         CTDB_REPLY_CONTROL      = 8,
 276         CTDB_REQ_KEEPALIVE      = 9,
 277 };
 278
 279 #define CTDB_MAGIC 0x43544442 /* CTDB */
 280 #define CTDB_PROTOCOL 1
 281
 282 enum ctdb_controls {CTDB_CONTROL_PROCESS_EXISTS          = 0,
 283                     CTDB_CONTROL_STATISTICS              = 1,
 284                     /* #2 removed */
 285                     CTDB_CONTROL_PING                    = 3,
 286                     CTDB_CONTROL_GETDBPATH               = 4,
 287                     CTDB_CONTROL_GETVNNMAP               = 5,
 288                     CTDB_CONTROL_SETVNNMAP               = 6,
 289                     CTDB_CONTROL_GET_DEBUG               = 7,
 290                     CTDB_CONTROL_SET_DEBUG               = 8,
 291                     CTDB_CONTROL_GET_DBMAP               = 9,
 292                     CTDB_CONTROL_GET_NODEMAPv4           = 10, /* obsolete */
 293                     CTDB_CONTROL_SET_DMASTER             = 11, /* obsolete */
 294                     /* #12 removed */
 295                     CTDB_CONTROL_PULL_DB                 = 13,
 296                     CTDB_CONTROL_PUSH_DB                 = 14,
 297                     CTDB_CONTROL_GET_RECMODE             = 15,
 298                     CTDB_CONTROL_SET_RECMODE             = 16,
 299                     CTDB_CONTROL_STATISTICS_RESET        = 17,
 300                     CTDB_CONTROL_DB_ATTACH               = 18,
 301                     CTDB_CONTROL_SET_CALL                = 19, /* obsolete */
 302                     CTDB_CONTROL_TRAVERSE_START          = 20,
 303                     CTDB_CONTROL_TRAVERSE_ALL            = 21,
 304                     CTDB_CONTROL_TRAVERSE_DATA           = 22,
 305                     CTDB_CONTROL_REGISTER_SRVID          = 23,
 306                     CTDB_CONTROL_DEREGISTER_SRVID        = 24,
 307                     CTDB_CONTROL_GET_DBNAME              = 25,
 308                     CTDB_CONTROL_ENABLE_SEQNUM           = 26,
 309                     CTDB_CONTROL_UPDATE_SEQNUM           = 27,
 310                     /* #28 removed */
 311                     CTDB_CONTROL_DUMP_MEMORY             = 29,
 312                     CTDB_CONTROL_GET_PID                 = 30,
 313                     CTDB_CONTROL_GET_RECMASTER           = 31,
 314                     CTDB_CONTROL_SET_RECMASTER           = 32,
 315                     CTDB_CONTROL_FREEZE                  = 33,
 316                     CTDB_CONTROL_THAW                    = 34,
 317                     CTDB_CONTROL_GET_PNN                 = 35,
 318                     CTDB_CONTROL_SHUTDOWN                = 36,
 319                     CTDB_CONTROL_GET_MONMODE             = 37,
 320                     /* #38 removed */
 321                     /* #39 removed */
 322                     /* #40 removed */
 323                     /* #41 removed */
 324                     CTDB_CONTROL_TAKEOVER_IPv4           = 42, /* obsolete */
 325                     CTDB_CONTROL_RELEASE_IPv4            = 43, /* obsolete */
 326                     CTDB_CONTROL_TCP_CLIENT              = 44,
 327                     CTDB_CONTROL_TCP_ADD                 = 45,
 328                     CTDB_CONTROL_TCP_REMOVE              = 46,
 329                     CTDB_CONTROL_STARTUP                 = 47,
 330                     CTDB_CONTROL_SET_TUNABLE             = 48,
 331                     CTDB_CONTROL_GET_TUNABLE             = 49,
 332                     CTDB_CONTROL_LIST_TUNABLES           = 50,
 333                     CTDB_CONTROL_GET_PUBLIC_IPSv4        = 51, /* obsolete */
 334                     CTDB_CONTROL_MODIFY_FLAGS            = 52,
 335                     CTDB_CONTROL_GET_ALL_TUNABLES        = 53,
 336                     CTDB_CONTROL_KILL_TCP                = 54,
 337                     CTDB_CONTROL_GET_TCP_TICKLE_LIST     = 55,
 338                     CTDB_CONTROL_SET_TCP_TICKLE_LIST     = 56,
 339                     CTDB_CONTROL_REGISTER_SERVER_ID      = 57,
 340                     CTDB_CONTROL_UNREGISTER_SERVER_ID    = 58,
 341                     CTDB_CONTROL_CHECK_SERVER_ID         = 59,
 342                     CTDB_CONTROL_GET_SERVER_ID_LIST      = 60,
 343                     CTDB_CONTROL_DB_ATTACH_PERSISTENT    = 61,
 344                     CTDB_CONTROL_PERSISTENT_STORE        = 62, /* obsolete */
 345                     CTDB_CONTROL_UPDATE_RECORD           = 63,
 346                     CTDB_CONTROL_SEND_GRATIOUS_ARP       = 64,
 347                     CTDB_CONTROL_TRANSACTION_START       = 65,
 348                     CTDB_CONTROL_TRANSACTION_COMMIT      = 66,
 349                     CTDB_CONTROL_WIPE_DATABASE           = 67,
 350                     /* #68 removed */
 351                     CTDB_CONTROL_UPTIME                  = 69,
 352                     CTDB_CONTROL_START_RECOVERY          = 70,
 353                     CTDB_CONTROL_END_RECOVERY            = 71,
 354                     CTDB_CONTROL_RELOAD_NODES_FILE       = 72,
 355                     /* #73 removed */
 356                     CTDB_CONTROL_TRY_DELETE_RECORDS      = 74,
 357                     CTDB_CONTROL_ENABLE_MONITOR          = 75,
 358                     CTDB_CONTROL_DISABLE_MONITOR         = 76,
 359                     CTDB_CONTROL_ADD_PUBLIC_IP           = 77,
 360                     CTDB_CONTROL_DEL_PUBLIC_IP           = 78,
 361                     CTDB_CONTROL_RUN_EVENTSCRIPTS        = 79,
 362                     CTDB_CONTROL_GET_CAPABILITIES        = 80,
 363                     CTDB_CONTROL_START_PERSISTENT_UPDATE = 81,
 364                     CTDB_CONTROL_CANCEL_PERSISTENT_UPDATE= 82,
 365                     CTDB_CONTROL_TRANS2_COMMIT           = 83, /* obsolete */
 366                     CTDB_CONTROL_TRANS2_FINISHED         = 84, /* obsolete */
 367                     CTDB_CONTROL_TRANS2_ERROR            = 85, /* obsolete */
 368                     CTDB_CONTROL_TRANS2_COMMIT_RETRY     = 86, /* obsolete */
 369                     CTDB_CONTROL_RECD_PING               = 87,
 370                     CTDB_CONTROL_RELEASE_IP              = 88,
 371                     CTDB_CONTROL_TAKEOVER_IP             = 89,
 372                     CTDB_CONTROL_GET_PUBLIC_IPS          = 90,
 373                     CTDB_CONTROL_GET_NODEMAP             = 91,
 374                     CTDB_CONTROL_GET_EVENT_SCRIPT_STATUS = 96,
 375                     CTDB_CONTROL_TRAVERSE_KILL           = 97,
 376                     CTDB_CONTROL_RECD_RECLOCK_LATENCY    = 98,
 377                     CTDB_CONTROL_GET_RECLOCK_FILE        = 99,
 378                     CTDB_CONTROL_SET_RECLOCK_FILE        = 100,
 379                     CTDB_CONTROL_STOP_NODE               = 101,
 380                     CTDB_CONTROL_CONTINUE_NODE           = 102,
 381                     CTDB_CONTROL_SET_NATGWSTATE          = 103,
 382                     CTDB_CONTROL_SET_LMASTERROLE         = 104,
 383                     CTDB_CONTROL_SET_RECMASTERROLE       = 105,
 384                     CTDB_CONTROL_ENABLE_SCRIPT           = 107,
 385                     CTDB_CONTROL_DISABLE_SCRIPT          = 108,
 386                     CTDB_CONTROL_SET_BAN_STATE           = 109,
 387                     CTDB_CONTROL_GET_BAN_STATE           = 110,
 388                     CTDB_CONTROL_SET_DB_PRIORITY         = 111,
 389                     CTDB_CONTROL_GET_DB_PRIORITY         = 112,
 390                     CTDB_CONTROL_TRANSACTION_CANCEL      = 113,
 391                     CTDB_CONTROL_REGISTER_NOTIFY         = 114,
 392                     CTDB_CONTROL_DEREGISTER_NOTIFY       = 115,
 393                     CTDB_CONTROL_TRANS2_ACTIVE           = 116, /* obsolete */
 394                     CTDB_CONTROL_GET_LOG                 = 117, /* obsolete */
 395                     CTDB_CONTROL_CLEAR_LOG               = 118, /* obsolete */
 396                     CTDB_CONTROL_TRANS3_COMMIT           = 119,
 397                     CTDB_CONTROL_GET_DB_SEQNUM           = 120,
 398                     CTDB_CONTROL_DB_SET_HEALTHY          = 121,
 399                     CTDB_CONTROL_DB_GET_HEALTH           = 122,
 400                     CTDB_CONTROL_GET_PUBLIC_IP_INFO      = 123,
 401                     CTDB_CONTROL_GET_IFACES              = 124,
 402                     CTDB_CONTROL_SET_IFACE_LINK_STATE    = 125,
 403                     CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE  = 126,
 404                     CTDB_CONTROL_GET_STAT_HISTORY        = 127,
 405                     CTDB_CONTROL_SCHEDULE_FOR_DELETION   = 128,
 406                     CTDB_CONTROL_SET_DB_READONLY         = 129,
 407                     CTDB_CONTROL_CHECK_SRVIDS            = 130,
 408                     CTDB_CONTROL_TRAVERSE_START_EXT      = 131,
 409                     CTDB_CONTROL_GET_DB_STATISTICS       = 132,
 410                     CTDB_CONTROL_SET_DB_STICKY           = 133,
 411                     CTDB_CONTROL_RELOAD_PUBLIC_IPS       = 134,
 412                     CTDB_CONTROL_TRAVERSE_ALL_EXT        = 135,
 413                     CTDB_CONTROL_RECEIVE_RECORDS         = 136,
 414                     CTDB_CONTROL_IPREALLOCATED           = 137,
 415                     CTDB_CONTROL_GET_RUNSTATE            = 138,
 416                     CTDB_CONTROL_DB_DETACH               = 139,
 417                     CTDB_CONTROL_GET_NODES_FILE          = 140,
 418                     CTDB_CONTROL_DB_FREEZE               = 141,
 419                     CTDB_CONTROL_DB_THAW                 = 142,
 420                     CTDB_CONTROL_DB_TRANSACTION_START    = 143,
 421                     CTDB_CONTROL_DB_TRANSACTION_COMMIT   = 144,
 422                     CTDB_CONTROL_DB_TRANSACTION_CANCEL   = 145,
 423 };
 424
 425 /*
 426   packet structures
 427 */
 428 struct ctdb_req_header {
 429         uint32_t length;
 430         uint32_t ctdb_magic;
 431         uint32_t ctdb_version;
 432         uint32_t generation;
 433         uint32_t operation;
 434         uint32_t destnode;
 435         uint32_t srcnode;
 436         uint32_t reqid;
 437 };
 438
 439 struct ctdb_req_call {
 440         struct ctdb_req_header hdr;
 441         uint32_t flags;
 442         uint32_t db_id;
 443         uint32_t callid;
 444         uint32_t hopcount;
 445         uint32_t keylen;
 446         uint32_t calldatalen;
 447         uint8_t data[1]; /* key[] followed by calldata[] */
 448 };
 449
 450 struct ctdb_reply_call {
 451         struct ctdb_req_header hdr;
 452         uint32_t status;
 453         uint32_t datalen;
 454         uint8_t  data[1];
 455 };
 456
 457 struct ctdb_reply_error {
 458         struct ctdb_req_header hdr;
 459         uint32_t status;
 460         uint32_t msglen;
 461         uint8_t  msg[1];
 462 };
 463
 464 struct ctdb_req_dmaster {
 465         struct ctdb_req_header hdr;
 466         uint32_t db_id;
 467         uint64_t rsn;
 468         uint32_t dmaster;
 469         uint32_t keylen;
 470         uint32_t datalen;
 471         uint8_t  data[1];
 472 };
 473
 474 struct ctdb_reply_dmaster {
 475         struct ctdb_req_header hdr;
 476         uint32_t db_id;
 477         uint64_t rsn;
 478         uint32_t keylen;
 479         uint32_t datalen;
 480         uint8_t  data[1];
 481 };
 482
 483 struct ctdb_req_message {
 484         struct ctdb_req_header hdr;
 485         uint64_t srvid;
 486         uint32_t datalen;
 487         uint8_t data[1];
 488 };
 489
 490 struct ctdb_req_control {
 491         struct ctdb_req_header hdr;
 492         uint32_t opcode;
 493         uint32_t pad;
 494         uint64_t srvid;
 495         uint32_t client_id;
 496 #define CTDB_CTRL_FLAG_NOREPLY   1
 497 #define CTDB_CTRL_FLAG_OPCODE_SPECIFIC   0xFFFF0000
 498         uint32_t flags;
 499         uint32_t datalen;
 500         uint8_t data[1];
 501 };
 502
 503 struct ctdb_reply_control {
 504         struct ctdb_req_header hdr;
 505         int32_t  status;
 506         uint32_t datalen;
 507         uint32_t errorlen;
 508         uint8_t data[1];
 509 };
 510
 511 struct ctdb_req_keepalive {
 512         struct ctdb_req_header hdr;
 513 };
 514
 515
 516 /*
 517   the extended header for records in the ltdb
 518 */
 519 struct ctdb_ltdb_header {
 520         uint64_t rsn;
 521         uint32_t dmaster;
 522         uint32_t reserved1;
 523 #define CTDB_REC_FLAG_DEFAULT                   0x00000000
 524 #define CTDB_REC_FLAG_MIGRATED_WITH_DATA        0x00010000
 525 #define CTDB_REC_FLAG_VACUUM_MIGRATED           0x00020000
 526 #define CTDB_REC_FLAG_AUTOMATIC                 0x00040000
 527 #define CTDB_REC_RO_HAVE_DELEGATIONS            0x01000000
 528 #define CTDB_REC_RO_HAVE_READONLY               0x02000000
 529 #define CTDB_REC_RO_REVOKING_READONLY           0x04000000
 530 #define CTDB_REC_RO_REVOKE_COMPLETE             0x08000000
 531 #define CTDB_REC_RO_FLAGS                       (CTDB_REC_RO_HAVE_DELEGATIONS|\
 532                                                  CTDB_REC_RO_HAVE_READONLY|\
 533                                                  CTDB_REC_RO_REVOKING_READONLY|\
 534                                                  CTDB_REC_RO_REVOKE_COMPLETE)
 535         uint32_t flags;
 536 };
 537
 538
 539 /*
 540   definitions for different socket structures
 541  */
 542 typedef struct sockaddr_in ctdb_addr_in;
 543 typedef struct sockaddr_in6 ctdb_addr_in6;
 544 typedef union {
 545         struct sockaddr sa;
 546         ctdb_addr_in    ip;
 547         ctdb_addr_in6   ip6;
 548 } ctdb_sock_addr;
 549
 550 /*
 551    A structure describing a single node, its flags and its address
 552 */
 553 struct ctdb_node_and_flags {
 554         uint32_t pnn;
 555         uint32_t flags;
 556         ctdb_sock_addr addr;
 557 };
 558
 559
 560 /*
 561    Structure used for a nodemap.
 562    The nodemap is the structure containing a list of all nodes
 563    known to the cluster and their associated flags.
 564 */
 565 struct ctdb_node_map {
 566         uint32_t num;
 567         struct ctdb_node_and_flags nodes[1];
 568 };
 569
 570 /*
 571  * Node flags
 572  */
 573 #define NODE_FLAGS_DISCONNECTED         0x00000001 /* node isn't connected */
 574 #define NODE_FLAGS_UNHEALTHY            0x00000002 /* monitoring says node is unhealthy */
 575 #define NODE_FLAGS_PERMANENTLY_DISABLED 0x00000004 /* administrator has disabled node */
 576 #define NODE_FLAGS_BANNED               0x00000008 /* recovery daemon has banned the node */
 577 #define NODE_FLAGS_DELETED              0x00000010 /* this node has been deleted */
 578 #define NODE_FLAGS_STOPPED              0x00000020 /* this node has been stopped */
 579 #define NODE_FLAGS_DISABLED             (NODE_FLAGS_UNHEALTHY|NODE_FLAGS_PERMANENTLY_DISABLED)
 580 #define NODE_FLAGS_INACTIVE             (NODE_FLAGS_DELETED|NODE_FLAGS_DISCONNECTED|NODE_FLAGS_BANNED|NODE_FLAGS_STOPPED)
 581
 582 /*
 583  * Node capabilities
 584  */
 585 #define CTDB_CAP_RECMASTER              0x00000001
 586 #define CTDB_CAP_LMASTER                0x00000002
 587 /* This capability is set if CTDB_LVS_PUBLIC_IP is set */
 588 #define CTDB_CAP_LVS                    0x00000004
 589 /* This capability is set if NATGW is enabled */
 590 #define CTDB_CAP_NATGW                  0x00000008
 591
 592 /*
 593  * Node features
 594  */
 595 #define CTDB_CAP_PARALLEL_RECOVERY      0x00010000
 596
 597 #define CTDB_CAP_DEFAULT                (CTDB_CAP_PARALLEL_RECOVERY)
 598
 599
 600 struct ctdb_public_ip {
 601         uint32_t pnn;
 602         ctdb_sock_addr addr;
 603 };
 604
 605 struct ctdb_all_public_ips {
 606         uint32_t num;
 607         struct ctdb_public_ip ips[1];
 608 };
 609
 610
 611 struct latency_counter {
 612         int num;
 613         double min;
 614         double max;
 615         double total;
 616 };
 617
 618 /*
 619   structure used to pass record data between the child and parent
 620  */
 621 struct ctdb_rec_data {
 622         uint32_t length;
 623         uint32_t reqid;
 624         uint32_t keylen;
 625         uint32_t datalen;
 626         uint8_t  data[1];
 627 };
 628
 629 struct ctdb_traverse_start {
 630         uint32_t db_id;
 631         uint32_t reqid;
 632         uint64_t srvid;
 633 };
 634
 635 struct ctdb_traverse_start_ext {
 636         uint32_t db_id;
 637         uint32_t reqid;
 638         uint64_t srvid;
 639         bool withemptyrecords;
 640 };
 641
 642 /*
 643   ctdb statistics information
 644  */
 645 #define MAX_COUNT_BUCKETS 16
 646 #define MAX_HOT_KEYS      10
 647
 648 struct ctdb_statistics {
 649         uint32_t num_clients;
 650         uint32_t frozen;
 651         uint32_t recovering;
 652         uint32_t client_packets_sent;
 653         uint32_t client_packets_recv;
 654         uint32_t node_packets_sent;
 655         uint32_t node_packets_recv;
 656         uint32_t keepalive_packets_sent;
 657         uint32_t keepalive_packets_recv;
 658         struct {
 659                 uint32_t req_call;
 660                 uint32_t reply_call;
 661                 uint32_t req_dmaster;
 662                 uint32_t reply_dmaster;
 663                 uint32_t reply_error;
 664                 uint32_t req_message;
 665                 uint32_t req_control;
 666                 uint32_t reply_control;
 667         } node;
 668         struct {
 669                 uint32_t req_call;
 670                 uint32_t req_message;
 671                 uint32_t req_control;
 672         } client;
 673         struct {
 674                 uint32_t call;
 675                 uint32_t control;
 676                 uint32_t traverse;
 677         } timeouts;
 678         struct {
 679                 struct latency_counter ctdbd;
 680                 struct latency_counter recd;
 681         } reclock;
 682         struct {
 683                 uint32_t num_calls;
 684                 uint32_t num_current;
 685                 uint32_t num_pending;
 686                 uint32_t num_failed;
 687                 struct latency_counter latency;
 688                 uint32_t buckets[MAX_COUNT_BUCKETS];
 689         } locks;
 690         uint32_t total_calls;
 691         uint32_t pending_calls;
 692         uint32_t childwrite_calls;
 693         uint32_t pending_childwrite_calls;
 694         uint32_t memory_used;
 695         uint32_t __last_counter; /* hack for control_statistics_all */
 696         uint32_t max_hop_count;
 697         uint32_t hop_count_bucket[MAX_COUNT_BUCKETS];
 698         struct latency_counter call_latency;
 699         struct latency_counter childwrite_latency;
 700         uint32_t num_recoveries;
 701         struct timeval statistics_start_time;
 702         struct timeval statistics_current_time;
 703         uint32_t total_ro_delegations;
 704         uint32_t total_ro_revokes;
 705 };
 706
 707 /*
 708  * wire format for statistics history
 709  */
 710 struct ctdb_statistics_wire {
 711         uint32_t num;
 712         struct ctdb_statistics stats[1];
 713 };
 714
 715 /*
 716  * db statistics
 717  */
 718 struct ctdb_db_statistics {
 719         struct {
 720                 uint32_t num_calls;
 721                 uint32_t num_current;
 722                 uint32_t num_pending;
 723                 uint32_t num_failed;
 724                 struct latency_counter latency;
 725                 uint32_t buckets[MAX_COUNT_BUCKETS];
 726         } locks;
 727         struct {
 728                 struct latency_counter latency;
 729         } vacuum;
 730         uint32_t db_ro_delegations;
 731         uint32_t db_ro_revokes;
 732         uint32_t hop_count_bucket[MAX_COUNT_BUCKETS];
 733         uint32_t num_hot_keys;
 734         struct {
 735                 uint32_t count;
 736                 TDB_DATA key;
 737         } hot_keys[MAX_HOT_KEYS];
 738         char hot_keys_wire[1];
 739 };
 740
 741 /*
 742  * wire format for interface list
 743  */
 744 #ifdef IFNAMSIZ
 745 #define CTDB_IFACE_SIZE IFNAMSIZ
 746 #else
 747 #define CTDB_IFACE_SIZE 16
 748 #endif
 749
 750 struct ctdb_iface_info {
 751         char name[CTDB_IFACE_SIZE+2];
 752         uint16_t link_state;
 753         uint32_t references;
 754 };
 755
 756 struct ctdb_ifaces_list {
 757         uint32_t num;
 758         struct ctdb_iface_info ifaces[1];
 759 };
 760
 761 #define INVALID_GENERATION 1
 762 /* table that contains the mapping between a hash value and lmaster
 763  */
 764 struct ctdb_vnn_map {
 765         uint32_t generation;
 766         uint32_t size;
 767         uint32_t *map;
 768 };
 769
 770 /*
 771    a wire representation of the vnn map
 772  */
 773 struct ctdb_vnn_map_wire {
 774         uint32_t generation;
 775         uint32_t size;
 776         uint32_t map[1];
 777 };
 778
 779 #endif