?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
nbt_server: Fix a typo ("domian->domain")
[Samba.git] / ctdb / protocol / protocol.h
blobcb807e3b939a9946c96198a1fa6f7289006ae99f
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_VNNMAP 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,
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 };
377
378 #define MAX_COUNT_BUCKETS 16
379 #define MAX_HOT_KEYS 10
380
381 struct ctdb_latency_counter {
382 int num;
383 double min;
384 double max;
385 double total;
386 };
387
388 struct ctdb_statistics {
389 uint32_t num_clients;
390 uint32_t frozen;
391 uint32_t recovering;
392 uint32_t client_packets_sent;
393 uint32_t client_packets_recv;
394 uint32_t node_packets_sent;
395 uint32_t node_packets_recv;
396 uint32_t keepalive_packets_sent;
397 uint32_t keepalive_packets_recv;
398 struct {
399 uint32_t req_call;
400 uint32_t reply_call;
401 uint32_t req_dmaster;
402 uint32_t reply_dmaster;
403 uint32_t reply_error;
404 uint32_t req_message;
405 uint32_t req_control;
406 uint32_t reply_control;
407 uint32_t req_tunnel;
408 } node;
409 struct {
410 uint32_t req_call;
411 uint32_t req_message;
412 uint32_t req_control;
413 uint32_t req_tunnel;
414 } client;
415 struct {
416 uint32_t call;
417 uint32_t control;
418 uint32_t traverse;
419 } timeouts;
420 struct {
421 struct ctdb_latency_counter ctdbd;
422 struct ctdb_latency_counter recd;
423 } reclock;
424 struct {
425 uint32_t num_calls;
426 uint32_t num_current;
427 uint32_t num_pending;
428 uint32_t num_failed;
429 struct ctdb_latency_counter latency;
430 uint32_t buckets[MAX_COUNT_BUCKETS];
431 } locks;
432 uint32_t total_calls;
433 uint32_t pending_calls;
434 uint32_t childwrite_calls;
435 uint32_t pending_childwrite_calls;
436 uint32_t memory_used;
437 uint32_t __last_counter; /* hack */
438 uint32_t max_hop_count;
439 uint32_t hop_count_bucket[MAX_COUNT_BUCKETS];
440 struct ctdb_latency_counter call_latency;
441 struct ctdb_latency_counter childwrite_latency;
442 uint32_t num_recoveries;
443 struct timeval statistics_start_time;
444 struct timeval statistics_current_time;
445 uint32_t total_ro_delegations;
446 uint32_t total_ro_revokes;
447 };
448
449 #define INVALID_GENERATION 1
450 /* table that contains the mapping between a hash value and lmaster
451 */
452 struct ctdb_vnn_map {
453 uint32_t generation;
454 uint32_t size;
455 uint32_t *map;
456 };
457
458 struct ctdb_dbid {
459 uint32_t db_id;
460 #define CTDB_DB_FLAGS_PERSISTENT 0x01
461 #define CTDB_DB_FLAGS_READONLY 0x02
462 #define CTDB_DB_FLAGS_STICKY 0x04
463 #define CTDB_DB_FLAGS_REPLICATED 0x08
464 uint8_t flags;
465 };
466
467 struct ctdb_dbid_map {
468 uint32_t num;
469 struct ctdb_dbid *dbs;
470 };
471
472 struct ctdb_pulldb {
473 uint32_t db_id;
474 #define CTDB_LMASTER_ANY 0xffffffff
475 uint32_t lmaster;
476 };
477
478 struct ctdb_pulldb_ext {
479 uint32_t db_id;
480 uint32_t lmaster;
481 uint64_t srvid;
482 };
483
484 #define CTDB_RECOVERY_NORMAL 0
485 #define CTDB_RECOVERY_ACTIVE 1
486
487 /*
488 the extended header for records in the ltdb
489 */
490 struct ctdb_ltdb_header {
491 uint64_t rsn;
492 uint32_t dmaster;
493 uint32_t reserved1;
494 #define CTDB_REC_FLAG_DEFAULT 0x00000000
495 #define CTDB_REC_FLAG_MIGRATED_WITH_DATA 0x00010000
496 #define CTDB_REC_FLAG_VACUUM_MIGRATED 0x00020000
497 #define CTDB_REC_FLAG_AUTOMATIC 0x00040000
498 #define CTDB_REC_RO_HAVE_DELEGATIONS 0x01000000
499 #define CTDB_REC_RO_HAVE_READONLY 0x02000000
500 #define CTDB_REC_RO_REVOKING_READONLY 0x04000000
501 #define CTDB_REC_RO_REVOKE_COMPLETE 0x08000000
502 #define CTDB_REC_RO_FLAGS (CTDB_REC_RO_HAVE_DELEGATIONS|\
503 CTDB_REC_RO_HAVE_READONLY|\
504 CTDB_REC_RO_REVOKING_READONLY|\
505 CTDB_REC_RO_REVOKE_COMPLETE)
506 uint32_t flags;
507 };
508
509 struct ctdb_rec_data {
510 uint32_t reqid;
511 struct ctdb_ltdb_header *header;
512 TDB_DATA key, data;
513 };
514
515 struct ctdb_rec_buffer {
516 uint32_t db_id;
517 uint32_t count;
518 uint8_t *buf;
519 size_t buflen;
520 };
521
522 typedef int (*ctdb_rec_parser_func_t)(uint32_t reqid,
523 struct ctdb_ltdb_header *header,
524 TDB_DATA key, TDB_DATA data,
525 void *private_data);
526
527 struct ctdb_traverse_start {
528 uint32_t db_id;
529 uint32_t reqid;
530 uint64_t srvid;
531 };
532
533 struct ctdb_traverse_all {
534 uint32_t db_id;
535 uint32_t reqid;
536 uint32_t pnn;
537 uint32_t client_reqid;
538 uint64_t srvid;
539 };
540
541 struct ctdb_traverse_start_ext {
542 uint32_t db_id;
543 uint32_t reqid;
544 uint64_t srvid;
545 bool withemptyrecords;
546 };
547
548 struct ctdb_traverse_all_ext {
549 uint32_t db_id;
550 uint32_t reqid;
551 uint32_t pnn;
552 uint32_t client_reqid;
553 uint64_t srvid;
554 bool withemptyrecords;
555 };
556
557 typedef union {
558 struct sockaddr sa;
559 struct sockaddr_in ip;
560 struct sockaddr_in6 ip6;
561 } ctdb_sock_addr;
562
563 struct ctdb_connection {
564 union {
565 ctdb_sock_addr src;
566 ctdb_sock_addr server;
567 };
568 union {
569 ctdb_sock_addr dst;
570 ctdb_sock_addr client;
571 };
572 };
573
574 struct ctdb_connection_list {
575 uint32_t num;
576 struct ctdb_connection *conn;
577 };
578
579 struct ctdb_tunable {
580 const char *name;
581 uint32_t value;
582 };
583
584 struct ctdb_var_list {
585 int count;
586 const char **var;
587 };
588
589 struct ctdb_node_flag_change {
590 uint32_t pnn;
591 uint32_t new_flags;
592 uint32_t old_flags;
593 };
594
595 /* all tunable variables go in here */
596 struct ctdb_tunable_list {
597 uint32_t max_redirect_count;
598 uint32_t seqnum_interval; /* unit is ms */
599 uint32_t control_timeout;
600 uint32_t traverse_timeout;
601 uint32_t keepalive_interval;
602 uint32_t keepalive_limit;
603 uint32_t recover_timeout;
604 uint32_t recover_interval;
605 uint32_t election_timeout;
606 uint32_t takeover_timeout;
607 uint32_t monitor_interval;
608 uint32_t tickle_update_interval;
609 uint32_t script_timeout;
610 uint32_t monitor_timeout_count; /* allow dodgy scripts to hang this many times in a row before we mark the node unhealthy */
611 uint32_t script_unhealthy_on_timeout; /* obsolete */
612 uint32_t recovery_grace_period;
613 uint32_t recovery_ban_period;
614 uint32_t database_hash_size;
615 uint32_t database_max_dead;
616 uint32_t rerecovery_timeout;
617 uint32_t enable_bans;
618 uint32_t deterministic_public_ips;
619 uint32_t reclock_ping_period;
620 uint32_t no_ip_failback;
621 uint32_t disable_ip_failover;
622 uint32_t verbose_memory_names;
623 uint32_t recd_ping_timeout;
624 uint32_t recd_ping_failcount;
625 uint32_t log_latency_ms;
626 uint32_t reclock_latency_ms;
627 uint32_t recovery_drop_all_ips;
628 uint32_t verify_recovery_lock;
629 uint32_t vacuum_interval;
630 uint32_t vacuum_max_run_time;
631 uint32_t repack_limit;
632 uint32_t vacuum_limit;
633 uint32_t max_queue_depth_drop_msg;
634 uint32_t allow_unhealthy_db_read;
635 uint32_t stat_history_interval;
636 uint32_t deferred_attach_timeout;
637 uint32_t vacuum_fast_path_count;
638 uint32_t lcp2_public_ip_assignment;
639 uint32_t allow_client_db_attach;
640 uint32_t recover_pdb_by_seqnum;
641 uint32_t deferred_rebalance_on_node_add;
642 uint32_t fetch_collapse;
643 uint32_t hopcount_make_sticky;
644 uint32_t sticky_duration;
645 uint32_t sticky_pindown;
646 uint32_t no_ip_takeover;
647 uint32_t db_record_count_warn;
648 uint32_t db_record_size_warn;
649 uint32_t db_size_warn;
650 uint32_t pulldb_preallocation_size;
651 uint32_t no_ip_host_on_all_disabled;
652 uint32_t samba3_hack;
653 uint32_t mutex_enabled;
654 uint32_t lock_processes_per_db;
655 uint32_t rec_buffer_size_limit;
656 uint32_t queue_buffer_size;
657 uint32_t ip_alloc_algorithm;
658 uint32_t allow_mixed_versions;
659 };
660
661 struct ctdb_tickle_list {
662 ctdb_sock_addr addr;
663 uint32_t num;
664 struct ctdb_connection *conn;
665 };
666
667 struct ctdb_addr_info {
668 ctdb_sock_addr addr;
669 uint32_t mask;
670 const char *iface;
671 };
672
673 struct ctdb_transdb {
674 uint32_t db_id;
675 uint32_t tid;
676 };
677
678 struct ctdb_uptime {
679 struct timeval current_time;
680 struct timeval ctdbd_start_time;
681 struct timeval last_recovery_started;
682 struct timeval last_recovery_finished;
683 };
684
685 struct ctdb_public_ip {
686 uint32_t pnn;
687 ctdb_sock_addr addr;
688 };
689
690 struct ctdb_public_ip_list {
691 uint32_t num;
692 struct ctdb_public_ip *ip;
693 };
694
695 /*
696 * Node flags
697 */
698 #define NODE_FLAGS_DISCONNECTED 0x00000001 /* node isn't connected */
699 #define NODE_FLAGS_UNHEALTHY 0x00000002 /* monitoring says node is unhealthy */
700 #define NODE_FLAGS_PERMANENTLY_DISABLED 0x00000004 /* administrator has disabled node */
701 #define NODE_FLAGS_BANNED 0x00000008 /* recovery daemon has banned the node */
702 #define NODE_FLAGS_DELETED 0x00000010 /* this node has been deleted */
703 #define NODE_FLAGS_STOPPED 0x00000020 /* this node has been stopped */
704 #define NODE_FLAGS_DISABLED (NODE_FLAGS_UNHEALTHY|NODE_FLAGS_PERMANENTLY_DISABLED)
705 #define NODE_FLAGS_INACTIVE (NODE_FLAGS_DELETED|NODE_FLAGS_DISCONNECTED|NODE_FLAGS_BANNED|NODE_FLAGS_STOPPED)
706
707 /*
708 * Node capabilities
709 */
710 #define CTDB_CAP_RECMASTER 0x00000001
711 #define CTDB_CAP_LMASTER 0x00000002
712 #define CTDB_CAP_LVS 0x00000004 /* obsolete */
713 #define CTDB_CAP_NATGW 0x00000008 /* obsolete */
714
715 /*
716 * Node features
717 */
718 #define CTDB_CAP_PARALLEL_RECOVERY 0x00010000
719 #define CTDB_CAP_FRAGMENTED_CONTROLS 0x00020000
720
721 #define CTDB_CAP_FEATURES (CTDB_CAP_PARALLEL_RECOVERY | \
722 CTDB_CAP_FRAGMENTED_CONTROLS)
723
724 #define CTDB_CAP_DEFAULT (CTDB_CAP_RECMASTER | \
725 CTDB_CAP_LMASTER | \
726 CTDB_CAP_FEATURES)
727
728 struct ctdb_node_and_flags {
729 uint32_t pnn;
730 uint32_t flags;
731 ctdb_sock_addr addr;
732 };
733
734 struct ctdb_node_map {
735 uint32_t num;
736 struct ctdb_node_and_flags *node;
737 };
738
739 enum ctdb_event {
740 CTDB_EVENT_INIT, /* CTDB starting up: no args */
741 CTDB_EVENT_SETUP, /* CTDB starting up after transport is readdy: no args. */
742 CTDB_EVENT_STARTUP, /* CTDB starting up after initial recovery: no args. */
743 CTDB_EVENT_START_RECOVERY, /* CTDB recovery starting: no args. */
744 CTDB_EVENT_RECOVERED, /* CTDB recovery finished: no args. */
745 CTDB_EVENT_TAKE_IP, /* IP taken: interface, IP address, netmask bits. */
746 CTDB_EVENT_RELEASE_IP, /* IP released: interface, IP address, netmask bits. */
747 CTDB_EVENT_STOPPED, /* Deprecated, do not use. */
748 CTDB_EVENT_MONITOR, /* Please check if service is healthy: no args. */
749 CTDB_EVENT_STATUS, /* Deprecated, do not use. */
750 CTDB_EVENT_SHUTDOWN, /* CTDB shutting down: no args. */
751 CTDB_EVENT_RELOAD, /* Deprecated, do not use */
752 CTDB_EVENT_UPDATE_IP, /* IP updating: old interface, new interface, IP address, netmask bits. */
753 CTDB_EVENT_IPREALLOCATED, /* when a takeover_run() completes */
754 CTDB_EVENT_MAX
755 };
756
757 #define MAX_SCRIPT_NAME 31
758 #define MAX_SCRIPT_OUTPUT 511
759
760 struct ctdb_script {
761 char name[MAX_SCRIPT_NAME+1];
762 struct timeval start;
763 struct timeval finished;
764 int32_t status;
765 char output[MAX_SCRIPT_OUTPUT+1];
766 };
767
768 struct ctdb_script_list {
769 uint32_t num_scripts;
770 struct ctdb_script *script;
771 };
772
773 struct ctdb_ban_state {
774 uint32_t pnn;
775 uint32_t time;
776 };
777
778 struct ctdb_notify_data {
779 uint64_t srvid;
780 TDB_DATA data;
781 };
782
783 #ifdef IFNAMSIZ
784 #define CTDB_IFACE_SIZE IFNAMSIZ
785 #else
786 #define CTDB_IFACE_SIZE 16
787 #endif
788
789 struct ctdb_iface {
790 char name[CTDB_IFACE_SIZE+2];
791 uint16_t link_state;
792 uint32_t references;
793 };
794
795 struct ctdb_iface_list {
796 uint32_t num;
797 struct ctdb_iface *iface;
798 };
799
800 struct ctdb_public_ip_info {
801 struct ctdb_public_ip ip;
802 uint32_t active_idx;
803 struct ctdb_iface_list *ifaces;
804 };
805
806 struct ctdb_statistics_list {
807 int num;
808 struct ctdb_statistics *stats;
809 };
810
811 struct ctdb_key_data {
812 uint32_t db_id;
813 struct ctdb_ltdb_header header;
814 TDB_DATA key;
815 };
816
817 struct ctdb_db_statistics {
818 struct {
819 uint32_t num_calls;
820 uint32_t num_current;
821 uint32_t num_pending;
822 uint32_t num_failed;
823 struct ctdb_latency_counter latency;
824 uint32_t buckets[MAX_COUNT_BUCKETS];
825 } locks;
826 struct {
827 struct ctdb_latency_counter latency;
828 } vacuum;
829 uint32_t db_ro_delegations;
830 uint32_t db_ro_revokes;
831 uint32_t hop_count_bucket[MAX_COUNT_BUCKETS];
832 uint32_t num_hot_keys;
833 struct {
834 uint32_t count;
835 TDB_DATA key;
836 } hot_keys[MAX_HOT_KEYS];
837 };
838
839 enum ctdb_runstate {
840 CTDB_RUNSTATE_UNKNOWN,
841 CTDB_RUNSTATE_INIT,
842 CTDB_RUNSTATE_SETUP,
843 CTDB_RUNSTATE_FIRST_RECOVERY,
844 CTDB_RUNSTATE_STARTUP,
845 CTDB_RUNSTATE_RUNNING,
846 CTDB_RUNSTATE_SHUTDOWN,
847 };
848
849 struct ctdb_pid_srvid {
850 pid_t pid;
851 uint64_t srvid;
852 };
853
854 struct ctdb_req_control_data {
855 uint32_t opcode;
856 union {
857 pid_t pid;
858 uint32_t db_id;
859 struct ctdb_vnn_map *vnnmap;
860 uint32_t loglevel;
861 struct ctdb_pulldb *pulldb;
862 struct ctdb_pulldb_ext *pulldb_ext;
863 struct ctdb_rec_buffer *recbuf;
864 uint32_t recmode;
865 const char *db_name;
866 struct ctdb_traverse_start *traverse_start;
867 struct ctdb_traverse_all *traverse_all;
868 struct ctdb_rec_data *rec_data;
869 uint32_t recmaster;
870 struct ctdb_connection *conn;
871 struct ctdb_tunable *tunable;
872 const char *tun_var;
873 struct ctdb_node_flag_change *flag_change;
874 ctdb_sock_addr *addr;
875 struct ctdb_tickle_list *tickles;
876 struct ctdb_client_id *cid;
877 struct ctdb_addr_info *addr_info;
878 struct ctdb_transdb *transdb;
879 struct ctdb_public_ip *pubip;
880 enum ctdb_event event;
881 double reclock_latency;
882 uint32_t role;
883 struct ctdb_ban_state *ban_state;
884 struct ctdb_notify_data *notify;
885 uint64_t srvid;
886 struct ctdb_iface *iface;
887 struct ctdb_key_data *key;
888 struct ctdb_traverse_start_ext *traverse_start_ext;
889 struct ctdb_traverse_all_ext *traverse_all_ext;
890 struct ctdb_pid_srvid *pid_srvid;
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 const char *reclock_file;
916 struct ctdb_ban_state *ban_state;
917 uint64_t seqnum;
918 const char *reason;
919 struct ctdb_public_ip_info *ipinfo;
920 struct ctdb_iface_list *iface_list;
921 struct ctdb_statistics_list *stats_list;
922 struct ctdb_db_statistics *dbstats;
923 enum ctdb_runstate runstate;
924 uint32_t num_records;
925 int tdb_flags;
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 /* Ugly overloading of this field... */
937 #define CTDB_PUBLIC_IP_FLAGS_ONLY_AVAILABLE 0x00010000
938 uint32_t flags;
939 struct ctdb_req_control_data rdata;
940 };
941
942 struct ctdb_reply_control {
943 int32_t status;
944 const char *errmsg;
945 struct ctdb_reply_control_data rdata;
946 };
947
948 struct ctdb_election_message {
949 uint32_t num_connected;
950 struct timeval priority_time;
951 uint32_t pnn;
952 uint32_t node_flags;
953 };
954
955 struct ctdb_srvid_message {
956 uint32_t pnn;
957 uint64_t srvid;
958 };
959
960 struct ctdb_disable_message {
961 uint32_t pnn;
962 uint64_t srvid;
963 uint32_t timeout;
964 };
965
966 union ctdb_message_data {
967 /* SRVID_ELECTION */
968 struct ctdb_election_message *election;
969 /* SRVID_RELEASE_IP, SRVID_TAKE_IP */
970 const char *ipaddr;
971 /* SRVID_SET_NODE_FLAGS, SERVID_PUSH_NODE_FLAGS */
972 struct ctdb_node_flag_change *flag_change;
973 /* SRVID_RECD_UPDATE_IP */
974 struct ctdb_public_ip *pubip;
975 /* SRVID_VACUUM_FETCH */
976 struct ctdb_rec_buffer *recbuf;
977 /* SRVID_DETACH_DATABASE */
978 uint32_t db_id;
979 /* SRVID_MEM_DUMP, SRVID_TAKEOVER_RUN */
980 struct ctdb_srvid_message *msg;
981 /* SRVID_BANNING, SRVID_REBALANCE_NODE */
982 uint32_t pnn;
983 /* SRVID_DISABLE_TAKEOVER_RUNS, SRVID_DISABLE_RECOVERIES */
984 struct ctdb_disable_message *disable;
985 /* SRVID_DISABLE_IP_CHECK */
986 uint32_t timeout;
987 /* Other */
988 TDB_DATA data;
989 };
990
991 struct ctdb_req_message {
992 uint64_t srvid;
993 union ctdb_message_data data;
994 };
995
996 struct ctdb_req_message_data {
997 uint64_t srvid;
998 TDB_DATA data;
999 };
1000
1001 struct ctdb_req_keepalive {
1002 uint32_t version;
1003 uint32_t uptime;
1004 };
1005
1006 #define CTDB_TUNNEL_TEST 0xffffffff00000000
1007
1008 #define CTDB_TUNNEL_FLAG_REQUEST 0x00000001
1009 #define CTDB_TUNNEL_FLAG_REPLY 0x00000002
1010 #define CTDB_TUNNEL_FLAG_NOREPLY 0x00000010
1011
1012 struct ctdb_req_tunnel {
1013 uint64_t tunnel_id;
1014 uint32_t flags;
1015 TDB_DATA data;
1016 };
1017
1018
1019 /* This is equivalent to server_id */
1020 struct ctdb_server_id {
1021 uint64_t pid;
1022 uint32_t task_id;
1023 uint32_t vnn;
1024 uint64_t unique_id;
1025 };
1026
1027 enum ctdb_g_lock_type {
1028 CTDB_G_LOCK_READ = 0,
1029 CTDB_G_LOCK_WRITE = 1,
1030 };
1031
1032 struct ctdb_g_lock {
1033 enum ctdb_g_lock_type type;
1034 struct ctdb_server_id sid;
1035 };
1036
1037 struct ctdb_g_lock_list {
1038 unsigned int num;
1039 struct ctdb_g_lock *lock;
1040 };
1041
1042 /*
1043 * Generic packet header
1044 */
1045
1046 struct sock_packet_header {
1047 uint32_t length;
1048 uint32_t reqid;
1049 };
1050
1051 /*
1052 * Eventd protocol
1053 */
1054
1055 enum ctdb_event_command {
1056 CTDB_EVENT_COMMAND_RUN = 1,
1057 CTDB_EVENT_COMMAND_STATUS = 2,
1058 CTDB_EVENT_COMMAND_SCRIPT_LIST = 3,
1059 CTDB_EVENT_COMMAND_SCRIPT_ENABLE = 4,
1060 CTDB_EVENT_COMMAND_SCRIPT_DISABLE = 5,
1061 };
1062
1063 enum ctdb_event_status_state {
1064 CTDB_EVENT_LAST_RUN = 1,
1065 CTDB_EVENT_LAST_PASS = 2,
1066 CTDB_EVENT_LAST_FAIL = 3,
1067 };
1068
1069 struct ctdb_event_request_run {
1070 enum ctdb_event event;
1071 uint32_t timeout;
1072 const char *arg_str;
1073 };
1074
1075 struct ctdb_event_request_status {
1076 enum ctdb_event event;
1077 enum ctdb_event_status_state state;
1078 };
1079
1080 struct ctdb_event_request_script_enable {
1081 const char *script_name;
1082 };
1083
1084 struct ctdb_event_request_script_disable {
1085 const char *script_name;
1086 };
1087
1088 struct ctdb_event_request_data {
1089 enum ctdb_event_command command;
1090 union {
1091 struct ctdb_event_request_run *run;
1092 struct ctdb_event_request_status *status;
1093 struct ctdb_event_request_script_enable *script_enable;
1094 struct ctdb_event_request_script_disable *script_disable;
1095 } data;
1096 };
1097
1098 struct ctdb_event_reply_status {
1099 int status;
1100 struct ctdb_script_list *script_list;
1101 };
1102
1103 struct ctdb_event_reply_script_list {
1104 struct ctdb_script_list *script_list;
1105 };
1106
1107 struct ctdb_event_reply_data {
1108 enum ctdb_event_command command;
1109 int32_t result;
1110 union {
1111 struct ctdb_event_reply_status *status;
1112 struct ctdb_event_reply_script_list *script_list;
1113 } data;
1114 };
1115
1116 struct ctdb_event_request {
1117 struct sock_packet_header header;
1118 struct ctdb_event_request_data rdata;
1119 };
1120
1121 struct ctdb_event_reply {
1122 struct sock_packet_header header;
1123 struct ctdb_event_reply_data rdata;
1124 };
1125
1126 #endif /* __CTDB_PROTOCOL_H__ */
Samba GIT mirror