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