2 CTDB protocol marshalling
4 Copyright (C) Amitay Isaacs 2015
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.
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.
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/>.
21 #include "system/network.h"
27 #include "protocol_api.h"
28 #include "protocol_private.h"
31 void ctdb_req_call_fill(struct ctdb_req_call *c,
32 uint32_t db_id, uint32_t flags,
33 uint32_t call_id, TDB_DATA key)
35 request->flags = flags;
39 c->calldata = tdb_null;
43 static int ctdb_reply_control_generic(struct ctdb_reply_control
*reply
,
46 if (reply
->rdata
.opcode
!= opcode
) {
53 /* CTDB_CONTROL_PROCESS_EXISTS */
55 void ctdb_req_control_process_exists(struct ctdb_req_control
*request
,
58 request
->opcode
= CTDB_CONTROL_PROCESS_EXISTS
;
61 request
->client_id
= 0;
64 request
->rdata
.opcode
= CTDB_CONTROL_PROCESS_EXISTS
;
65 request
->rdata
.data
.pid
= pid
;
69 int ctdb_reply_control_process_exists(struct ctdb_reply_control
*reply
,
72 if (reply
->rdata
.opcode
!= CTDB_CONTROL_PROCESS_EXISTS
) {
76 *status
= reply
->status
;
82 /* CTDB_CONTROL_STATISTICS */
84 void ctdb_req_control_statistics(struct ctdb_req_control
*request
)
86 request
->opcode
= CTDB_CONTROL_STATISTICS
;
89 request
->client_id
= 0;
92 request
->rdata
.opcode
= CTDB_CONTROL_STATISTICS
;
95 int ctdb_reply_control_statistics(struct ctdb_reply_control
*reply
,
97 struct ctdb_statistics
**stats
)
99 if (reply
->rdata
.opcode
!= CTDB_CONTROL_STATISTICS
) {
103 if (reply
->status
== 0) {
104 *stats
= talloc_steal(mem_ctx
, reply
->rdata
.data
.stats
);
106 return reply
->status
;
109 /* CTDB_CONTROL_PING */
111 void ctdb_req_control_ping(struct ctdb_req_control
*request
)
113 request
->opcode
= CTDB_CONTROL_PING
;
116 request
->client_id
= 0;
119 request
->rdata
.opcode
= CTDB_CONTROL_PING
;
122 int ctdb_reply_control_ping(struct ctdb_reply_control
*reply
,
125 if (reply
->rdata
.opcode
!= CTDB_CONTROL_PING
) {
129 if (reply
->status
>= 0) {
130 *num_clients
= reply
->status
;
133 return reply
->status
;
136 /* CTDB_CONTROL_GETDBPATH */
138 void ctdb_req_control_getdbpath(struct ctdb_req_control
*request
,
141 request
->opcode
= CTDB_CONTROL_GETDBPATH
;
144 request
->client_id
= 0;
147 request
->rdata
.opcode
= CTDB_CONTROL_GETDBPATH
;
148 request
->rdata
.data
.db_id
= db_id
;
151 int ctdb_reply_control_getdbpath(struct ctdb_reply_control
*reply
,
152 TALLOC_CTX
*mem_ctx
, const char **db_path
)
154 if (reply
->rdata
.opcode
!= CTDB_CONTROL_GETDBPATH
) {
158 if (reply
->status
== 0) {
159 *db_path
= talloc_steal(mem_ctx
, reply
->rdata
.data
.db_path
);
161 return reply
->status
;
164 /* CTDB_CONTROL_GETVNNMAP */
166 void ctdb_req_control_getvnnmap(struct ctdb_req_control
*request
)
168 request
->opcode
= CTDB_CONTROL_GETVNNMAP
;
171 request
->client_id
= 0;
174 request
->rdata
.opcode
= CTDB_CONTROL_GETVNNMAP
;
177 int ctdb_reply_control_getvnnmap(struct ctdb_reply_control
*reply
,
179 struct ctdb_vnn_map
**vnnmap
)
181 if (reply
->rdata
.opcode
!= CTDB_CONTROL_GETVNNMAP
) {
185 if (reply
->status
== 0) {
186 *vnnmap
= talloc_steal(mem_ctx
, reply
->rdata
.data
.vnnmap
);
188 return reply
->status
;
191 /* CTDB_CONTROL_SETVNNMAP */
193 void ctdb_req_control_setvnnmap(struct ctdb_req_control
*request
,
194 struct ctdb_vnn_map
*vnnmap
)
196 request
->opcode
= CTDB_CONTROL_SETVNNMAP
;
199 request
->client_id
= 0;
202 request
->rdata
.opcode
= CTDB_CONTROL_SETVNNMAP
;
203 request
->rdata
.data
.vnnmap
= vnnmap
;
206 int ctdb_reply_control_setvnnmap(struct ctdb_reply_control
*reply
)
208 return ctdb_reply_control_generic(reply
, CTDB_CONTROL_SETVNNMAP
);
211 /* CTDB_CONTROL_GET_DEBUG */
213 void ctdb_req_control_get_debug(struct ctdb_req_control
*request
)
215 request
->opcode
= CTDB_CONTROL_GET_DEBUG
;
218 request
->client_id
= 0;
221 request
->rdata
.opcode
= CTDB_CONTROL_GET_DEBUG
;
224 int ctdb_reply_control_get_debug(struct ctdb_reply_control
*reply
,
227 if (reply
->rdata
.opcode
!= CTDB_CONTROL_GET_DEBUG
) {
231 if (reply
->status
== 0) {
232 *loglevel
= (int)reply
->rdata
.data
.loglevel
;
234 return reply
->status
;
237 /* CTDB_CONTROL_SET_DEBUG */
239 void ctdb_req_control_set_debug(struct ctdb_req_control
*request
,
242 request
->opcode
= CTDB_CONTROL_SET_DEBUG
;
245 request
->client_id
= 0;
248 request
->rdata
.opcode
= CTDB_CONTROL_SET_DEBUG
;
249 request
->rdata
.data
.loglevel
= (uint32_t)loglevel
;
252 int ctdb_reply_control_set_debug(struct ctdb_reply_control
*reply
)
254 return ctdb_reply_control_generic(reply
, CTDB_CONTROL_SET_DEBUG
);
257 /* CTDB_CONTROL_GET_DBMAP */
259 void ctdb_req_control_get_dbmap(struct ctdb_req_control
*request
)
261 request
->opcode
= CTDB_CONTROL_GET_DBMAP
;
264 request
->client_id
= 0;
267 request
->rdata
.opcode
= CTDB_CONTROL_GET_DBMAP
;
270 int ctdb_reply_control_get_dbmap(struct ctdb_reply_control
*reply
,
272 struct ctdb_dbid_map
**dbmap
)
274 if (reply
->rdata
.opcode
!= CTDB_CONTROL_GET_DBMAP
) {
278 if (reply
->status
== 0) {
279 *dbmap
= talloc_steal(mem_ctx
, reply
->rdata
.data
.dbmap
);
281 return reply
->status
;
284 /* CTDB_CONTROL_GET_RECMODE */
286 void ctdb_req_control_get_recmode(struct ctdb_req_control
*request
)
288 request
->opcode
= CTDB_CONTROL_GET_RECMODE
;
291 request
->client_id
= 0;
294 request
->rdata
.opcode
= CTDB_CONTROL_GET_RECMODE
;
297 int ctdb_reply_control_get_recmode(struct ctdb_reply_control
*reply
,
300 if (reply
->rdata
.opcode
!= CTDB_CONTROL_GET_RECMODE
) {
304 if (reply
->status
>= 0) {
305 *recmode
= reply
->status
;
308 return reply
->status
;
311 /* CTDB_CONTROL_SET_RECMODE */
313 void ctdb_req_control_set_recmode(struct ctdb_req_control
*request
,
316 request
->opcode
= CTDB_CONTROL_SET_RECMODE
;
319 request
->client_id
= 0;
322 request
->rdata
.opcode
= CTDB_CONTROL_SET_RECMODE
;
323 request
->rdata
.data
.recmode
= recmode
;
326 int ctdb_reply_control_set_recmode(struct ctdb_reply_control
*reply
)
328 return ctdb_reply_control_generic(reply
, CTDB_CONTROL_SET_RECMODE
);
331 /* CTDB_CONTROL_STATISTICS_RESET */
333 void ctdb_req_control_statistics_reset(struct ctdb_req_control
*request
)
335 request
->opcode
= CTDB_CONTROL_STATISTICS_RESET
;
338 request
->client_id
= 0;
341 request
->rdata
.opcode
= CTDB_CONTROL_STATISTICS_RESET
;
344 int ctdb_reply_control_statistics_reset(struct ctdb_reply_control
*reply
)
346 return ctdb_reply_control_generic(reply
,
347 CTDB_CONTROL_STATISTICS_RESET
);
350 /* CTDB_CONTROL_DB_ATTACH */
352 void ctdb_req_control_db_attach(struct ctdb_req_control
*request
,
355 request
->opcode
= CTDB_CONTROL_DB_ATTACH
;
358 request
->client_id
= 0;
361 request
->rdata
.opcode
= CTDB_CONTROL_DB_ATTACH
;
362 request
->rdata
.data
.db_name
= db_name
;
365 int ctdb_reply_control_db_attach(struct ctdb_reply_control
*reply
,
368 if (reply
->rdata
.opcode
!= CTDB_CONTROL_DB_ATTACH
) {
372 if (reply
->status
== 0) {
373 *db_id
= reply
->rdata
.data
.db_id
;
375 return reply
->status
;
378 /* CTDB_CONTROL_TRAVERSE_START */
380 void ctdb_req_control_traverse_start(struct ctdb_req_control
*request
,
381 struct ctdb_traverse_start
*traverse
)
383 request
->opcode
= CTDB_CONTROL_TRAVERSE_START
;
386 request
->client_id
= 0;
389 request
->rdata
.opcode
= CTDB_CONTROL_TRAVERSE_START
;
390 request
->rdata
.data
.traverse_start
= traverse
;
393 int ctdb_reply_control_traverse_start(struct ctdb_reply_control
*reply
)
395 return ctdb_reply_control_generic(reply
, CTDB_CONTROL_TRAVERSE_START
);
398 /* CTDB_CONTROL_TRAVERSE_ALL */
399 /* CTDB_CONTROL_TRAVERSE_DATA */
401 /* CTDB_CONTROL_REGISTER_SRVID */
403 void ctdb_req_control_register_srvid(struct ctdb_req_control
*request
,
406 request
->opcode
= CTDB_CONTROL_REGISTER_SRVID
;
408 request
->srvid
= srvid
;
409 request
->client_id
= 0;
412 request
->rdata
.opcode
= CTDB_CONTROL_REGISTER_SRVID
;
415 int ctdb_reply_control_register_srvid(struct ctdb_reply_control
*reply
)
417 return ctdb_reply_control_generic(reply
, CTDB_CONTROL_REGISTER_SRVID
);
420 /* CTDB_CONTROL_DEREGISTER_SRVID */
422 void ctdb_req_control_deregister_srvid(struct ctdb_req_control
*request
,
425 request
->opcode
= CTDB_CONTROL_DEREGISTER_SRVID
;
427 request
->srvid
= srvid
;
428 request
->client_id
= 0;
431 request
->rdata
.opcode
= CTDB_CONTROL_DEREGISTER_SRVID
;
434 int ctdb_reply_control_deregister_srvid(struct ctdb_reply_control
*reply
)
436 return ctdb_reply_control_generic(reply
,
437 CTDB_CONTROL_DEREGISTER_SRVID
);
440 /* CTDB_CONTROL_GET_DBNAME */
442 void ctdb_req_control_get_dbname(struct ctdb_req_control
*request
,
445 request
->opcode
= CTDB_CONTROL_GET_DBNAME
;
448 request
->client_id
= 0;
451 request
->rdata
.opcode
= CTDB_CONTROL_GET_DBNAME
;
452 request
->rdata
.data
.db_id
= db_id
;
455 int ctdb_reply_control_get_dbname(struct ctdb_reply_control
*reply
,
456 TALLOC_CTX
*mem_ctx
, const char **db_name
)
458 if (reply
->rdata
.opcode
!= CTDB_CONTROL_GET_DBNAME
) {
462 if (reply
->status
== 0) {
463 *db_name
= talloc_steal(mem_ctx
, reply
->rdata
.data
.db_name
);
465 return reply
->status
;
468 /* CTDB_CONTROL_ENABLE_SEQNUM */
470 void ctdb_req_control_enable_seqnum(struct ctdb_req_control
*request
,
473 request
->opcode
= CTDB_CONTROL_ENABLE_SEQNUM
;
476 request
->client_id
= 0;
479 request
->rdata
.opcode
= CTDB_CONTROL_ENABLE_SEQNUM
;
480 request
->rdata
.data
.db_id
= db_id
;
483 int ctdb_reply_control_enable_seqnum(struct ctdb_reply_control
*reply
)
485 return ctdb_reply_control_generic(reply
, CTDB_CONTROL_ENABLE_SEQNUM
);
488 /* CTDB_CONTROL_UPDATE_SEQNUM */
490 void ctdb_req_control_update_seqnum(struct ctdb_req_control
*request
,
493 request
->opcode
= CTDB_CONTROL_UPDATE_SEQNUM
;
496 request
->client_id
= 0;
499 request
->rdata
.opcode
= CTDB_CONTROL_UPDATE_SEQNUM
;
500 request
->rdata
.data
.db_id
= db_id
;
503 int ctdb_reply_control_update_seqnum(struct ctdb_reply_control
*reply
)
505 return ctdb_reply_control_generic(reply
, CTDB_CONTROL_UPDATE_SEQNUM
);
508 /* CTDB_CONTROL_DUMP_MEMORY */
510 void ctdb_req_control_dump_memory(struct ctdb_req_control
*request
)
512 request
->opcode
= CTDB_CONTROL_DUMP_MEMORY
;
515 request
->client_id
= 0;
518 request
->rdata
.opcode
= CTDB_CONTROL_DUMP_MEMORY
;
521 int ctdb_reply_control_dump_memory(struct ctdb_reply_control
*reply
,
522 TALLOC_CTX
*mem_ctx
, const char **mem_str
)
524 if (reply
->rdata
.opcode
!= CTDB_CONTROL_DUMP_MEMORY
) {
528 if (reply
->status
== 0) {
529 *mem_str
= talloc_steal(mem_ctx
, reply
->rdata
.data
.mem_str
);
531 return reply
->status
;
534 /* CTDB_CONTROL_GET_PID */
536 void ctdb_req_control_get_pid(struct ctdb_req_control
*request
)
538 request
->opcode
= CTDB_CONTROL_GET_PID
;
541 request
->client_id
= 0;
544 request
->rdata
.opcode
= CTDB_CONTROL_GET_PID
;
547 int ctdb_reply_control_get_pid(struct ctdb_reply_control
*reply
,
550 if (reply
->rdata
.opcode
!= CTDB_CONTROL_GET_PID
) {
554 *pid
= reply
->status
;
557 return reply
->status
;
560 /* CTDB_CONTROL_GET_RECMASTER */
562 void ctdb_req_control_get_recmaster(struct ctdb_req_control
*request
)
564 request
->opcode
= CTDB_CONTROL_GET_RECMASTER
;
567 request
->client_id
= 0;
570 request
->rdata
.opcode
= CTDB_CONTROL_GET_RECMASTER
;
573 int ctdb_reply_control_get_recmaster(struct ctdb_reply_control
*reply
,
576 if (reply
->rdata
.opcode
!= CTDB_CONTROL_GET_RECMASTER
) {
580 *recmaster
= reply
->status
;
583 return reply
->status
;
586 /* CTDB_CONTROL_SET_RECMASTER */
588 void ctdb_req_control_set_recmaster(struct ctdb_req_control
*request
,
591 request
->opcode
= CTDB_CONTROL_SET_RECMASTER
;
594 request
->client_id
= 0;
597 request
->rdata
.opcode
= CTDB_CONTROL_SET_RECMASTER
;
598 request
->rdata
.data
.recmaster
= recmaster
;
601 int ctdb_reply_control_set_recmaster(struct ctdb_reply_control
*reply
)
603 return ctdb_reply_control_generic(reply
, CTDB_CONTROL_SET_RECMASTER
);
606 /* CTDB_CONTROL_FREEZE */
608 void ctdb_req_control_freeze(struct ctdb_req_control
*request
,
611 request
->opcode
= CTDB_CONTROL_FREEZE
;
613 request
->srvid
= priority
;
614 request
->client_id
= 0;
617 request
->rdata
.opcode
= CTDB_CONTROL_FREEZE
;
620 int ctdb_reply_control_freeze(struct ctdb_reply_control
*reply
)
622 return ctdb_reply_control_generic(reply
, CTDB_CONTROL_FREEZE
);
625 /* CTDB_CONTROL_GET_PNN */
627 void ctdb_req_control_get_pnn(struct ctdb_req_control
*request
)
629 request
->opcode
= CTDB_CONTROL_GET_PNN
;
632 request
->client_id
= 0;
635 request
->rdata
.opcode
= CTDB_CONTROL_GET_PNN
;
638 int ctdb_reply_control_get_pnn(struct ctdb_reply_control
*reply
,
641 if (reply
->rdata
.opcode
!= CTDB_CONTROL_GET_PNN
) {
645 if (reply
->status
>= 0) {
646 *pnn
= reply
->status
;
649 return reply
->status
;
652 /* CTDB_CONTROL_SHUTDOWN */
654 void ctdb_req_control_shutdown(struct ctdb_req_control
*request
)
656 request
->opcode
= CTDB_CONTROL_SHUTDOWN
;
659 request
->client_id
= 0;
660 request
->flags
= CTDB_CTRL_FLAG_NOREPLY
;
662 request
->rdata
.opcode
= CTDB_CONTROL_SHUTDOWN
;
665 int ctdb_reply_control_shutdown(struct ctdb_reply_control
*reply
)
667 return ctdb_reply_control_generic(reply
, CTDB_CONTROL_SHUTDOWN
);
670 /* CTDB_CONTROL_TCP_CLIENT */
672 void ctdb_req_control_tcp_client(struct ctdb_req_control
*request
,
673 struct ctdb_connection
*conn
)
675 request
->opcode
= CTDB_CONTROL_TCP_CLIENT
;
678 request
->client_id
= 0;
681 request
->rdata
.opcode
= CTDB_CONTROL_TCP_CLIENT
;
682 request
->rdata
.data
.conn
= conn
;
685 int ctdb_reply_control_tcp_client(struct ctdb_reply_control
*reply
)
687 return ctdb_reply_control_generic(reply
, CTDB_CONTROL_TCP_CLIENT
);
690 /* CTDB_CONTROL_TCP_ADD */
692 void ctdb_req_control_tcp_add(struct ctdb_req_control
*request
,
693 struct ctdb_connection
*conn
)
695 request
->opcode
= CTDB_CONTROL_TCP_ADD
;
698 request
->client_id
= 0;
701 request
->rdata
.opcode
= CTDB_CONTROL_TCP_ADD
;
702 request
->rdata
.data
.conn
= conn
;
705 int ctdb_reply_control_tcp_add(struct ctdb_reply_control
*reply
)
707 return ctdb_reply_control_generic(reply
, CTDB_CONTROL_TCP_ADD
);
710 /* CTDB_CONTROL_TCP_REMOVE */
712 void ctdb_req_control_tcp_remove(struct ctdb_req_control
*request
,
713 struct ctdb_connection
*conn
)
715 request
->opcode
= CTDB_CONTROL_TCP_REMOVE
;
718 request
->client_id
= 0;
721 request
->rdata
.opcode
= CTDB_CONTROL_TCP_REMOVE
;
722 request
->rdata
.data
.conn
= conn
;
725 int ctdb_reply_control_tcp_remove(struct ctdb_reply_control
*reply
)
727 return ctdb_reply_control_generic(reply
, CTDB_CONTROL_TCP_REMOVE
);
730 /* CTDB_CONTROL_STARTUP */
732 void ctdb_req_control_startup(struct ctdb_req_control
*request
)
734 request
->opcode
= CTDB_CONTROL_STARTUP
;
737 request
->client_id
= 0;
740 request
->rdata
.opcode
= CTDB_CONTROL_STARTUP
;
743 int ctdb_reply_control_startup(struct ctdb_reply_control
*reply
)
745 return ctdb_reply_control_generic(reply
, CTDB_CONTROL_STARTUP
);
748 /* CTDB_CONTROL_SET_TUNABLE */
750 void ctdb_req_control_set_tunable(struct ctdb_req_control
*request
,
751 struct ctdb_tunable
*tunable
)
753 request
->opcode
= CTDB_CONTROL_SET_TUNABLE
;
756 request
->client_id
= 0;
759 request
->rdata
.opcode
= CTDB_CONTROL_SET_TUNABLE
;
760 request
->rdata
.data
.tunable
= tunable
;
763 int ctdb_reply_control_set_tunable(struct ctdb_reply_control
*reply
)
765 return ctdb_reply_control_generic(reply
, CTDB_CONTROL_SET_TUNABLE
);
768 /* CTDB_CONTROL_GET_TUNABLE */
770 void ctdb_req_control_get_tunable(struct ctdb_req_control
*request
,
773 request
->opcode
= CTDB_CONTROL_GET_TUNABLE
;
776 request
->client_id
= 0;
779 request
->rdata
.opcode
= CTDB_CONTROL_GET_TUNABLE
;
780 request
->rdata
.data
.tun_var
= discard_const(name
);
783 int ctdb_reply_control_get_tunable(struct ctdb_reply_control
*reply
,
786 if (reply
->rdata
.opcode
!= CTDB_CONTROL_GET_TUNABLE
) {
790 if (reply
->status
== 0) {
791 *value
= reply
->rdata
.data
.tun_value
;
793 return reply
->status
;
796 /* CTDB_CONTROL_LIST_TUNABLES */
798 void ctdb_req_control_list_tunables(struct ctdb_req_control
*request
)
800 request
->opcode
= CTDB_CONTROL_LIST_TUNABLES
;
803 request
->client_id
= 0;
806 request
->rdata
.opcode
= CTDB_CONTROL_LIST_TUNABLES
;
809 int ctdb_reply_control_list_tunables(struct ctdb_reply_control
*reply
,
811 struct ctdb_var_list
**tun_var_list
)
813 if (reply
->rdata
.opcode
!= CTDB_CONTROL_LIST_TUNABLES
) {
817 if (reply
->status
== 0) {
818 *tun_var_list
= talloc_steal(mem_ctx
,
819 reply
->rdata
.data
.tun_var_list
);
821 return reply
->status
;
824 /* CTDB_CONTROL_MODIFY_FLAGS */
826 void ctdb_req_control_modify_flags(struct ctdb_req_control
*request
,
827 struct ctdb_node_flag_change
*flag_change
)
829 request
->opcode
= CTDB_CONTROL_MODIFY_FLAGS
;
832 request
->client_id
= 0;
835 request
->rdata
.opcode
= CTDB_CONTROL_MODIFY_FLAGS
;
836 request
->rdata
.data
.flag_change
= flag_change
;
839 int ctdb_reply_control_modify_flags(struct ctdb_reply_control
*reply
)
841 return ctdb_reply_control_generic(reply
, CTDB_CONTROL_MODIFY_FLAGS
);
844 /* CTDB_CONTROL_GET_ALL_TUNABLES */
846 void ctdb_req_control_get_all_tunables(struct ctdb_req_control
*request
)
848 request
->opcode
= CTDB_CONTROL_GET_ALL_TUNABLES
;
851 request
->client_id
= 0;
854 request
->rdata
.opcode
= CTDB_CONTROL_GET_ALL_TUNABLES
;
857 int ctdb_reply_control_get_all_tunables(struct ctdb_reply_control
*reply
,
859 struct ctdb_tunable_list
**tun_list
)
861 if (reply
->rdata
.opcode
!= CTDB_CONTROL_GET_ALL_TUNABLES
) {
865 if (reply
->status
== 0) {
866 *tun_list
= talloc_steal(mem_ctx
, reply
->rdata
.data
.tun_list
);
868 return reply
->status
;
871 /* CTDB_CONTROL_GET_TCP_TICKLE_LIST */
873 void ctdb_req_control_get_tcp_tickle_list(struct ctdb_req_control
*request
,
874 ctdb_sock_addr
*addr
)
876 request
->opcode
= CTDB_CONTROL_GET_TCP_TICKLE_LIST
;
879 request
->client_id
= 0;
882 request
->rdata
.opcode
= CTDB_CONTROL_GET_TCP_TICKLE_LIST
;
883 request
->rdata
.data
.addr
= addr
;
886 int ctdb_reply_control_get_tcp_tickle_list(struct ctdb_reply_control
*reply
,
888 struct ctdb_tickle_list
**tickles
)
890 if (reply
->rdata
.opcode
!= CTDB_CONTROL_GET_TCP_TICKLE_LIST
) {
894 if (reply
->status
== 0) {
895 *tickles
= talloc_steal(mem_ctx
, reply
->rdata
.data
.tickles
);
897 return reply
->status
;
900 /* CTDB_CONTROL_SET_TCP_TICKLE_LIST */
902 void ctdb_req_control_set_tcp_tickle_list(struct ctdb_req_control
*request
,
903 struct ctdb_tickle_list
*tickles
)
905 request
->opcode
= CTDB_CONTROL_SET_TCP_TICKLE_LIST
;
908 request
->client_id
= 0;
911 request
->rdata
.opcode
= CTDB_CONTROL_SET_TCP_TICKLE_LIST
;
912 request
->rdata
.data
.tickles
= tickles
;
915 int ctdb_reply_control_set_tcp_tickle_list(struct ctdb_reply_control
*reply
)
917 return ctdb_reply_control_generic(reply
,
918 CTDB_CONTROL_SET_TCP_TICKLE_LIST
);
921 /* CTDB_CONTROL_DB_ATTACH_PERSISTENT */
923 void ctdb_req_control_db_attach_persistent(struct ctdb_req_control
*request
,
926 request
->opcode
= CTDB_CONTROL_DB_ATTACH_PERSISTENT
;
929 request
->client_id
= 0;
932 request
->rdata
.opcode
= CTDB_CONTROL_DB_ATTACH_PERSISTENT
;
933 request
->rdata
.data
.db_name
= db_name
;
936 int ctdb_reply_control_db_attach_persistent(struct ctdb_reply_control
*reply
,
939 if (reply
->rdata
.opcode
!= CTDB_CONTROL_DB_ATTACH_PERSISTENT
) {
943 if (reply
->status
== 0) {
944 *db_id
= reply
->rdata
.data
.db_id
;
946 return reply
->status
;
949 /* CTDB_CONTROL_UPDATE_RECORD */
951 void ctdb_req_control_update_record(struct ctdb_req_control
*request
,
952 struct ctdb_rec_buffer
*recbuf
)
954 request
->opcode
= CTDB_CONTROL_UPDATE_RECORD
;
957 request
->client_id
= 0;
960 request
->rdata
.opcode
= CTDB_CONTROL_UPDATE_RECORD
;
961 request
->rdata
.data
.recbuf
= recbuf
;
964 int ctdb_reply_control_update_record(struct ctdb_reply_control
*reply
)
966 return ctdb_reply_control_generic(reply
, CTDB_CONTROL_UPDATE_RECORD
);
969 /* CTDB_CONTROL_SEND_GRATUITOUS_ARP */
971 void ctdb_req_control_send_gratuitous_arp(struct ctdb_req_control
*request
,
972 struct ctdb_addr_info
*addr_info
)
974 request
->opcode
= CTDB_CONTROL_SEND_GRATUITOUS_ARP
;
977 request
->client_id
= 0;
980 request
->rdata
.opcode
= CTDB_CONTROL_SEND_GRATUITOUS_ARP
;
981 request
->rdata
.data
.addr_info
= addr_info
;
984 int ctdb_reply_control_send_gratuitous_arp(struct ctdb_reply_control
*reply
)
986 return ctdb_reply_control_generic(reply
,
987 CTDB_CONTROL_SEND_GRATUITOUS_ARP
);
990 /* CTDB_CONTROL_WIPE_DATABASE */
992 void ctdb_req_control_wipe_database(struct ctdb_req_control
*request
,
993 struct ctdb_transdb
*transdb
)
995 request
->opcode
= CTDB_CONTROL_WIPE_DATABASE
;
998 request
->client_id
= 0;
1001 request
->rdata
.opcode
= CTDB_CONTROL_WIPE_DATABASE
;
1002 request
->rdata
.data
.transdb
= transdb
;
1005 int ctdb_reply_control_wipe_database(struct ctdb_reply_control
*reply
)
1007 return ctdb_reply_control_generic(reply
, CTDB_CONTROL_WIPE_DATABASE
);
1010 /* CTDB_CONTROL_UPTIME */
1012 void ctdb_req_control_uptime(struct ctdb_req_control
*request
)
1014 request
->opcode
= CTDB_CONTROL_UPTIME
;
1017 request
->client_id
= 0;
1020 request
->rdata
.opcode
= CTDB_CONTROL_UPTIME
;
1023 int ctdb_reply_control_uptime(struct ctdb_reply_control
*reply
,
1024 TALLOC_CTX
*mem_ctx
, struct ctdb_uptime
**uptime
)
1026 if (reply
->rdata
.opcode
!= CTDB_CONTROL_UPTIME
) {
1030 if (reply
->status
== 0) {
1031 *uptime
= talloc_steal(mem_ctx
, reply
->rdata
.data
.uptime
);
1033 return reply
->status
;
1036 /* CTDB_CONTROL_START_RECOVERY */
1038 void ctdb_req_control_start_recovery(struct ctdb_req_control
*request
)
1040 request
->opcode
= CTDB_CONTROL_START_RECOVERY
;
1043 request
->client_id
= 0;
1046 request
->rdata
.opcode
= CTDB_CONTROL_START_RECOVERY
;
1049 int ctdb_reply_control_start_recovery(struct ctdb_reply_control
*reply
)
1051 return ctdb_reply_control_generic(reply
, CTDB_CONTROL_START_RECOVERY
);
1054 /* CTDB_CONTROL_END_RECOVERY */
1056 void ctdb_req_control_end_recovery(struct ctdb_req_control
*request
)
1058 request
->opcode
= CTDB_CONTROL_END_RECOVERY
;
1061 request
->client_id
= 0;
1064 request
->rdata
.opcode
= CTDB_CONTROL_END_RECOVERY
;
1067 int ctdb_reply_control_end_recovery(struct ctdb_reply_control
*reply
)
1069 return ctdb_reply_control_generic(reply
, CTDB_CONTROL_END_RECOVERY
);
1072 /* CTDB_CONTROL_RELOAD_NODES_FILE */
1074 void ctdb_req_control_reload_nodes_file(struct ctdb_req_control
*request
)
1076 request
->opcode
= CTDB_CONTROL_RELOAD_NODES_FILE
;
1079 request
->client_id
= 0;
1082 request
->rdata
.opcode
= CTDB_CONTROL_RELOAD_NODES_FILE
;
1085 int ctdb_reply_control_reload_nodes_file(struct ctdb_reply_control
*reply
)
1087 return ctdb_reply_control_generic(reply
,
1088 CTDB_CONTROL_RELOAD_NODES_FILE
);
1091 /* CTDB_CONTROL_TRY_DELETE_RECORDS */
1093 void ctdb_req_control_try_delete_records(struct ctdb_req_control
*request
,
1094 struct ctdb_rec_buffer
*recbuf
)
1096 request
->opcode
= CTDB_CONTROL_TRY_DELETE_RECORDS
;
1099 request
->client_id
= 0;
1102 request
->rdata
.opcode
= CTDB_CONTROL_TRY_DELETE_RECORDS
;
1103 request
->rdata
.data
.recbuf
= recbuf
;
1106 int ctdb_reply_control_try_delete_records(struct ctdb_reply_control
*reply
,
1107 TALLOC_CTX
*mem_ctx
,
1108 struct ctdb_rec_buffer
**recbuf
)
1110 if (reply
->rdata
.opcode
!= CTDB_CONTROL_TRY_DELETE_RECORDS
) {
1114 if (reply
->status
== 0) {
1115 *recbuf
= talloc_steal(mem_ctx
, reply
->rdata
.data
.recbuf
);
1117 return reply
->status
;
1120 /* CTDB_CONTROL_ADD_PUBLIC_IP */
1122 void ctdb_req_control_add_public_ip(struct ctdb_req_control
*request
,
1123 struct ctdb_addr_info
*addr_info
)
1125 request
->opcode
= CTDB_CONTROL_ADD_PUBLIC_IP
;
1128 request
->client_id
= 0;
1131 request
->rdata
.opcode
= CTDB_CONTROL_ADD_PUBLIC_IP
;
1132 request
->rdata
.data
.addr_info
= addr_info
;
1135 int ctdb_reply_control_add_public_ip(struct ctdb_reply_control
*reply
)
1137 return ctdb_reply_control_generic(reply
, CTDB_CONTROL_ADD_PUBLIC_IP
);
1140 /* CTDB_CONTROL_DEL_PUBLIC_IP */
1142 void ctdb_req_control_del_public_ip(struct ctdb_req_control
*request
,
1143 struct ctdb_addr_info
*addr_info
)
1145 request
->opcode
= CTDB_CONTROL_DEL_PUBLIC_IP
;
1148 request
->client_id
= 0;
1151 request
->rdata
.opcode
= CTDB_CONTROL_DEL_PUBLIC_IP
;
1152 request
->rdata
.data
.addr_info
= addr_info
;
1155 int ctdb_reply_control_del_public_ip(struct ctdb_reply_control
*reply
)
1157 return ctdb_reply_control_generic(reply
, CTDB_CONTROL_DEL_PUBLIC_IP
);
1160 /* CTDB_CONTROL_GET_CAPABILITIES */
1162 void ctdb_req_control_get_capabilities(struct ctdb_req_control
*request
)
1164 request
->opcode
= CTDB_CONTROL_GET_CAPABILITIES
;
1167 request
->client_id
= 0;
1170 request
->rdata
.opcode
= CTDB_CONTROL_GET_CAPABILITIES
;
1173 int ctdb_reply_control_get_capabilities(struct ctdb_reply_control
*reply
,
1176 if (reply
->rdata
.opcode
!= CTDB_CONTROL_GET_CAPABILITIES
) {
1180 if (reply
->status
== 0) {
1181 *caps
= reply
->rdata
.data
.caps
;
1183 return reply
->status
;
1186 /* CTDB_CONTROL_RECD_PING */
1188 void ctdb_req_control_recd_ping(struct ctdb_req_control
*request
)
1190 request
->opcode
= CTDB_CONTROL_RECD_PING
;
1193 request
->client_id
= 0;
1196 request
->rdata
.opcode
= CTDB_CONTROL_RECD_PING
;
1199 int ctdb_reply_control_recd_ping(struct ctdb_reply_control
*reply
)
1201 return ctdb_reply_control_generic(reply
, CTDB_CONTROL_RECD_PING
);
1204 /* CTDB_CONTROL_RELEASE_IP */
1206 void ctdb_req_control_release_ip(struct ctdb_req_control
*request
,
1207 struct ctdb_public_ip
*pubip
)
1209 request
->opcode
= CTDB_CONTROL_RELEASE_IP
;
1212 request
->client_id
= 0;
1215 request
->rdata
.opcode
= CTDB_CONTROL_RELEASE_IP
;
1216 request
->rdata
.data
.pubip
= pubip
;
1219 int ctdb_reply_control_release_ip(struct ctdb_reply_control
*reply
)
1221 return ctdb_reply_control_generic(reply
, CTDB_CONTROL_RELEASE_IP
);
1224 /* CTDB_CONTROL_TAKEOVER_IP */
1226 void ctdb_req_control_takeover_ip(struct ctdb_req_control
*request
,
1227 struct ctdb_public_ip
*pubip
)
1229 request
->opcode
= CTDB_CONTROL_TAKEOVER_IP
;
1232 request
->client_id
= 0;
1235 request
->rdata
.opcode
= CTDB_CONTROL_TAKEOVER_IP
;
1236 request
->rdata
.data
.pubip
= pubip
;
1239 int ctdb_reply_control_takeover_ip(struct ctdb_reply_control
*reply
)
1241 return ctdb_reply_control_generic(reply
, CTDB_CONTROL_TAKEOVER_IP
);
1244 /* CTDB_CONTROL_GET_PUBLIC_IPS */
1246 void ctdb_req_control_get_public_ips(struct ctdb_req_control
*request
,
1247 bool available_only
)
1249 request
->opcode
= CTDB_CONTROL_GET_PUBLIC_IPS
;
1252 request
->client_id
= 0;
1255 request
->rdata
.opcode
= CTDB_CONTROL_GET_PUBLIC_IPS
;
1256 if (available_only
) {
1257 request
->flags
= CTDB_PUBLIC_IP_FLAGS_ONLY_AVAILABLE
;
1261 int ctdb_reply_control_get_public_ips(struct ctdb_reply_control
*reply
,
1262 TALLOC_CTX
*mem_ctx
,
1263 struct ctdb_public_ip_list
**pubip_list
)
1265 if (reply
->rdata
.opcode
!= CTDB_CONTROL_GET_PUBLIC_IPS
) {
1269 if (reply
->status
== 0) {
1270 *pubip_list
= talloc_steal(mem_ctx
,
1271 reply
->rdata
.data
.pubip_list
);
1273 return reply
->status
;
1276 /* CTDB_CONTROL_GET_NODEMAP */
1278 void ctdb_req_control_get_nodemap(struct ctdb_req_control
*request
)
1280 request
->opcode
= CTDB_CONTROL_GET_NODEMAP
;
1283 request
->client_id
= 0;
1286 request
->rdata
.opcode
= CTDB_CONTROL_GET_NODEMAP
;
1289 int ctdb_reply_control_get_nodemap(struct ctdb_reply_control
*reply
,
1290 TALLOC_CTX
*mem_ctx
,
1291 struct ctdb_node_map
**nodemap
)
1293 if (reply
->rdata
.opcode
!= CTDB_CONTROL_GET_NODEMAP
) {
1297 if (reply
->status
== 0) {
1298 *nodemap
= talloc_steal(mem_ctx
, reply
->rdata
.data
.nodemap
);
1300 return reply
->status
;
1303 /* CTDB_CONTROL_TRAVERSE_KILL */
1305 void ctdb_req_control_traverse_kill(struct ctdb_req_control
*request
,
1306 struct ctdb_traverse_start
*traverse
)
1308 request
->opcode
= CTDB_CONTROL_TRAVERSE_KILL
;
1311 request
->client_id
= 0;
1314 request
->rdata
.opcode
= CTDB_CONTROL_TRAVERSE_KILL
;
1315 request
->rdata
.data
.traverse_start
= traverse
;
1318 int ctdb_reply_control_traverse_kill(struct ctdb_reply_control
*reply
)
1320 return ctdb_reply_control_generic(reply
, CTDB_CONTROL_TRAVERSE_KILL
);
1323 /* CTDB_CONTROL_RECD_RECLOCK_LATENCY */
1325 void ctdb_req_control_recd_reclock_latency(struct ctdb_req_control
*request
,
1326 double reclock_latency
)
1328 request
->opcode
= CTDB_CONTROL_RECD_RECLOCK_LATENCY
;
1331 request
->client_id
= 0;
1334 request
->rdata
.opcode
= CTDB_CONTROL_RECD_RECLOCK_LATENCY
;
1335 request
->rdata
.data
.reclock_latency
= reclock_latency
;
1338 int ctdb_reply_control_recd_reclock_latency(struct ctdb_reply_control
*reply
)
1340 return ctdb_reply_control_generic(reply
,
1341 CTDB_CONTROL_RECD_RECLOCK_LATENCY
);
1344 /* CTDB_CONTROL_GET_RECLOCK_FILE */
1346 void ctdb_req_control_get_reclock_file(struct ctdb_req_control
*request
)
1348 request
->opcode
= CTDB_CONTROL_GET_RECLOCK_FILE
;
1351 request
->client_id
= 0;
1354 request
->rdata
.opcode
= CTDB_CONTROL_GET_RECLOCK_FILE
;
1357 int ctdb_reply_control_get_reclock_file(struct ctdb_reply_control
*reply
,
1358 TALLOC_CTX
*mem_ctx
,
1359 const char **reclock_file
)
1361 if (reply
->rdata
.opcode
!= CTDB_CONTROL_GET_RECLOCK_FILE
) {
1365 if (reply
->status
== 0) {
1366 *reclock_file
= talloc_steal(mem_ctx
,
1367 reply
->rdata
.data
.reclock_file
);
1369 return reply
->status
;
1372 /* CTDB_CONTROL_STOP_NODE */
1374 void ctdb_req_control_stop_node(struct ctdb_req_control
*request
)
1376 request
->opcode
= CTDB_CONTROL_STOP_NODE
;
1379 request
->client_id
= 0;
1382 request
->rdata
.opcode
= CTDB_CONTROL_STOP_NODE
;
1385 int ctdb_reply_control_stop_node(struct ctdb_reply_control
*reply
)
1387 return ctdb_reply_control_generic(reply
, CTDB_CONTROL_STOP_NODE
);
1390 /* CTDB_CONTROL_CONTINUE_NODE */
1392 void ctdb_req_control_continue_node(struct ctdb_req_control
*request
)
1394 request
->opcode
= CTDB_CONTROL_CONTINUE_NODE
;
1397 request
->client_id
= 0;
1400 request
->rdata
.opcode
= CTDB_CONTROL_CONTINUE_NODE
;
1403 int ctdb_reply_control_continue_node(struct ctdb_reply_control
*reply
)
1405 return ctdb_reply_control_generic(reply
, CTDB_CONTROL_CONTINUE_NODE
);
1408 /* CTDB_CONTROL_SET_LMASTERROLE */
1410 void ctdb_req_control_set_lmasterrole(struct ctdb_req_control
*request
,
1411 uint32_t lmaster_role
)
1413 request
->opcode
= CTDB_CONTROL_SET_LMASTERROLE
;
1416 request
->client_id
= 0;
1419 request
->rdata
.opcode
= CTDB_CONTROL_SET_LMASTERROLE
;
1420 request
->rdata
.data
.role
= lmaster_role
;
1423 int ctdb_reply_control_set_lmasterrole(struct ctdb_reply_control
*reply
)
1425 return ctdb_reply_control_generic(reply
, CTDB_CONTROL_SET_LMASTERROLE
);
1428 /* CTDB_CONTROL_SET_RECMASTERROLE */
1430 void ctdb_req_control_set_recmasterrole(struct ctdb_req_control
*request
,
1431 uint32_t recmaster_role
)
1433 request
->opcode
= CTDB_CONTROL_SET_RECMASTERROLE
;
1436 request
->client_id
= 0;
1439 request
->rdata
.opcode
= CTDB_CONTROL_SET_RECMASTERROLE
;
1440 request
->rdata
.data
.role
= recmaster_role
;
1443 int ctdb_reply_control_set_recmasterrole(struct ctdb_reply_control
*reply
)
1445 return ctdb_reply_control_generic(reply
,
1446 CTDB_CONTROL_SET_RECMASTERROLE
);
1449 /* CTDB_CONTROL_SET_BAN_STATE */
1451 void ctdb_req_control_set_ban_state(struct ctdb_req_control
*request
,
1452 struct ctdb_ban_state
*ban_state
)
1454 request
->opcode
= CTDB_CONTROL_SET_BAN_STATE
;
1457 request
->client_id
= 0;
1460 request
->rdata
.opcode
= CTDB_CONTROL_SET_BAN_STATE
;
1461 request
->rdata
.data
.ban_state
= ban_state
;
1464 int ctdb_reply_control_set_ban_state(struct ctdb_reply_control
*reply
)
1466 return ctdb_reply_control_generic(reply
, CTDB_CONTROL_SET_BAN_STATE
);
1469 /* CTDB_CONTROL_GET_BAN_STATE */
1471 void ctdb_req_control_get_ban_state(struct ctdb_req_control
*request
)
1473 request
->opcode
= CTDB_CONTROL_GET_BAN_STATE
;
1476 request
->client_id
= 0;
1479 request
->rdata
.opcode
= CTDB_CONTROL_GET_BAN_STATE
;
1482 int ctdb_reply_control_get_ban_state(struct ctdb_reply_control
*reply
,
1483 TALLOC_CTX
*mem_ctx
,
1484 struct ctdb_ban_state
**ban_state
)
1486 if (reply
->rdata
.opcode
!= CTDB_CONTROL_GET_BAN_STATE
) {
1490 if (reply
->status
== 0) {
1491 *ban_state
= talloc_steal(mem_ctx
,
1492 reply
->rdata
.data
.ban_state
);
1494 return reply
->status
;
1497 /* CTDB_CONTROL_REGISTER_NOTIFY */
1499 void ctdb_req_control_register_notify(struct ctdb_req_control
*request
,
1500 struct ctdb_notify_data
*notify
)
1502 request
->opcode
= CTDB_CONTROL_REGISTER_NOTIFY
;
1505 request
->client_id
= 0;
1508 request
->rdata
.opcode
= CTDB_CONTROL_REGISTER_NOTIFY
;
1509 request
->rdata
.data
.notify
= notify
;
1512 int ctdb_reply_control_register_notify(struct ctdb_reply_control
*reply
)
1514 return ctdb_reply_control_generic(reply
, CTDB_CONTROL_REGISTER_NOTIFY
);
1517 /* CTDB_CONTROL_DEREGISTER_NOTIFY */
1519 void ctdb_req_control_deregister_notify(struct ctdb_req_control
*request
,
1522 request
->opcode
= CTDB_CONTROL_DEREGISTER_NOTIFY
;
1525 request
->client_id
= 0;
1528 request
->rdata
.opcode
= CTDB_CONTROL_DEREGISTER_NOTIFY
;
1529 request
->rdata
.data
.srvid
= srvid
;
1532 int ctdb_reply_control_deregister_notify(struct ctdb_reply_control
*reply
)
1534 return ctdb_reply_control_generic(reply
,
1535 CTDB_CONTROL_DEREGISTER_NOTIFY
);
1538 /* CTDB_CONTROL_TRANS3_COMMIT */
1540 void ctdb_req_control_trans3_commit(struct ctdb_req_control
*request
,
1541 struct ctdb_rec_buffer
*recbuf
)
1543 request
->opcode
= CTDB_CONTROL_TRANS3_COMMIT
;
1546 request
->client_id
= 0;
1549 request
->rdata
.opcode
= CTDB_CONTROL_TRANS3_COMMIT
;
1550 request
->rdata
.data
.recbuf
= recbuf
;
1553 int ctdb_reply_control_trans3_commit(struct ctdb_reply_control
*reply
)
1555 return ctdb_reply_control_generic(reply
, CTDB_CONTROL_TRANS3_COMMIT
);
1558 /* CTDB_CONTROL_GET_DB_SEQNUM */
1560 void ctdb_req_control_get_db_seqnum(struct ctdb_req_control
*request
,
1563 request
->opcode
= CTDB_CONTROL_GET_DB_SEQNUM
;
1566 request
->client_id
= 0;
1569 request
->rdata
.opcode
= CTDB_CONTROL_GET_DB_SEQNUM
;
1570 request
->rdata
.data
.db_id
= db_id
;
1573 int ctdb_reply_control_get_db_seqnum(struct ctdb_reply_control
*reply
,
1576 if (reply
->rdata
.opcode
!= CTDB_CONTROL_GET_DB_SEQNUM
) {
1580 if (reply
->status
== 0) {
1581 *seqnum
= reply
->rdata
.data
.seqnum
;
1583 return reply
->status
;
1586 /* CTDB_CONTROL_DB_SET_HEALTHY */
1588 void ctdb_req_control_db_set_healthy(struct ctdb_req_control
*request
,
1591 request
->opcode
= CTDB_CONTROL_DB_SET_HEALTHY
;
1594 request
->client_id
= 0;
1597 request
->rdata
.opcode
= CTDB_CONTROL_DB_SET_HEALTHY
;
1598 request
->rdata
.data
.db_id
= db_id
;
1601 int ctdb_reply_control_db_set_healthy(struct ctdb_reply_control
*reply
)
1603 return ctdb_reply_control_generic(reply
, CTDB_CONTROL_DB_SET_HEALTHY
);
1606 /* CTDB_CONTROL_DB_GET_HEALTH */
1608 void ctdb_req_control_db_get_health(struct ctdb_req_control
*request
,
1611 request
->opcode
= CTDB_CONTROL_DB_GET_HEALTH
;
1614 request
->client_id
= 0;
1617 request
->rdata
.opcode
= CTDB_CONTROL_DB_GET_HEALTH
;
1618 request
->rdata
.data
.db_id
= db_id
;
1621 int ctdb_reply_control_db_get_health(struct ctdb_reply_control
*reply
,
1622 TALLOC_CTX
*mem_ctx
, const char **reason
)
1624 if (reply
->rdata
.opcode
!= CTDB_CONTROL_DB_GET_HEALTH
) {
1628 if (reply
->status
== 0) {
1629 *reason
= talloc_steal(mem_ctx
, reply
->rdata
.data
.reason
);
1631 return reply
->status
;
1634 /* CTDB_CONTROL_GET_PUBLIC_IP_INFO */
1636 void ctdb_req_control_get_public_ip_info(struct ctdb_req_control
*request
,
1637 ctdb_sock_addr
*addr
)
1639 request
->opcode
= CTDB_CONTROL_GET_PUBLIC_IP_INFO
;
1642 request
->client_id
= 0;
1645 request
->rdata
.opcode
= CTDB_CONTROL_GET_PUBLIC_IP_INFO
;
1646 request
->rdata
.data
.addr
= addr
;
1649 int ctdb_reply_control_get_public_ip_info(struct ctdb_reply_control
*reply
,
1650 TALLOC_CTX
*mem_ctx
,
1651 struct ctdb_public_ip_info
**ipinfo
)
1653 if (reply
->rdata
.opcode
!= CTDB_CONTROL_GET_PUBLIC_IP_INFO
) {
1657 if (reply
->status
== 0) {
1658 *ipinfo
= talloc_steal(mem_ctx
, reply
->rdata
.data
.ipinfo
);
1660 return reply
->status
;
1663 /* CTDB_CONTROL_GET_IFACES */
1665 void ctdb_req_control_get_ifaces(struct ctdb_req_control
*request
)
1667 request
->opcode
= CTDB_CONTROL_GET_IFACES
;
1670 request
->client_id
= 0;
1673 request
->rdata
.opcode
= CTDB_CONTROL_GET_IFACES
;
1676 int ctdb_reply_control_get_ifaces(struct ctdb_reply_control
*reply
,
1677 TALLOC_CTX
*mem_ctx
,
1678 struct ctdb_iface_list
**iface_list
)
1680 if (reply
->rdata
.opcode
!= CTDB_CONTROL_GET_IFACES
) {
1684 if (reply
->status
== 0) {
1685 *iface_list
= talloc_steal(mem_ctx
,
1686 reply
->rdata
.data
.iface_list
);
1688 return reply
->status
;
1691 /* CTDB_CONTROL_SET_IFACE_LINK_STATE */
1693 void ctdb_req_control_set_iface_link_state(struct ctdb_req_control
*request
,
1694 struct ctdb_iface
*iface
)
1696 request
->opcode
= CTDB_CONTROL_SET_IFACE_LINK_STATE
;
1699 request
->client_id
= 0;
1702 request
->rdata
.opcode
= CTDB_CONTROL_SET_IFACE_LINK_STATE
;
1703 request
->rdata
.data
.iface
= iface
;
1706 int ctdb_reply_control_set_iface_link_state(struct ctdb_reply_control
*reply
)
1708 return ctdb_reply_control_generic(reply
,
1709 CTDB_CONTROL_SET_IFACE_LINK_STATE
);
1712 /* CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE */
1714 void ctdb_req_control_tcp_add_delayed_update(struct ctdb_req_control
*request
,
1715 struct ctdb_connection
*conn
)
1717 request
->opcode
= CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE
;
1720 request
->client_id
= 0;
1723 request
->rdata
.opcode
= CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE
;
1724 request
->rdata
.data
.conn
= conn
;
1727 int ctdb_reply_control_tcp_add_delayed_update(struct ctdb_reply_control
*reply
)
1729 return ctdb_reply_control_generic(reply
,
1730 CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE
);
1733 /* CTDB_CONTROL_GET_STAT_HISTORY */
1735 void ctdb_req_control_get_stat_history(struct ctdb_req_control
*request
)
1737 request
->opcode
= CTDB_CONTROL_GET_STAT_HISTORY
;
1740 request
->client_id
= 0;
1743 request
->rdata
.opcode
= CTDB_CONTROL_GET_STAT_HISTORY
;
1746 int ctdb_reply_control_get_stat_history(struct ctdb_reply_control
*reply
,
1747 TALLOC_CTX
*mem_ctx
,
1748 struct ctdb_statistics_list
**stats_list
)
1750 if (reply
->rdata
.opcode
!= CTDB_CONTROL_GET_STAT_HISTORY
) {
1754 if (reply
->status
== 0) {
1755 *stats_list
= talloc_steal(mem_ctx
,
1756 reply
->rdata
.data
.stats_list
);
1758 return reply
->status
;
1761 /* CTDB_CONTROL_SCHEDULE_FOR_DELETION */
1763 void ctdb_req_control_schedule_for_deletion(struct ctdb_req_control
*request
,
1764 struct ctdb_key_data
*key
)
1766 request
->opcode
= CTDB_CONTROL_SCHEDULE_FOR_DELETION
;
1769 request
->client_id
= 0;
1772 request
->rdata
.opcode
= CTDB_CONTROL_SCHEDULE_FOR_DELETION
;
1773 request
->rdata
.data
.key
= key
;
1776 int ctdb_reply_control_schedule_for_deletion(struct ctdb_reply_control
*reply
)
1778 return ctdb_reply_control_generic(reply
,
1779 CTDB_CONTROL_SCHEDULE_FOR_DELETION
);
1782 /* CTDB_CONTROL_SET_DB_READONLY */
1784 void ctdb_req_control_set_db_readonly(struct ctdb_req_control
*request
,
1787 request
->opcode
= CTDB_CONTROL_SET_DB_READONLY
;
1790 request
->client_id
= 0;
1793 request
->rdata
.opcode
= CTDB_CONTROL_SET_DB_READONLY
;
1794 request
->rdata
.data
.db_id
= db_id
;
1797 int ctdb_reply_control_set_db_readonly(struct ctdb_reply_control
*reply
)
1799 return ctdb_reply_control_generic(reply
, CTDB_CONTROL_SET_DB_READONLY
);
1802 /* CTDB_CONTROL_TRAVERSE_START_EXT */
1804 void ctdb_req_control_traverse_start_ext(struct ctdb_req_control
*request
,
1805 struct ctdb_traverse_start_ext
*traverse
)
1807 request
->opcode
= CTDB_CONTROL_TRAVERSE_START_EXT
;
1810 request
->client_id
= 0;
1813 request
->rdata
.opcode
= CTDB_CONTROL_TRAVERSE_START_EXT
;
1814 request
->rdata
.data
.traverse_start_ext
= traverse
;
1817 int ctdb_reply_control_traverse_start_ext(struct ctdb_reply_control
*reply
)
1819 return ctdb_reply_control_generic(reply
,
1820 CTDB_CONTROL_TRAVERSE_START_EXT
);
1823 /* CTDB_CONTROL_GET_DB_STATISTICS */
1825 void ctdb_req_control_get_db_statistics(struct ctdb_req_control
*request
,
1828 request
->opcode
= CTDB_CONTROL_GET_DB_STATISTICS
;
1831 request
->client_id
= 0;
1834 request
->rdata
.opcode
= CTDB_CONTROL_GET_DB_STATISTICS
;
1835 request
->rdata
.data
.db_id
= db_id
;
1838 int ctdb_reply_control_get_db_statistics(struct ctdb_reply_control
*reply
,
1839 TALLOC_CTX
*mem_ctx
,
1840 struct ctdb_db_statistics
**dbstats
)
1842 if (reply
->rdata
.opcode
!= CTDB_CONTROL_GET_DB_STATISTICS
) {
1846 if (reply
->status
== 0) {
1847 *dbstats
= talloc_steal(mem_ctx
, reply
->rdata
.data
.dbstats
);
1849 return reply
->status
;
1852 /* CTDB_CONTROL_SET_DB_STICKY */
1854 void ctdb_req_control_set_db_sticky(struct ctdb_req_control
*request
,
1857 request
->opcode
= CTDB_CONTROL_SET_DB_STICKY
;
1860 request
->client_id
= 0;
1863 request
->rdata
.opcode
= CTDB_CONTROL_SET_DB_STICKY
;
1864 request
->rdata
.data
.db_id
= db_id
;
1867 int ctdb_reply_control_set_db_sticky(struct ctdb_reply_control
*reply
)
1869 return ctdb_reply_control_generic(reply
, CTDB_CONTROL_SET_DB_STICKY
);
1872 /* CTDB_CONTROL_RELOAD_PUBLIC_IPS */
1874 void ctdb_req_control_reload_public_ips(struct ctdb_req_control
*request
)
1876 request
->opcode
= CTDB_CONTROL_RELOAD_PUBLIC_IPS
;
1879 request
->client_id
= 0;
1882 request
->rdata
.opcode
= CTDB_CONTROL_RELOAD_PUBLIC_IPS
;
1885 int ctdb_reply_control_reload_public_ips(struct ctdb_reply_control
*reply
)
1887 return ctdb_reply_control_generic(reply
,
1888 CTDB_CONTROL_RELOAD_PUBLIC_IPS
);
1891 /* CTDB_CONTROL_TRAVERSE_ALL_EXT */
1893 /* CTDB_CONTROL_IPREALLOCATED */
1895 void ctdb_req_control_ipreallocated(struct ctdb_req_control
*request
)
1897 request
->opcode
= CTDB_CONTROL_IPREALLOCATED
;
1900 request
->client_id
= 0;
1903 request
->rdata
.opcode
= CTDB_CONTROL_IPREALLOCATED
;
1906 int ctdb_reply_control_ipreallocated(struct ctdb_reply_control
*reply
)
1908 return ctdb_reply_control_generic(reply
, CTDB_CONTROL_IPREALLOCATED
);
1911 /* CTDB_CONTROL_GET_RUNSTATE */
1913 void ctdb_req_control_get_runstate(struct ctdb_req_control
*request
)
1915 request
->opcode
= CTDB_CONTROL_GET_RUNSTATE
;
1918 request
->client_id
= 0;
1921 request
->rdata
.opcode
= CTDB_CONTROL_GET_RUNSTATE
;
1924 int ctdb_reply_control_get_runstate(struct ctdb_reply_control
*reply
,
1925 enum ctdb_runstate
*runstate
)
1927 if (reply
->rdata
.opcode
!= CTDB_CONTROL_GET_RUNSTATE
) {
1931 if (reply
->status
== 0) {
1932 *runstate
= reply
->rdata
.data
.runstate
;
1934 return reply
->status
;
1937 /* CTDB_CONTROL_DB_DETACH */
1939 void ctdb_req_control_db_detach(struct ctdb_req_control
*request
,
1942 request
->opcode
= CTDB_CONTROL_DB_DETACH
;
1945 request
->client_id
= 0;
1948 request
->rdata
.opcode
= CTDB_CONTROL_DB_DETACH
;
1949 request
->rdata
.data
.db_id
= db_id
;
1952 int ctdb_reply_control_db_detach(struct ctdb_reply_control
*reply
)
1954 return ctdb_reply_control_generic(reply
, CTDB_CONTROL_DB_DETACH
);
1957 /* CTDB_CONTROL_GET_NODES_FILE */
1959 void ctdb_req_control_get_nodes_file(struct ctdb_req_control
*request
)
1961 request
->opcode
= CTDB_CONTROL_GET_NODES_FILE
;
1964 request
->client_id
= 0;
1967 request
->rdata
.opcode
= CTDB_CONTROL_GET_NODES_FILE
;
1970 int ctdb_reply_control_get_nodes_file(struct ctdb_reply_control
*reply
,
1971 TALLOC_CTX
*mem_ctx
,
1972 struct ctdb_node_map
**nodemap
)
1974 if (reply
->rdata
.opcode
!= CTDB_CONTROL_GET_NODES_FILE
) {
1978 if (reply
->status
== 0) {
1979 *nodemap
= talloc_steal(mem_ctx
, reply
->rdata
.data
.nodemap
);
1981 return reply
->status
;
1984 /* CTDB_CONTROL_DB_FREEZE */
1986 void ctdb_req_control_db_freeze(struct ctdb_req_control
*request
,
1989 request
->opcode
= CTDB_CONTROL_DB_FREEZE
;
1992 request
->client_id
= 0;
1995 request
->rdata
.opcode
= CTDB_CONTROL_DB_FREEZE
;
1996 request
->rdata
.data
.db_id
= db_id
;
1999 int ctdb_reply_control_db_freeze(struct ctdb_reply_control
*reply
)
2001 return ctdb_reply_control_generic(reply
, CTDB_CONTROL_DB_FREEZE
);
2004 /* CTDB_CONTROL_DB_THAW */
2006 void ctdb_req_control_db_thaw(struct ctdb_req_control
*request
,
2009 request
->opcode
= CTDB_CONTROL_DB_THAW
;
2012 request
->client_id
= 0;
2015 request
->rdata
.opcode
= CTDB_CONTROL_DB_THAW
;
2016 request
->rdata
.data
.db_id
= db_id
;
2019 int ctdb_reply_control_db_thaw(struct ctdb_reply_control
*reply
)
2021 return ctdb_reply_control_generic(reply
, CTDB_CONTROL_DB_THAW
);
2024 /* CTDB_CONTROL_DB_TRANSACTION_START */
2026 void ctdb_req_control_db_transaction_start(struct ctdb_req_control
*request
,
2027 struct ctdb_transdb
*transdb
)
2029 request
->opcode
= CTDB_CONTROL_DB_TRANSACTION_START
;
2032 request
->client_id
= 0;
2035 request
->rdata
.opcode
= CTDB_CONTROL_DB_TRANSACTION_START
;
2036 request
->rdata
.data
.transdb
= transdb
;
2039 int ctdb_reply_control_db_transaction_start(struct ctdb_reply_control
*reply
)
2041 return ctdb_reply_control_generic(reply
,
2042 CTDB_CONTROL_DB_TRANSACTION_START
);
2045 /* CTDB_CONTROL_DB_TRANSACTION_COMMIT */
2047 void ctdb_req_control_db_transaction_commit(struct ctdb_req_control
*request
,
2048 struct ctdb_transdb
*transdb
)
2050 request
->opcode
= CTDB_CONTROL_DB_TRANSACTION_COMMIT
;
2053 request
->client_id
= 0;
2056 request
->rdata
.opcode
= CTDB_CONTROL_DB_TRANSACTION_COMMIT
;
2057 request
->rdata
.data
.transdb
= transdb
;
2060 int ctdb_reply_control_db_transaction_commit(struct ctdb_reply_control
*reply
)
2062 return ctdb_reply_control_generic(reply
,
2063 CTDB_CONTROL_DB_TRANSACTION_COMMIT
);
2066 /* CTDB_CONTROL_DB_TRANSACTION_CANCEL */
2068 void ctdb_req_control_db_transaction_cancel(struct ctdb_req_control
*request
,
2071 request
->opcode
= CTDB_CONTROL_DB_TRANSACTION_CANCEL
;
2074 request
->client_id
= 0;
2077 request
->rdata
.opcode
= CTDB_CONTROL_DB_TRANSACTION_CANCEL
;
2078 request
->rdata
.data
.db_id
= db_id
;
2081 int ctdb_reply_control_db_transaction_cancel(struct ctdb_reply_control
*reply
)
2083 return ctdb_reply_control_generic(reply
,
2084 CTDB_CONTROL_DB_TRANSACTION_CANCEL
);
2087 /* CTDB_CONTROL_DB_PULL */
2089 void ctdb_req_control_db_pull(struct ctdb_req_control
*request
,
2090 struct ctdb_pulldb_ext
*pulldb_ext
)
2092 request
->opcode
= CTDB_CONTROL_DB_PULL
;
2095 request
->client_id
= 0;
2098 request
->rdata
.opcode
= CTDB_CONTROL_DB_PULL
;
2099 request
->rdata
.data
.pulldb_ext
= pulldb_ext
;
2102 int ctdb_reply_control_db_pull(struct ctdb_reply_control
*reply
,
2103 uint32_t *num_records
)
2105 if (reply
->rdata
.opcode
!= CTDB_CONTROL_DB_PULL
) {
2109 if (reply
->status
== 0) {
2110 *num_records
= reply
->rdata
.data
.num_records
;
2112 return reply
->status
;
2115 /* CTDB_CONTROL_DB_PUSH_START */
2117 void ctdb_req_control_db_push_start(struct ctdb_req_control
*request
,
2118 struct ctdb_pulldb_ext
*pulldb_ext
)
2120 request
->opcode
= CTDB_CONTROL_DB_PUSH_START
;
2123 request
->client_id
= 0;
2126 request
->rdata
.opcode
= CTDB_CONTROL_DB_PUSH_START
;
2127 request
->rdata
.data
.pulldb_ext
= pulldb_ext
;
2130 int ctdb_reply_control_db_push_start(struct ctdb_reply_control
*reply
)
2132 return ctdb_reply_control_generic(reply
, CTDB_CONTROL_DB_PUSH_START
);
2135 /* CTDB_CONTROL_DB_PUSH_CONFIRM */
2137 void ctdb_req_control_db_push_confirm(struct ctdb_req_control
*request
,
2140 request
->opcode
= CTDB_CONTROL_DB_PUSH_CONFIRM
;
2143 request
->client_id
= 0;
2146 request
->rdata
.opcode
= CTDB_CONTROL_DB_PUSH_CONFIRM
;
2147 request
->rdata
.data
.db_id
= db_id
;
2150 int ctdb_reply_control_db_push_confirm(struct ctdb_reply_control
*reply
,
2151 uint32_t *num_records
)
2153 if (reply
->rdata
.opcode
!= CTDB_CONTROL_DB_PUSH_CONFIRM
) {
2157 if (reply
->status
== 0) {
2158 *num_records
= reply
->rdata
.data
.num_records
;
2160 return reply
->status
;
2163 /* CTDB_CONTROL_DB_OPEN_FLAGS */
2165 void ctdb_req_control_db_open_flags(struct ctdb_req_control
*request
,
2168 request
->opcode
= CTDB_CONTROL_DB_OPEN_FLAGS
;
2171 request
->client_id
= 0;
2174 request
->rdata
.opcode
= CTDB_CONTROL_DB_OPEN_FLAGS
;
2175 request
->rdata
.data
.db_id
= db_id
;
2178 int ctdb_reply_control_db_open_flags(struct ctdb_reply_control
*reply
,
2181 if (reply
->rdata
.opcode
!= CTDB_CONTROL_DB_OPEN_FLAGS
) {
2185 if (reply
->status
== 0) {
2186 *tdb_flags
= reply
->rdata
.data
.tdb_flags
;
2188 return reply
->status
;
2191 /* CTDB_CONTROL_DB_ATTACH_REPLICATED */
2193 void ctdb_req_control_db_attach_replicated(struct ctdb_req_control
*request
,
2194 const char *db_name
)
2196 request
->opcode
= CTDB_CONTROL_DB_ATTACH_REPLICATED
;
2199 request
->client_id
= 0;
2202 request
->rdata
.opcode
= CTDB_CONTROL_DB_ATTACH_REPLICATED
;
2203 request
->rdata
.data
.db_name
= db_name
;
2206 int ctdb_reply_control_db_attach_replicated(struct ctdb_reply_control
*reply
,
2209 if (reply
->rdata
.opcode
!= CTDB_CONTROL_DB_ATTACH_REPLICATED
) {
2212 if (reply
->status
== 0) {
2213 *db_id
= reply
->rdata
.data
.db_id
;
2215 return reply
->status
;
2218 /* CTDB_CONTROL_CHECK_PID_SRVID */
2220 void ctdb_req_control_check_pid_srvid(struct ctdb_req_control
*request
,
2221 struct ctdb_pid_srvid
*pid_srvid
)
2223 request
->opcode
= CTDB_CONTROL_CHECK_PID_SRVID
;
2226 request
->client_id
= 0;
2229 request
->rdata
.opcode
= CTDB_CONTROL_CHECK_PID_SRVID
;
2230 request
->rdata
.data
.pid_srvid
= pid_srvid
;
2233 int ctdb_reply_control_check_pid_srvid(struct ctdb_reply_control
*reply
,
2236 if (reply
->rdata
.opcode
!= CTDB_CONTROL_CHECK_PID_SRVID
) {
2240 *status
= reply
->status
;
2243 return reply
->status
;
2246 /* CTDB_CONTROL_TUNNEL_REGISTER */
2248 void ctdb_req_control_tunnel_register(struct ctdb_req_control
*request
,
2251 request
->opcode
= CTDB_CONTROL_TUNNEL_REGISTER
;
2253 request
->srvid
= tunnel_id
;
2254 request
->client_id
= 0;
2257 request
->rdata
.opcode
= CTDB_CONTROL_TUNNEL_REGISTER
;
2260 int ctdb_reply_control_tunnel_register(struct ctdb_reply_control
*reply
)
2262 if (reply
->rdata
.opcode
!= CTDB_CONTROL_TUNNEL_REGISTER
) {
2266 return reply
->status
;
2269 /* CTDB_CONTROL_TUNNEL_DEREGISTER */
2271 void ctdb_req_control_tunnel_deregister(struct ctdb_req_control
*request
,
2274 request
->opcode
= CTDB_CONTROL_TUNNEL_DEREGISTER
;
2276 request
->srvid
= tunnel_id
;
2277 request
->client_id
= 0;
2280 request
->rdata
.opcode
= CTDB_CONTROL_TUNNEL_DEREGISTER
;
2283 int ctdb_reply_control_tunnel_deregister(struct ctdb_reply_control
*reply
)
2285 if (reply
->rdata
.opcode
!= CTDB_CONTROL_TUNNEL_DEREGISTER
) {
2289 return reply
->status
;
2292 /* CTDB_CONTROL_VACUUM_FETCH */
2294 void ctdb_req_control_vacuum_fetch(struct ctdb_req_control
*request
,
2295 struct ctdb_rec_buffer
*recbuf
)
2297 request
->opcode
= CTDB_CONTROL_VACUUM_FETCH
;
2300 request
->client_id
= 0;
2303 request
->rdata
.opcode
= CTDB_CONTROL_VACUUM_FETCH
;
2304 request
->rdata
.data
.recbuf
= recbuf
;
2307 int ctdb_reply_control_vacuum_fetch(struct ctdb_reply_control
*reply
)
2309 if (reply
->rdata
.opcode
!= CTDB_CONTROL_VACUUM_FETCH
) {
2313 return reply
->status
;
2316 /* CTDB_CONTROL_DB_VACUUM */
2318 void ctdb_req_control_db_vacuum(struct ctdb_req_control
*request
,
2319 struct ctdb_db_vacuum
*db_vacuum
)
2321 request
->opcode
= CTDB_CONTROL_DB_VACUUM
;
2324 request
->client_id
= 0;
2327 request
->rdata
.opcode
= CTDB_CONTROL_DB_VACUUM
;
2328 request
->rdata
.data
.db_vacuum
= db_vacuum
;
2331 int ctdb_reply_control_db_vacuum(struct ctdb_reply_control
*reply
)
2333 if (reply
->rdata
.opcode
!= CTDB_CONTROL_DB_VACUUM
) {
2337 return reply
->status
;
2340 /* CTDB_CONTROL_ECHO_DATA */
2342 void ctdb_req_control_echo_data(struct ctdb_req_control
*request
,
2343 struct ctdb_echo_data
*echo_data
)
2345 request
->opcode
= CTDB_CONTROL_ECHO_DATA
;
2348 request
->client_id
= 0;
2351 request
->rdata
.opcode
= CTDB_CONTROL_ECHO_DATA
;
2352 request
->rdata
.data
.echo_data
= echo_data
;
2355 int ctdb_reply_control_echo_data(struct ctdb_reply_control
*reply
)
2357 if (reply
->rdata
.opcode
!= CTDB_CONTROL_ECHO_DATA
) {
2361 return reply
->status
;
2364 /* CTDB_CONTROL_DISABLE_NODE */
2366 void ctdb_req_control_disable_node(struct ctdb_req_control
*request
)
2368 request
->opcode
= CTDB_CONTROL_DISABLE_NODE
;
2371 request
->client_id
= 0;
2374 request
->rdata
.opcode
= CTDB_CONTROL_DISABLE_NODE
;
2377 int ctdb_reply_control_disable_node(struct ctdb_reply_control
*reply
)
2379 return ctdb_reply_control_generic(reply
, CTDB_CONTROL_DISABLE_NODE
);
2382 /* CTDB_CONTROL_ENABLE_NODE */
2384 void ctdb_req_control_enable_node(struct ctdb_req_control
*request
)
2386 request
->opcode
= CTDB_CONTROL_ENABLE_NODE
;
2389 request
->client_id
= 0;
2392 request
->rdata
.opcode
= CTDB_CONTROL_ENABLE_NODE
;
2395 int ctdb_reply_control_enable_node(struct ctdb_reply_control
*reply
)
2397 return ctdb_reply_control_generic(reply
, CTDB_CONTROL_ENABLE_NODE
);