2 ctdb_control protocol code
4 Copyright (C) Andrew Tridgell 2007
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/>.
20 #include "system/network.h"
21 #include "system/filesys.h"
22 #include "system/wait.h"
27 #include "lib/tdb_wrap/tdb_wrap.h"
28 #include "lib/util/dlinklist.h"
29 #include "lib/util/debug.h"
30 #include "lib/util/samba_util.h"
31 #include "lib/util/talloc_report.h"
33 #include "ctdb_private.h"
34 #include "ctdb_client.h"
36 #include "common/reqid.h"
37 #include "common/common.h"
38 #include "common/logging.h"
41 struct ctdb_control_state
{
42 struct ctdb_context
*ctdb
;
44 ctdb_control_callback_fn_t callback
;
51 dump talloc memory hierarchy, returning it as a blob to the client
53 int32_t ctdb_dump_memory(struct ctdb_context
*ctdb
, TDB_DATA
*outdata
)
58 report
= talloc_report_str(outdata
, NULL
);
61 (__location__
" talloc_report_str failed\n"));
64 reportlen
= talloc_get_size(report
);
67 reportlen
-= 1; /* strip trailing zero */
70 outdata
->dptr
= (uint8_t *)report
;
71 outdata
->dsize
= reportlen
;
75 static int32_t control_not_implemented(const char *unsupported
,
76 const char *alternate
)
78 if (alternate
== NULL
) {
80 ("Control %s is not implemented any more\n",
84 ("Control %s is not implemented any more, use %s instead\n",
85 unsupported
, alternate
));
91 process a control request
93 static int32_t ctdb_control_dispatch(struct ctdb_context
*ctdb
,
94 struct ctdb_req_control_old
*c
,
96 TDB_DATA
*outdata
, uint32_t srcnode
,
97 const char **errormsg
,
100 uint32_t opcode
= c
->opcode
;
101 uint64_t srvid
= c
->srvid
;
102 uint32_t client_id
= c
->client_id
;
103 static int level
= DEBUG_ERR
;
106 case CTDB_CONTROL_PROCESS_EXISTS
: {
107 CHECK_CONTROL_DATA_SIZE(sizeof(pid_t
));
108 return ctdb_control_process_exists(ctdb
, *(pid_t
*)indata
.dptr
);
111 case CTDB_CONTROL_SET_DEBUG
: {
116 CHECK_CONTROL_DATA_SIZE(sizeof(int32_t));
117 debug
.ptr
= indata
.dptr
;
118 debuglevel_set(*debug
.level
);
122 case CTDB_CONTROL_GET_DEBUG
: {
123 CHECK_CONTROL_DATA_SIZE(0);
124 level
= debuglevel_get();
125 outdata
->dptr
= (uint8_t *)&(level
);
126 outdata
->dsize
= sizeof(DEBUGLEVEL
);
130 case CTDB_CONTROL_STATISTICS
: {
131 CHECK_CONTROL_DATA_SIZE(0);
132 ctdb
->statistics
.memory_used
= talloc_total_size(NULL
);
133 ctdb
->statistics
.num_clients
= ctdb
->num_clients
;
134 ctdb
->statistics
.frozen
= (ctdb_db_all_frozen(ctdb
) ? 1 : 0);
135 ctdb
->statistics
.recovering
= (ctdb
->recovery_mode
== CTDB_RECOVERY_ACTIVE
);
136 ctdb
->statistics
.statistics_current_time
= timeval_current();
138 outdata
->dptr
= (uint8_t *)&ctdb
->statistics
;
139 outdata
->dsize
= sizeof(ctdb
->statistics
);
143 case CTDB_CONTROL_GET_ALL_TUNABLES
: {
144 CHECK_CONTROL_DATA_SIZE(0);
145 outdata
->dptr
= (uint8_t *)&ctdb
->tunable
;
146 outdata
->dsize
= sizeof(ctdb
->tunable
);
150 case CTDB_CONTROL_DUMP_MEMORY
: {
151 CHECK_CONTROL_DATA_SIZE(0);
152 return ctdb_dump_memory(ctdb
, outdata
);
155 case CTDB_CONTROL_STATISTICS_RESET
: {
156 struct ctdb_db_context
*ctdb_db
;
158 CHECK_CONTROL_DATA_SIZE(0);
159 ZERO_STRUCT(ctdb
->statistics
);
160 for (ctdb_db
= ctdb
->db_list
;
162 ctdb_db
= ctdb_db
->next
) {
163 ctdb_db_statistics_reset(ctdb_db
);
165 ctdb
->statistics
.statistics_start_time
= timeval_current();
169 case CTDB_CONTROL_GETVNNMAP
:
170 return ctdb_control_getvnnmap(ctdb
, opcode
, indata
, outdata
);
172 case CTDB_CONTROL_GET_DBMAP
:
173 return ctdb_control_getdbmap(ctdb
, opcode
, indata
, outdata
);
175 case CTDB_CONTROL_GET_NODEMAPv4
:
176 return control_not_implemented("GET_NODEMAPv4", "GET_NODEMAP");
178 case CTDB_CONTROL_GET_NODEMAP
:
179 return ctdb_control_getnodemap(ctdb
, opcode
, indata
, outdata
);
181 case CTDB_CONTROL_GET_NODES_FILE
:
182 return ctdb_control_getnodesfile(ctdb
, opcode
, indata
, outdata
);
184 case CTDB_CONTROL_RELOAD_NODES_FILE
:
185 CHECK_CONTROL_DATA_SIZE(0);
186 return ctdb_control_reload_nodes_file(ctdb
, opcode
);
188 case CTDB_CONTROL_SET_DB_STICKY
: {
190 struct ctdb_db_context
*ctdb_db
;
192 CHECK_CONTROL_DATA_SIZE(sizeof(db_id
));
193 db_id
= *(uint32_t *)indata
.dptr
;
194 ctdb_db
= find_ctdb_db(ctdb
, db_id
);
195 if (ctdb_db
== NULL
) return -1;
196 return ctdb_set_db_sticky(ctdb
, ctdb_db
);
199 case CTDB_CONTROL_SETVNNMAP
:
200 return ctdb_control_setvnnmap(ctdb
, opcode
, indata
, outdata
);
202 case CTDB_CONTROL_PULL_DB
:
203 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_pulldb
));
204 return ctdb_control_pull_db(ctdb
, indata
, outdata
);
206 case CTDB_CONTROL_SET_DMASTER
:
207 return control_not_implemented("SET_DMASTER", NULL
);
209 case CTDB_CONTROL_PUSH_DB
:
210 return ctdb_control_push_db(ctdb
, indata
);
212 case CTDB_CONTROL_GET_RECMODE
: {
213 return ctdb
->recovery_mode
;
216 case CTDB_CONTROL_SET_RECMASTER
: {
217 return ctdb_control_set_recmaster(ctdb
, opcode
, indata
);
220 case CTDB_CONTROL_GET_RECMASTER
:
221 return ctdb
->recovery_master
;
223 case CTDB_CONTROL_GET_PID
:
226 case CTDB_CONTROL_GET_PNN
:
229 case CTDB_CONTROL_PING
:
230 CHECK_CONTROL_DATA_SIZE(0);
231 return ctdb
->num_clients
;
233 case CTDB_CONTROL_GET_RUNSTATE
:
234 CHECK_CONTROL_DATA_SIZE(0);
235 outdata
->dptr
= (uint8_t *)&ctdb
->runstate
;
236 outdata
->dsize
= sizeof(uint32_t);
240 case CTDB_CONTROL_SET_DB_READONLY
: {
242 struct ctdb_db_context
*ctdb_db
;
244 CHECK_CONTROL_DATA_SIZE(sizeof(db_id
));
245 db_id
= *(uint32_t *)indata
.dptr
;
246 ctdb_db
= find_ctdb_db(ctdb
, db_id
);
247 if (ctdb_db
== NULL
) return -1;
248 return ctdb_set_db_readonly(ctdb
, ctdb_db
);
250 case CTDB_CONTROL_GET_DBNAME
: {
252 struct ctdb_db_context
*ctdb_db
;
254 CHECK_CONTROL_DATA_SIZE(sizeof(db_id
));
255 db_id
= *(uint32_t *)indata
.dptr
;
256 ctdb_db
= find_ctdb_db(ctdb
, db_id
);
257 if (ctdb_db
== NULL
) return -1;
258 outdata
->dptr
= discard_const(ctdb_db
->db_name
);
259 outdata
->dsize
= strlen(ctdb_db
->db_name
)+1;
263 case CTDB_CONTROL_GETDBPATH
: {
265 struct ctdb_db_context
*ctdb_db
;
267 CHECK_CONTROL_DATA_SIZE(sizeof(db_id
));
268 db_id
= *(uint32_t *)indata
.dptr
;
269 ctdb_db
= find_ctdb_db(ctdb
, db_id
);
270 if (ctdb_db
== NULL
) return -1;
271 outdata
->dptr
= discard_const(ctdb_db
->db_path
);
272 outdata
->dsize
= strlen(ctdb_db
->db_path
)+1;
276 case CTDB_CONTROL_DB_ATTACH
:
277 return ctdb_control_db_attach(ctdb
,
286 case CTDB_CONTROL_DB_ATTACH_PERSISTENT
:
287 return ctdb_control_db_attach(ctdb
,
290 CTDB_DB_FLAGS_PERSISTENT
,
296 case CTDB_CONTROL_DB_ATTACH_REPLICATED
:
297 return ctdb_control_db_attach(ctdb
,
300 CTDB_DB_FLAGS_REPLICATED
,
306 case CTDB_CONTROL_SET_CALL
:
307 return control_not_implemented("SET_CALL", NULL
);
309 case CTDB_CONTROL_TRAVERSE_START
:
310 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_traverse_start
));
311 return ctdb_control_traverse_start(ctdb
, indata
, outdata
, srcnode
, client_id
);
313 case CTDB_CONTROL_TRAVERSE_START_EXT
:
314 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_traverse_start_ext
));
315 return ctdb_control_traverse_start_ext(ctdb
, indata
, outdata
, srcnode
, client_id
);
317 case CTDB_CONTROL_TRAVERSE_ALL
:
318 return ctdb_control_traverse_all(ctdb
, indata
, outdata
);
320 case CTDB_CONTROL_TRAVERSE_ALL_EXT
:
321 return ctdb_control_traverse_all_ext(ctdb
, indata
, outdata
);
323 case CTDB_CONTROL_TRAVERSE_DATA
:
324 return ctdb_control_traverse_data(ctdb
, indata
, outdata
);
326 case CTDB_CONTROL_TRAVERSE_KILL
:
327 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_traverse_start
));
328 return ctdb_control_traverse_kill(ctdb
, indata
, outdata
, srcnode
);
330 case CTDB_CONTROL_REGISTER_SRVID
:
331 return daemon_register_message_handler(ctdb
, client_id
, srvid
);
333 case CTDB_CONTROL_DEREGISTER_SRVID
:
334 return daemon_deregister_message_handler(ctdb
, client_id
, srvid
);
336 case CTDB_CONTROL_CHECK_SRVIDS
:
337 return control_not_implemented("CHECK_SRVIDS", NULL
);
339 case CTDB_CONTROL_ENABLE_SEQNUM
:
340 CHECK_CONTROL_DATA_SIZE(sizeof(uint32_t));
341 return ctdb_ltdb_enable_seqnum(ctdb
, *(uint32_t *)indata
.dptr
);
343 case CTDB_CONTROL_UPDATE_SEQNUM
:
344 CHECK_CONTROL_DATA_SIZE(sizeof(uint32_t));
345 return ctdb_ltdb_update_seqnum(ctdb
, *(uint32_t *)indata
.dptr
, srcnode
);
347 case CTDB_CONTROL_FREEZE
:
348 CHECK_CONTROL_DATA_SIZE(0);
349 return ctdb_control_freeze(ctdb
, c
, async_reply
);
351 case CTDB_CONTROL_THAW
:
352 return control_not_implemented("THAW", NULL
);
354 case CTDB_CONTROL_SET_RECMODE
:
355 CHECK_CONTROL_DATA_SIZE(sizeof(uint32_t));
356 return ctdb_control_set_recmode(ctdb
, c
, indata
, async_reply
, errormsg
);
358 case CTDB_CONTROL_GET_MONMODE
:
359 return control_not_implemented("GET_MONMODE", NULL
);
361 case CTDB_CONTROL_ENABLE_MONITOR
:
362 return control_not_implemented("ENABLE_MONITOR", NULL
);
364 case CTDB_CONTROL_RUN_EVENTSCRIPTS
:
365 return control_not_implemented("RUN_EVENTSCRIPTS", NULL
);
367 case CTDB_CONTROL_DISABLE_MONITOR
:
368 return control_not_implemented("DISABLE_MONITOR", NULL
);
370 case CTDB_CONTROL_SHUTDOWN
:
371 DEBUG(DEBUG_NOTICE
,("Received SHUTDOWN command.\n"));
372 ctdb_shutdown_sequence(ctdb
, 0);
373 /* In case above returns due to duplicate shutdown */
376 case CTDB_CONTROL_TAKEOVER_IPv4
:
377 return control_not_implemented("TAKEOVER_IPv4", "TAKEOVER_IP");
379 case CTDB_CONTROL_TAKEOVER_IP
:
380 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_public_ip
));
381 return ctdb_control_takeover_ip(ctdb
, c
, indata
, async_reply
);
383 case CTDB_CONTROL_RELEASE_IPv4
:
384 return control_not_implemented("RELEASE_IPv4", "RELEASE_IP");
386 case CTDB_CONTROL_RELEASE_IP
:
387 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_public_ip
));
388 return ctdb_control_release_ip(ctdb
, c
, indata
, async_reply
);
390 case CTDB_CONTROL_IPREALLOCATED
:
391 CHECK_CONTROL_DATA_SIZE(0);
392 return ctdb_control_ipreallocated(ctdb
, c
, async_reply
);
394 case CTDB_CONTROL_GET_PUBLIC_IPSv4
:
395 return control_not_implemented("GET_PUBLIC_IPSv4",
398 case CTDB_CONTROL_GET_PUBLIC_IPS
:
399 CHECK_CONTROL_DATA_SIZE(0);
400 return ctdb_control_get_public_ips(ctdb
, c
, outdata
);
402 case CTDB_CONTROL_TCP_CLIENT
:
403 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_connection
));
404 return ctdb_control_tcp_client(ctdb
, client_id
, indata
);
406 case CTDB_CONTROL_STARTUP
:
407 CHECK_CONTROL_DATA_SIZE(0);
408 return ctdb_control_startup(ctdb
, srcnode
);
410 case CTDB_CONTROL_TCP_ADD
:
411 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_connection
));
412 return ctdb_control_tcp_add(ctdb
, indata
, false);
414 case CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE
:
415 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_connection
));
416 return ctdb_control_tcp_add(ctdb
, indata
, true);
418 case CTDB_CONTROL_TCP_REMOVE
:
419 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_connection
));
420 return ctdb_control_tcp_remove(ctdb
, indata
);
422 case CTDB_CONTROL_SET_TUNABLE
:
423 return ctdb_control_set_tunable(ctdb
, indata
);
425 case CTDB_CONTROL_GET_TUNABLE
:
426 return ctdb_control_get_tunable(ctdb
, indata
, outdata
);
428 case CTDB_CONTROL_LIST_TUNABLES
:
429 return ctdb_control_list_tunables(ctdb
, outdata
);
431 case CTDB_CONTROL_MODIFY_FLAGS
:
432 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_node_flag_change
));
433 return ctdb_control_modflags(ctdb
, indata
);
435 case CTDB_CONTROL_KILL_TCP
:
436 return control_not_implemented("KILL_TCP", NULL
);
438 case CTDB_CONTROL_GET_TCP_TICKLE_LIST
:
439 CHECK_CONTROL_DATA_SIZE(sizeof(ctdb_sock_addr
));
440 return ctdb_control_get_tcp_tickle_list(ctdb
, indata
, outdata
);
442 case CTDB_CONTROL_SET_TCP_TICKLE_LIST
:
443 /* data size is verified in the called function */
444 return ctdb_control_set_tcp_tickle_list(ctdb
, indata
);
446 case CTDB_CONTROL_REGISTER_SERVER_ID
:
447 return control_not_implemented("REGISTER_SERVER_ID", NULL
);
449 case CTDB_CONTROL_UNREGISTER_SERVER_ID
:
450 return control_not_implemented("UNREGISTER_SERVER_ID", NULL
);
452 case CTDB_CONTROL_CHECK_SERVER_ID
:
453 return control_not_implemented("CHECK_SERVER_ID", NULL
);
455 case CTDB_CONTROL_GET_SERVER_ID_LIST
:
456 return control_not_implemented("SERVER_ID_LIST", NULL
);
458 case CTDB_CONTROL_PERSISTENT_STORE
:
459 return control_not_implemented("PERSISTENT_STORE", NULL
);
461 case CTDB_CONTROL_UPDATE_RECORD
:
462 return ctdb_control_update_record(ctdb
, c
, indata
, async_reply
);
464 case CTDB_CONTROL_SEND_GRATUITOUS_ARP
:
465 return ctdb_control_send_gratious_arp(ctdb
, indata
);
467 case CTDB_CONTROL_TRANSACTION_START
:
468 return control_not_implemented("TRANSACTION_START", NULL
);
470 case CTDB_CONTROL_TRANSACTION_COMMIT
:
471 return control_not_implemented("TRANSACTION_COMMIT", NULL
);
473 case CTDB_CONTROL_WIPE_DATABASE
:
474 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_transdb
));
475 return ctdb_control_wipe_database(ctdb
, indata
);
477 case CTDB_CONTROL_UPTIME
:
478 return ctdb_control_uptime(ctdb
, outdata
);
480 case CTDB_CONTROL_START_RECOVERY
:
481 return ctdb_control_start_recovery(ctdb
, c
, async_reply
);
483 case CTDB_CONTROL_END_RECOVERY
:
484 return ctdb_control_end_recovery(ctdb
, c
, async_reply
);
486 case CTDB_CONTROL_TRY_DELETE_RECORDS
:
487 return ctdb_control_try_delete_records(ctdb
, indata
, outdata
);
489 case CTDB_CONTROL_ADD_PUBLIC_IP
:
490 return ctdb_control_add_public_address(ctdb
, indata
);
492 case CTDB_CONTROL_DEL_PUBLIC_IP
:
493 return ctdb_control_del_public_address(ctdb
, indata
);
495 case CTDB_CONTROL_GET_CAPABILITIES
:
496 return ctdb_control_get_capabilities(ctdb
, outdata
);
498 case CTDB_CONTROL_START_PERSISTENT_UPDATE
:
499 return ctdb_control_start_persistent_update(ctdb
, c
, indata
);
501 case CTDB_CONTROL_CANCEL_PERSISTENT_UPDATE
:
502 return ctdb_control_cancel_persistent_update(ctdb
, c
, indata
);
504 case CTDB_CONTROL_TRANS2_COMMIT
:
505 case CTDB_CONTROL_TRANS2_COMMIT_RETRY
:
506 return control_not_implemented("TRANS2_COMMIT", "TRANS3_COMMIT");
508 case CTDB_CONTROL_TRANS2_ERROR
:
509 return control_not_implemented("TRANS2_ERROR", NULL
);
511 case CTDB_CONTROL_TRANS2_FINISHED
:
512 return control_not_implemented("TRANS2_FINISHED", NULL
);
514 case CTDB_CONTROL_TRANS2_ACTIVE
:
515 return control_not_implemented("TRANS2_ACTIVE", NULL
);
517 case CTDB_CONTROL_TRANS3_COMMIT
:
518 return ctdb_control_trans3_commit(ctdb
, c
, indata
, async_reply
);
520 case CTDB_CONTROL_RECD_PING
:
521 CHECK_CONTROL_DATA_SIZE(0);
522 return ctdb_control_recd_ping(ctdb
);
524 case CTDB_CONTROL_GET_EVENT_SCRIPT_STATUS
:
525 return control_not_implemented("GET_EVENT_SCRIPT_STATUS", NULL
);
527 case CTDB_CONTROL_RECD_RECLOCK_LATENCY
:
528 CHECK_CONTROL_DATA_SIZE(sizeof(double));
529 CTDB_UPDATE_RECLOCK_LATENCY(ctdb
, "recd reclock", reclock
.recd
, *((double *)indata
.dptr
));
531 case CTDB_CONTROL_GET_RECLOCK_FILE
:
532 CHECK_CONTROL_DATA_SIZE(0);
533 if (ctdb
->recovery_lock
!= NULL
) {
534 outdata
->dptr
= discard_const(ctdb
->recovery_lock
);
535 outdata
->dsize
= strlen(ctdb
->recovery_lock
) + 1;
538 case CTDB_CONTROL_SET_RECLOCK_FILE
:
539 return control_not_implemented("SET_RECLOCK", NULL
);
541 case CTDB_CONTROL_STOP_NODE
:
542 CHECK_CONTROL_DATA_SIZE(0);
543 return ctdb_control_stop_node(ctdb
);
545 case CTDB_CONTROL_CONTINUE_NODE
:
546 CHECK_CONTROL_DATA_SIZE(0);
547 return ctdb_control_continue_node(ctdb
);
549 case CTDB_CONTROL_SET_NATGWSTATE
:
550 return control_not_implemented("SET_NATGWSTATE", NULL
);
552 case CTDB_CONTROL_SET_LMASTERROLE
: {
553 uint32_t lmasterrole
;
555 CHECK_CONTROL_DATA_SIZE(sizeof(uint32_t));
556 lmasterrole
= *(uint32_t *)indata
.dptr
;
557 if (lmasterrole
== 0) {
558 ctdb
->capabilities
&= ~CTDB_CAP_LMASTER
;
560 ctdb
->capabilities
|= CTDB_CAP_LMASTER
;
565 case CTDB_CONTROL_SET_RECMASTERROLE
: {
566 uint32_t recmasterrole
;
568 CHECK_CONTROL_DATA_SIZE(sizeof(uint32_t));
569 recmasterrole
= *(uint32_t *)indata
.dptr
;
570 if (recmasterrole
== 0) {
571 ctdb
->capabilities
&= ~CTDB_CAP_RECMASTER
;
573 ctdb
->capabilities
|= CTDB_CAP_RECMASTER
;
578 case CTDB_CONTROL_ENABLE_SCRIPT
:
579 return control_not_implemented("ENABLE_SCRIPT", NULL
);
581 case CTDB_CONTROL_DISABLE_SCRIPT
:
582 return control_not_implemented("DISABLE_SCRIPT", NULL
);
584 case CTDB_CONTROL_SET_BAN_STATE
:
585 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_ban_state
));
586 return ctdb_control_set_ban_state(ctdb
, indata
);
588 case CTDB_CONTROL_GET_BAN_STATE
:
589 CHECK_CONTROL_DATA_SIZE(0);
590 return ctdb_control_get_ban_state(ctdb
, outdata
);
592 case CTDB_CONTROL_SET_DB_PRIORITY
:
593 return control_not_implemented("SET_DB_PRIORITY", NULL
);
595 case CTDB_CONTROL_GET_DB_PRIORITY
:
596 return control_not_implemented("GET_DB_PRIORITY", NULL
);
598 case CTDB_CONTROL_TRANSACTION_CANCEL
:
599 return control_not_implemented("TRANSACTION_CANCEL", NULL
);
601 case CTDB_CONTROL_REGISTER_NOTIFY
:
602 return ctdb_control_register_notify(ctdb
, client_id
, indata
);
604 case CTDB_CONTROL_DEREGISTER_NOTIFY
:
605 CHECK_CONTROL_DATA_SIZE(sizeof(uint64_t));
606 return ctdb_control_deregister_notify(ctdb
, client_id
, indata
);
608 case CTDB_CONTROL_GET_LOG
:
609 return control_not_implemented("GET_LOG", NULL
);
611 case CTDB_CONTROL_CLEAR_LOG
:
612 return control_not_implemented("CLEAR_LOG", NULL
);
614 case CTDB_CONTROL_GET_DB_SEQNUM
:
615 CHECK_CONTROL_DATA_SIZE(sizeof(uint64_t));
616 return ctdb_control_get_db_seqnum(ctdb
, indata
, outdata
);
618 case CTDB_CONTROL_DB_SET_HEALTHY
:
619 CHECK_CONTROL_DATA_SIZE(sizeof(uint32_t));
620 return ctdb_control_db_set_healthy(ctdb
, indata
);
622 case CTDB_CONTROL_DB_GET_HEALTH
:
623 CHECK_CONTROL_DATA_SIZE(sizeof(uint32_t));
624 return ctdb_control_db_get_health(ctdb
, indata
, outdata
);
626 case CTDB_CONTROL_GET_PUBLIC_IP_INFO
:
627 CHECK_CONTROL_DATA_SIZE(sizeof(ctdb_sock_addr
));
628 return ctdb_control_get_public_ip_info(ctdb
, c
, indata
, outdata
);
630 case CTDB_CONTROL_GET_IFACES
:
631 CHECK_CONTROL_DATA_SIZE(0);
632 return ctdb_control_get_ifaces(ctdb
, c
, outdata
);
634 case CTDB_CONTROL_SET_IFACE_LINK_STATE
:
635 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_iface
));
636 return ctdb_control_set_iface_link(ctdb
, c
, indata
);
638 case CTDB_CONTROL_GET_STAT_HISTORY
:
639 CHECK_CONTROL_DATA_SIZE(0);
640 return ctdb_control_get_stat_history(ctdb
, c
, outdata
);
642 case CTDB_CONTROL_SCHEDULE_FOR_DELETION
: {
643 struct ctdb_control_schedule_for_deletion
*d
;
644 size_t size
= offsetof(struct ctdb_control_schedule_for_deletion
, key
);
645 CHECK_CONTROL_MIN_DATA_SIZE(size
);
646 d
= (struct ctdb_control_schedule_for_deletion
*)indata
.dptr
;
648 CHECK_CONTROL_DATA_SIZE(size
);
649 return ctdb_control_schedule_for_deletion(ctdb
, indata
);
651 case CTDB_CONTROL_GET_DB_STATISTICS
:
652 CHECK_CONTROL_DATA_SIZE(sizeof(uint32_t));
653 return ctdb_control_get_db_statistics(ctdb
, *(uint32_t *)indata
.dptr
, outdata
);
655 case CTDB_CONTROL_RELOAD_PUBLIC_IPS
:
656 CHECK_CONTROL_DATA_SIZE(0);
657 return ctdb_control_reload_public_ips(ctdb
, c
, async_reply
);
659 case CTDB_CONTROL_RECEIVE_RECORDS
:
660 return control_not_implemented("RECEIVE_RECORDS", NULL
);
662 case CTDB_CONTROL_DB_DETACH
:
663 return ctdb_control_db_detach(ctdb
, indata
, client_id
);
665 case CTDB_CONTROL_DB_FREEZE
:
666 CHECK_CONTROL_DATA_SIZE(sizeof(uint32_t));
667 return ctdb_control_db_freeze(ctdb
, c
, *(uint32_t *)indata
.dptr
,
670 case CTDB_CONTROL_DB_THAW
:
671 CHECK_CONTROL_DATA_SIZE(sizeof(uint32_t));
672 return ctdb_control_db_thaw(ctdb
, *(uint32_t *)indata
.dptr
);
674 case CTDB_CONTROL_DB_TRANSACTION_START
:
675 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_transdb
));
676 return ctdb_control_db_transaction_start(ctdb
, indata
);
678 case CTDB_CONTROL_DB_TRANSACTION_COMMIT
:
679 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_transdb
));
680 return ctdb_control_db_transaction_commit(ctdb
, indata
);
682 case CTDB_CONTROL_DB_TRANSACTION_CANCEL
:
683 CHECK_CONTROL_DATA_SIZE(sizeof(uint32_t));
684 return ctdb_control_db_transaction_cancel(ctdb
, indata
);
686 case CTDB_CONTROL_DB_PULL
:
687 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_pulldb_ext
));
688 return ctdb_control_db_pull(ctdb
, c
, indata
, outdata
);
690 case CTDB_CONTROL_DB_PUSH_START
:
691 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_pulldb_ext
));
692 return ctdb_control_db_push_start(ctdb
, indata
);
694 case CTDB_CONTROL_DB_PUSH_CONFIRM
:
695 CHECK_CONTROL_DATA_SIZE(sizeof(uint32_t));
696 return ctdb_control_db_push_confirm(ctdb
, indata
, outdata
);
698 case CTDB_CONTROL_DB_OPEN_FLAGS
: {
700 struct ctdb_db_context
*ctdb_db
;
703 CHECK_CONTROL_DATA_SIZE(sizeof(db_id
));
704 db_id
= *(uint32_t *)indata
.dptr
;
705 ctdb_db
= find_ctdb_db(ctdb
, db_id
);
706 if (ctdb_db
== NULL
) {
710 tdb_flags
= tdb_get_flags(ctdb_db
->ltdb
->tdb
);
712 outdata
->dptr
= talloc_size(outdata
, sizeof(tdb_flags
));
713 if (outdata
->dptr
== NULL
) {
717 outdata
->dsize
= sizeof(tdb_flags
);
718 memcpy(outdata
->dptr
, &tdb_flags
, outdata
->dsize
);
722 case CTDB_CONTROL_CHECK_PID_SRVID
:
723 CHECK_CONTROL_DATA_SIZE((sizeof(pid_t
) + sizeof(uint64_t)));
724 return ctdb_control_check_pid_srvid(ctdb
, indata
);
726 case CTDB_CONTROL_TUNNEL_REGISTER
:
727 return ctdb_control_tunnel_register(ctdb
, client_id
, srvid
);
729 case CTDB_CONTROL_TUNNEL_DEREGISTER
:
730 return ctdb_control_tunnel_deregister(ctdb
, client_id
, srvid
);
733 DEBUG(DEBUG_CRIT
,(__location__
" Unknown CTDB control opcode %u\n", opcode
));
739 send a reply for a ctdb control
741 void ctdb_request_control_reply(struct ctdb_context
*ctdb
, struct ctdb_req_control_old
*c
,
742 TDB_DATA
*outdata
, int32_t status
, const char *errormsg
)
744 struct ctdb_reply_control_old
*r
;
747 /* some controls send no reply */
748 if (c
->flags
& CTDB_CTRL_FLAG_NOREPLY
) {
752 len
= offsetof(struct ctdb_reply_control_old
, data
) + (outdata
?outdata
->dsize
:0);
754 len
+= strlen(errormsg
);
756 r
= ctdb_transport_allocate(ctdb
, ctdb
, CTDB_REPLY_CONTROL
, len
, struct ctdb_reply_control_old
);
758 DEBUG(DEBUG_ERR
,(__location__
"Unable to allocate transport - OOM or transport is down\n"));
762 r
->hdr
.destnode
= c
->hdr
.srcnode
;
763 r
->hdr
.reqid
= c
->hdr
.reqid
;
765 r
->datalen
= outdata
?outdata
->dsize
:0;
766 if (outdata
&& outdata
->dsize
) {
767 memcpy(&r
->data
[0], outdata
->dptr
, outdata
->dsize
);
770 r
->errorlen
= strlen(errormsg
);
771 memcpy(&r
->data
[r
->datalen
], errormsg
, r
->errorlen
);
774 ctdb_queue_packet_opcode(ctdb
, &r
->hdr
, c
->opcode
);
780 called when a CTDB_REQ_CONTROL packet comes in
782 void ctdb_request_control(struct ctdb_context
*ctdb
, struct ctdb_req_header
*hdr
)
784 struct ctdb_req_control_old
*c
= (struct ctdb_req_control_old
*)hdr
;
785 TDB_DATA data
, *outdata
;
787 bool async_reply
= false;
788 const char *errormsg
= NULL
;
790 data
.dptr
= &c
->data
[0];
791 data
.dsize
= c
->datalen
;
793 outdata
= talloc_zero(c
, TDB_DATA
);
795 status
= ctdb_control_dispatch(ctdb
, c
, data
, outdata
, hdr
->srcnode
,
796 &errormsg
, &async_reply
);
799 ctdb_request_control_reply(ctdb
, c
, outdata
, status
, errormsg
);
804 called when a CTDB_REPLY_CONTROL packet comes in
806 void ctdb_reply_control(struct ctdb_context
*ctdb
, struct ctdb_req_header
*hdr
)
808 struct ctdb_reply_control_old
*c
= (struct ctdb_reply_control_old
*)hdr
;
810 struct ctdb_control_state
*state
;
811 const char *errormsg
= NULL
;
813 state
= reqid_find(ctdb
->idr
, hdr
->reqid
, struct ctdb_control_state
);
815 DEBUG(DEBUG_ERR
,("pnn %u Invalid reqid %u in ctdb_reply_control\n",
816 ctdb
->pnn
, hdr
->reqid
));
820 if (hdr
->reqid
!= state
->reqid
) {
821 /* we found a record but it was the wrong one */
822 DEBUG(DEBUG_ERR
, ("Dropped orphaned control reply with reqid:%u\n", hdr
->reqid
));
826 data
.dptr
= &c
->data
[0];
827 data
.dsize
= c
->datalen
;
829 errormsg
= talloc_strndup(state
,
830 (char *)&c
->data
[c
->datalen
], c
->errorlen
);
833 /* make state a child of the packet, so it goes away when the packet
835 talloc_steal(hdr
, state
);
837 state
->callback(ctdb
, c
->status
, data
, errormsg
, state
->private_data
);
840 static int ctdb_control_destructor(struct ctdb_control_state
*state
)
842 reqid_remove(state
->ctdb
->idr
, state
->reqid
);
847 handle a timeout of a control
849 static void ctdb_control_timeout(struct tevent_context
*ev
,
850 struct tevent_timer
*te
,
851 struct timeval t
, void *private_data
)
853 struct ctdb_control_state
*state
= talloc_get_type(private_data
, struct ctdb_control_state
);
854 TALLOC_CTX
*tmp_ctx
= talloc_new(ev
);
856 CTDB_INCREMENT_STAT(state
->ctdb
, timeouts
.control
);
858 talloc_steal(tmp_ctx
, state
);
860 state
->callback(state
->ctdb
, -1, tdb_null
,
861 "ctdb_control timed out",
862 state
->private_data
);
863 talloc_free(tmp_ctx
);
868 send a control message to a node
870 int ctdb_daemon_send_control(struct ctdb_context
*ctdb
, uint32_t destnode
,
871 uint64_t srvid
, uint32_t opcode
, uint32_t client_id
,
874 ctdb_control_callback_fn_t callback
,
877 struct ctdb_req_control_old
*c
;
878 struct ctdb_control_state
*state
;
881 if (ctdb
->methods
== NULL
) {
882 DEBUG(DEBUG_INFO
,(__location__
" Failed to send control. Transport is DOWN\n"));
886 if (((destnode
== CTDB_BROADCAST_ACTIVE
) ||
887 (destnode
== CTDB_BROADCAST_ALL
) ||
888 (destnode
== CTDB_BROADCAST_CONNECTED
)) &&
889 !(flags
& CTDB_CTRL_FLAG_NOREPLY
)) {
890 DEBUG(DEBUG_CRIT
,("Attempt to broadcast control without NOREPLY\n"));
894 if (destnode
!= CTDB_BROADCAST_ACTIVE
&&
895 destnode
!= CTDB_BROADCAST_ALL
&&
896 destnode
!= CTDB_BROADCAST_CONNECTED
&&
897 (!ctdb_validate_pnn(ctdb
, destnode
) ||
898 (ctdb
->nodes
[destnode
]->flags
& NODE_FLAGS_DISCONNECTED
))) {
899 if (!(flags
& CTDB_CTRL_FLAG_NOREPLY
)) {
900 callback(ctdb
, -1, tdb_null
, "ctdb_control to disconnected node", private_data
);
905 /* the state is made a child of private_data if possible. This means any reply
906 will be discarded if the private_data goes away */
907 state
= talloc(private_data
?private_data
:ctdb
, struct ctdb_control_state
);
908 CTDB_NO_MEMORY(ctdb
, state
);
910 state
->reqid
= reqid_new(ctdb
->idr
, state
);
911 state
->callback
= callback
;
912 state
->private_data
= private_data
;
914 state
->flags
= flags
;
916 talloc_set_destructor(state
, ctdb_control_destructor
);
918 len
= offsetof(struct ctdb_req_control_old
, data
) + data
.dsize
;
919 c
= ctdb_transport_allocate(ctdb
, state
, CTDB_REQ_CONTROL
, len
,
920 struct ctdb_req_control_old
);
921 CTDB_NO_MEMORY(ctdb
, c
);
922 talloc_set_name_const(c
, "ctdb_req_control packet");
924 c
->hdr
.destnode
= destnode
;
925 c
->hdr
.reqid
= state
->reqid
;
927 c
->client_id
= client_id
;
930 c
->datalen
= data
.dsize
;
932 memcpy(&c
->data
[0], data
.dptr
, data
.dsize
);
935 ctdb_queue_packet(ctdb
, &c
->hdr
);
937 if (flags
& CTDB_CTRL_FLAG_NOREPLY
) {
942 if (ctdb
->tunable
.control_timeout
) {
943 tevent_add_timer(ctdb
->ev
, state
,
944 timeval_current_ofs(ctdb
->tunable
.control_timeout
, 0),
945 ctdb_control_timeout
, state
);