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/>.
21 #include "system/network.h"
22 #include "system/filesys.h"
23 #include "system/wait.h"
24 #include "../include/ctdb_private.h"
25 #include "lib/util/dlinklist.h"
26 #include "lib/tdb_wrap/tdb_wrap.h"
27 #include "lib/util/talloc_report.h"
30 struct ctdb_control_state
{
31 struct ctdb_context
*ctdb
;
33 ctdb_control_callback_fn_t callback
;
40 dump talloc memory hierarchy, returning it as a blob to the client
42 int32_t ctdb_dump_memory(struct ctdb_context
*ctdb
, TDB_DATA
*outdata
)
47 report
= talloc_report_str(outdata
, NULL
);
50 (__location__
" talloc_report_str failed\n"));
53 reportlen
= talloc_get_size(report
);
56 reportlen
-= 1; /* strip trailing zero */
59 outdata
->dptr
= (uint8_t *)report
;
60 outdata
->dsize
= reportlen
;
64 static int32_t control_not_implemented(const char *unsupported
,
65 const char *alternate
)
67 if (alternate
== NULL
) {
69 ("Control %s is not implemented any more\n",
73 ("Control %s is not implemented any more, use %s instead\n",
74 unsupported
, alternate
));
80 process a control request
82 static int32_t ctdb_control_dispatch(struct ctdb_context
*ctdb
,
83 struct ctdb_req_control
*c
,
85 TDB_DATA
*outdata
, uint32_t srcnode
,
86 const char **errormsg
,
89 uint32_t opcode
= c
->opcode
;
90 uint64_t srvid
= c
->srvid
;
91 uint32_t client_id
= c
->client_id
;
94 case CTDB_CONTROL_PROCESS_EXISTS
: {
95 CHECK_CONTROL_DATA_SIZE(sizeof(pid_t
));
96 return ctdb_control_process_exists(ctdb
, *(pid_t
*)indata
.dptr
);
99 case CTDB_CONTROL_SET_DEBUG
: {
100 CHECK_CONTROL_DATA_SIZE(sizeof(int32_t));
101 DEBUGLEVEL
= *(int32_t *)indata
.dptr
;
105 case CTDB_CONTROL_GET_DEBUG
: {
106 CHECK_CONTROL_DATA_SIZE(0);
107 outdata
->dptr
= (uint8_t *)&(DEBUGLEVEL
);
108 outdata
->dsize
= sizeof(DEBUGLEVEL
);
112 case CTDB_CONTROL_STATISTICS
: {
114 CHECK_CONTROL_DATA_SIZE(0);
115 ctdb
->statistics
.memory_used
= talloc_total_size(NULL
);
116 ctdb
->statistics
.num_clients
= ctdb
->num_clients
;
117 ctdb
->statistics
.frozen
= 0;
118 for (i
=1; i
<= NUM_DB_PRIORITIES
; i
++) {
119 if (ctdb
->freeze_mode
[i
] == CTDB_FREEZE_FROZEN
) {
120 ctdb
->statistics
.frozen
= 1;
123 ctdb
->statistics
.recovering
= (ctdb
->recovery_mode
== CTDB_RECOVERY_ACTIVE
);
124 ctdb
->statistics
.statistics_current_time
= timeval_current();
126 outdata
->dptr
= (uint8_t *)&ctdb
->statistics
;
127 outdata
->dsize
= sizeof(ctdb
->statistics
);
131 case CTDB_CONTROL_GET_ALL_TUNABLES
: {
132 CHECK_CONTROL_DATA_SIZE(0);
133 outdata
->dptr
= (uint8_t *)&ctdb
->tunable
;
134 outdata
->dsize
= sizeof(ctdb
->tunable
);
138 case CTDB_CONTROL_DUMP_MEMORY
: {
139 CHECK_CONTROL_DATA_SIZE(0);
140 return ctdb_dump_memory(ctdb
, outdata
);
143 case CTDB_CONTROL_STATISTICS_RESET
: {
144 struct ctdb_db_context
*ctdb_db
;
146 CHECK_CONTROL_DATA_SIZE(0);
147 ZERO_STRUCT(ctdb
->statistics
);
148 for (ctdb_db
= ctdb
->db_list
;
150 ctdb_db
= ctdb_db
->next
) {
151 ctdb_db_statistics_reset(ctdb_db
);
153 ctdb
->statistics
.statistics_start_time
= timeval_current();
157 case CTDB_CONTROL_GETVNNMAP
:
158 return ctdb_control_getvnnmap(ctdb
, opcode
, indata
, outdata
);
160 case CTDB_CONTROL_GET_DBMAP
:
161 return ctdb_control_getdbmap(ctdb
, opcode
, indata
, outdata
);
163 case CTDB_CONTROL_GET_NODEMAPv4
:
164 return control_not_implemented("GET_NODEMAPv4", "GET_NODEMAP");
166 case CTDB_CONTROL_GET_NODEMAP
:
167 return ctdb_control_getnodemap(ctdb
, opcode
, indata
, outdata
);
169 case CTDB_CONTROL_GET_NODES_FILE
:
170 return ctdb_control_getnodesfile(ctdb
, opcode
, indata
, outdata
);
172 case CTDB_CONTROL_RELOAD_NODES_FILE
:
173 CHECK_CONTROL_DATA_SIZE(0);
174 return ctdb_control_reload_nodes_file(ctdb
, opcode
);
176 case CTDB_CONTROL_SET_DB_STICKY
: {
178 struct ctdb_db_context
*ctdb_db
;
180 CHECK_CONTROL_DATA_SIZE(sizeof(db_id
));
181 db_id
= *(uint32_t *)indata
.dptr
;
182 ctdb_db
= find_ctdb_db(ctdb
, db_id
);
183 if (ctdb_db
== NULL
) return -1;
184 return ctdb_set_db_sticky(ctdb
, ctdb_db
);
187 case CTDB_CONTROL_SETVNNMAP
:
188 return ctdb_control_setvnnmap(ctdb
, opcode
, indata
, outdata
);
190 case CTDB_CONTROL_PULL_DB
:
191 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_control_pulldb
));
192 return ctdb_control_pull_db(ctdb
, indata
, outdata
);
194 case CTDB_CONTROL_SET_DMASTER
:
195 return control_not_implemented("SET_DMASTER", NULL
);
197 case CTDB_CONTROL_PUSH_DB
:
198 return ctdb_control_push_db(ctdb
, indata
);
200 case CTDB_CONTROL_GET_RECMODE
: {
201 return ctdb
->recovery_mode
;
204 case CTDB_CONTROL_SET_RECMASTER
: {
205 return ctdb_control_set_recmaster(ctdb
, opcode
, indata
);
208 case CTDB_CONTROL_GET_RECMASTER
:
209 return ctdb
->recovery_master
;
211 case CTDB_CONTROL_GET_PID
:
214 case CTDB_CONTROL_GET_PNN
:
217 case CTDB_CONTROL_PING
:
218 CHECK_CONTROL_DATA_SIZE(0);
219 return ctdb
->num_clients
;
221 case CTDB_CONTROL_GET_RUNSTATE
:
222 CHECK_CONTROL_DATA_SIZE(0);
223 outdata
->dptr
= (uint8_t *)&ctdb
->runstate
;
224 outdata
->dsize
= sizeof(uint32_t);
228 case CTDB_CONTROL_SET_DB_READONLY
: {
230 struct ctdb_db_context
*ctdb_db
;
232 CHECK_CONTROL_DATA_SIZE(sizeof(db_id
));
233 db_id
= *(uint32_t *)indata
.dptr
;
234 ctdb_db
= find_ctdb_db(ctdb
, db_id
);
235 if (ctdb_db
== NULL
) return -1;
236 return ctdb_set_db_readonly(ctdb
, ctdb_db
);
238 case CTDB_CONTROL_GET_DBNAME
: {
240 struct ctdb_db_context
*ctdb_db
;
242 CHECK_CONTROL_DATA_SIZE(sizeof(db_id
));
243 db_id
= *(uint32_t *)indata
.dptr
;
244 ctdb_db
= find_ctdb_db(ctdb
, db_id
);
245 if (ctdb_db
== NULL
) return -1;
246 outdata
->dptr
= discard_const(ctdb_db
->db_name
);
247 outdata
->dsize
= strlen(ctdb_db
->db_name
)+1;
251 case CTDB_CONTROL_GETDBPATH
: {
253 struct ctdb_db_context
*ctdb_db
;
255 CHECK_CONTROL_DATA_SIZE(sizeof(db_id
));
256 db_id
= *(uint32_t *)indata
.dptr
;
257 ctdb_db
= find_ctdb_db(ctdb
, db_id
);
258 if (ctdb_db
== NULL
) return -1;
259 outdata
->dptr
= discard_const(ctdb_db
->db_path
);
260 outdata
->dsize
= strlen(ctdb_db
->db_path
)+1;
264 case CTDB_CONTROL_DB_ATTACH
:
265 return ctdb_control_db_attach(ctdb
, indata
, outdata
, srvid
, false, client_id
, c
, async_reply
);
267 case CTDB_CONTROL_DB_ATTACH_PERSISTENT
:
268 return ctdb_control_db_attach(ctdb
, indata
, outdata
, srvid
, true, client_id
, c
, async_reply
);
270 case CTDB_CONTROL_SET_CALL
:
271 return control_not_implemented("SET_CALL", NULL
);
273 case CTDB_CONTROL_TRAVERSE_START
:
274 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_traverse_start
));
275 return ctdb_control_traverse_start(ctdb
, indata
, outdata
, srcnode
, client_id
);
277 case CTDB_CONTROL_TRAVERSE_START_EXT
:
278 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_traverse_start_ext
));
279 return ctdb_control_traverse_start_ext(ctdb
, indata
, outdata
, srcnode
, client_id
);
281 case CTDB_CONTROL_TRAVERSE_ALL
:
282 return ctdb_control_traverse_all(ctdb
, indata
, outdata
);
284 case CTDB_CONTROL_TRAVERSE_ALL_EXT
:
285 return ctdb_control_traverse_all_ext(ctdb
, indata
, outdata
);
287 case CTDB_CONTROL_TRAVERSE_DATA
:
288 return ctdb_control_traverse_data(ctdb
, indata
, outdata
);
290 case CTDB_CONTROL_TRAVERSE_KILL
:
291 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_traverse_start
));
292 return ctdb_control_traverse_kill(ctdb
, indata
, outdata
, srcnode
);
294 case CTDB_CONTROL_REGISTER_SRVID
:
295 return daemon_register_message_handler(ctdb
, client_id
, srvid
);
297 case CTDB_CONTROL_DEREGISTER_SRVID
:
298 return daemon_deregister_message_handler(ctdb
, client_id
, srvid
);
300 case CTDB_CONTROL_CHECK_SRVIDS
:
301 return daemon_check_srvids(ctdb
, indata
, outdata
);
303 case CTDB_CONTROL_ENABLE_SEQNUM
:
304 CHECK_CONTROL_DATA_SIZE(sizeof(uint32_t));
305 return ctdb_ltdb_enable_seqnum(ctdb
, *(uint32_t *)indata
.dptr
);
307 case CTDB_CONTROL_UPDATE_SEQNUM
:
308 CHECK_CONTROL_DATA_SIZE(sizeof(uint32_t));
309 return ctdb_ltdb_update_seqnum(ctdb
, *(uint32_t *)indata
.dptr
, srcnode
);
311 case CTDB_CONTROL_FREEZE
:
312 CHECK_CONTROL_DATA_SIZE(0);
313 return ctdb_control_freeze(ctdb
, c
, async_reply
);
315 case CTDB_CONTROL_THAW
:
316 CHECK_CONTROL_DATA_SIZE(0);
317 return ctdb_control_thaw(ctdb
, (uint32_t)c
->srvid
, true);
319 case CTDB_CONTROL_SET_RECMODE
:
320 CHECK_CONTROL_DATA_SIZE(sizeof(uint32_t));
321 return ctdb_control_set_recmode(ctdb
, c
, indata
, async_reply
, errormsg
);
323 case CTDB_CONTROL_GET_MONMODE
:
324 CHECK_CONTROL_DATA_SIZE(0);
325 return ctdb_monitoring_mode(ctdb
);
327 case CTDB_CONTROL_ENABLE_MONITOR
:
328 CHECK_CONTROL_DATA_SIZE(0);
329 ctdb_enable_monitoring(ctdb
);
332 case CTDB_CONTROL_RUN_EVENTSCRIPTS
:
333 return ctdb_run_eventscripts(ctdb
, c
, indata
, async_reply
);
335 case CTDB_CONTROL_DISABLE_MONITOR
:
336 CHECK_CONTROL_DATA_SIZE(0);
337 ctdb_disable_monitoring(ctdb
);
340 case CTDB_CONTROL_SHUTDOWN
:
341 DEBUG(DEBUG_NOTICE
,("Received SHUTDOWN command.\n"));
342 ctdb_shutdown_sequence(ctdb
, 0);
343 /* In case above returns due to duplicate shutdown */
346 case CTDB_CONTROL_TAKEOVER_IPv4
:
347 return control_not_implemented("TAKEOVER_IPv4", "TAKEOVER_IP");
349 case CTDB_CONTROL_TAKEOVER_IP
:
350 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_public_ip
));
351 return ctdb_control_takeover_ip(ctdb
, c
, indata
, async_reply
);
353 case CTDB_CONTROL_RELEASE_IPv4
:
354 return control_not_implemented("RELEASE_IPv4", "RELEASE_IP");
356 case CTDB_CONTROL_RELEASE_IP
:
357 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_public_ip
));
358 return ctdb_control_release_ip(ctdb
, c
, indata
, async_reply
);
360 case CTDB_CONTROL_IPREALLOCATED
:
361 CHECK_CONTROL_DATA_SIZE(0);
362 return ctdb_control_ipreallocated(ctdb
, c
, async_reply
);
364 case CTDB_CONTROL_GET_PUBLIC_IPSv4
:
365 return control_not_implemented("GET_PUBLIC_IPSv4",
368 case CTDB_CONTROL_GET_PUBLIC_IPS
:
369 CHECK_CONTROL_DATA_SIZE(0);
370 return ctdb_control_get_public_ips(ctdb
, c
, outdata
);
372 case CTDB_CONTROL_TCP_CLIENT
:
373 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_control_tcp_addr
));
374 return ctdb_control_tcp_client(ctdb
, client_id
, indata
);
376 case CTDB_CONTROL_STARTUP
:
377 CHECK_CONTROL_DATA_SIZE(0);
378 return ctdb_control_startup(ctdb
, srcnode
);
380 case CTDB_CONTROL_TCP_ADD
:
381 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_tcp_connection
));
382 return ctdb_control_tcp_add(ctdb
, indata
, false);
384 case CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE
:
385 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_tcp_connection
));
386 return ctdb_control_tcp_add(ctdb
, indata
, true);
388 case CTDB_CONTROL_TCP_REMOVE
:
389 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_tcp_connection
));
390 return ctdb_control_tcp_remove(ctdb
, indata
);
392 case CTDB_CONTROL_SET_TUNABLE
:
393 return ctdb_control_set_tunable(ctdb
, indata
);
395 case CTDB_CONTROL_GET_TUNABLE
:
396 return ctdb_control_get_tunable(ctdb
, indata
, outdata
);
398 case CTDB_CONTROL_LIST_TUNABLES
:
399 return ctdb_control_list_tunables(ctdb
, outdata
);
401 case CTDB_CONTROL_MODIFY_FLAGS
:
402 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_node_flag_change
));
403 return ctdb_control_modflags(ctdb
, indata
);
405 case CTDB_CONTROL_KILL_TCP
:
406 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_control_killtcp
));
407 return ctdb_control_kill_tcp(ctdb
, indata
);
409 case CTDB_CONTROL_GET_TCP_TICKLE_LIST
:
410 CHECK_CONTROL_DATA_SIZE(sizeof(ctdb_sock_addr
));
411 return ctdb_control_get_tcp_tickle_list(ctdb
, indata
, outdata
);
413 case CTDB_CONTROL_SET_TCP_TICKLE_LIST
:
414 /* data size is verified in the called function */
415 return ctdb_control_set_tcp_tickle_list(ctdb
, indata
);
417 case CTDB_CONTROL_REGISTER_SERVER_ID
:
418 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_server_id
));
419 return ctdb_control_register_server_id(ctdb
, client_id
, indata
);
421 case CTDB_CONTROL_UNREGISTER_SERVER_ID
:
422 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_server_id
));
423 return ctdb_control_unregister_server_id(ctdb
, indata
);
425 case CTDB_CONTROL_CHECK_SERVER_ID
:
426 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_server_id
));
427 return ctdb_control_check_server_id(ctdb
, indata
);
429 case CTDB_CONTROL_GET_SERVER_ID_LIST
:
430 CHECK_CONTROL_DATA_SIZE(0);
431 return ctdb_control_get_server_id_list(ctdb
, outdata
);
433 case CTDB_CONTROL_PERSISTENT_STORE
:
434 return control_not_implemented("PERSISTENT_STORE", NULL
);
436 case CTDB_CONTROL_UPDATE_RECORD
:
437 return ctdb_control_update_record(ctdb
, c
, indata
, async_reply
);
439 case CTDB_CONTROL_SEND_GRATIOUS_ARP
:
440 return ctdb_control_send_gratious_arp(ctdb
, indata
);
442 case CTDB_CONTROL_TRANSACTION_START
:
443 CHECK_CONTROL_DATA_SIZE(sizeof(uint32_t));
444 return ctdb_control_transaction_start(ctdb
, *(uint32_t *)indata
.dptr
);
446 case CTDB_CONTROL_TRANSACTION_COMMIT
:
447 CHECK_CONTROL_DATA_SIZE(sizeof(uint32_t));
448 return ctdb_control_transaction_commit(ctdb
, *(uint32_t *)indata
.dptr
);
450 case CTDB_CONTROL_WIPE_DATABASE
:
451 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_control_wipe_database
));
452 return ctdb_control_wipe_database(ctdb
, indata
);
454 case CTDB_CONTROL_UPTIME
:
455 return ctdb_control_uptime(ctdb
, outdata
);
457 case CTDB_CONTROL_START_RECOVERY
:
458 return ctdb_control_start_recovery(ctdb
, c
, async_reply
);
460 case CTDB_CONTROL_END_RECOVERY
:
461 return ctdb_control_end_recovery(ctdb
, c
, async_reply
);
463 case CTDB_CONTROL_TRY_DELETE_RECORDS
:
464 return ctdb_control_try_delete_records(ctdb
, indata
, outdata
);
466 case CTDB_CONTROL_ADD_PUBLIC_IP
:
467 return ctdb_control_add_public_address(ctdb
, indata
);
469 case CTDB_CONTROL_DEL_PUBLIC_IP
:
470 return ctdb_control_del_public_address(ctdb
, c
, indata
,
473 case CTDB_CONTROL_GET_CAPABILITIES
:
474 return ctdb_control_get_capabilities(ctdb
, outdata
);
476 case CTDB_CONTROL_START_PERSISTENT_UPDATE
:
477 return ctdb_control_start_persistent_update(ctdb
, c
, indata
);
479 case CTDB_CONTROL_CANCEL_PERSISTENT_UPDATE
:
480 return ctdb_control_cancel_persistent_update(ctdb
, c
, indata
);
482 case CTDB_CONTROL_TRANS2_COMMIT
:
483 case CTDB_CONTROL_TRANS2_COMMIT_RETRY
:
484 return control_not_implemented("TRANS2_COMMIT", "TRANS3_COMMIT");
486 case CTDB_CONTROL_TRANS2_ERROR
:
487 return control_not_implemented("TRANS2_ERROR", NULL
);
489 case CTDB_CONTROL_TRANS2_FINISHED
:
490 return control_not_implemented("TRANS2_FINISHED", NULL
);
492 case CTDB_CONTROL_TRANS2_ACTIVE
:
493 return control_not_implemented("TRANS2_ACTIVE", NULL
);
495 case CTDB_CONTROL_TRANS3_COMMIT
:
496 return ctdb_control_trans3_commit(ctdb
, c
, indata
, async_reply
);
498 case CTDB_CONTROL_RECD_PING
:
499 CHECK_CONTROL_DATA_SIZE(0);
500 return ctdb_control_recd_ping(ctdb
);
502 case CTDB_CONTROL_GET_EVENT_SCRIPT_STATUS
:
503 CHECK_CONTROL_DATA_SIZE(sizeof(uint32_t));
504 return ctdb_control_get_event_script_status(ctdb
, *(uint32_t *)indata
.dptr
, outdata
);
506 case CTDB_CONTROL_RECD_RECLOCK_LATENCY
:
507 CHECK_CONTROL_DATA_SIZE(sizeof(double));
508 CTDB_UPDATE_RECLOCK_LATENCY(ctdb
, "recd reclock", reclock
.recd
, *((double *)indata
.dptr
));
510 case CTDB_CONTROL_GET_RECLOCK_FILE
:
511 CHECK_CONTROL_DATA_SIZE(0);
512 if (ctdb
->recovery_lock_file
!= NULL
) {
513 outdata
->dptr
= discard_const(ctdb
->recovery_lock_file
);
514 outdata
->dsize
= strlen(ctdb
->recovery_lock_file
) + 1;
517 case CTDB_CONTROL_SET_RECLOCK_FILE
: {
520 if (indata
.dsize
== 0) {
521 TALLOC_FREE(ctdb
->recovery_lock_file
);
525 /* Return silent success if unchanged. Recovery
526 * master updates all nodes on each recovery - we
527 * don't need the extra memory allocation or log
528 * message each time. */
529 if (ctdb
->recovery_lock_file
!= NULL
&&
530 strcmp(discard_const(indata
.dptr
),
531 ctdb
->recovery_lock_file
) == 0) {
535 t
= talloc_strdup(ctdb
, discard_const(indata
.dptr
));
537 DEBUG(DEBUG_ERR
, ("Out of memory in SET_RECLOCK_FILE\n"));
541 talloc_free(ctdb
->recovery_lock_file
);
542 ctdb
->recovery_lock_file
= t
;
543 DEBUG(DEBUG_NOTICE
, ("Updated recovery lock file to %s\n", t
));
548 case CTDB_CONTROL_STOP_NODE
:
549 CHECK_CONTROL_DATA_SIZE(0);
550 return ctdb_control_stop_node(ctdb
);
552 case CTDB_CONTROL_CONTINUE_NODE
:
553 CHECK_CONTROL_DATA_SIZE(0);
554 return ctdb_control_continue_node(ctdb
);
556 case CTDB_CONTROL_SET_NATGWSTATE
: {
559 CHECK_CONTROL_DATA_SIZE(sizeof(uint32_t));
560 natgwstate
= *(uint32_t *)indata
.dptr
;
561 if (natgwstate
== 0) {
562 ctdb
->capabilities
&= ~CTDB_CAP_NATGW
;
564 ctdb
->capabilities
|= CTDB_CAP_NATGW
;
569 case CTDB_CONTROL_SET_LMASTERROLE
: {
570 uint32_t lmasterrole
;
572 CHECK_CONTROL_DATA_SIZE(sizeof(uint32_t));
573 lmasterrole
= *(uint32_t *)indata
.dptr
;
574 if (lmasterrole
== 0) {
575 ctdb
->capabilities
&= ~CTDB_CAP_LMASTER
;
577 ctdb
->capabilities
|= CTDB_CAP_LMASTER
;
582 case CTDB_CONTROL_SET_RECMASTERROLE
: {
583 uint32_t recmasterrole
;
585 CHECK_CONTROL_DATA_SIZE(sizeof(uint32_t));
586 recmasterrole
= *(uint32_t *)indata
.dptr
;
587 if (recmasterrole
== 0) {
588 ctdb
->capabilities
&= ~CTDB_CAP_RECMASTER
;
590 ctdb
->capabilities
|= CTDB_CAP_RECMASTER
;
595 case CTDB_CONTROL_ENABLE_SCRIPT
:
596 return ctdb_control_enable_script(ctdb
, indata
);
598 case CTDB_CONTROL_DISABLE_SCRIPT
:
599 return ctdb_control_disable_script(ctdb
, indata
);
601 case CTDB_CONTROL_SET_BAN_STATE
:
602 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_ban_time
));
603 return ctdb_control_set_ban_state(ctdb
, indata
);
605 case CTDB_CONTROL_GET_BAN_STATE
:
606 CHECK_CONTROL_DATA_SIZE(0);
607 return ctdb_control_get_ban_state(ctdb
, outdata
);
609 case CTDB_CONTROL_SET_DB_PRIORITY
:
610 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_db_priority
));
611 return ctdb_control_set_db_priority(ctdb
, indata
, client_id
);
613 case CTDB_CONTROL_GET_DB_PRIORITY
: {
615 struct ctdb_db_context
*ctdb_db
;
617 CHECK_CONTROL_DATA_SIZE(sizeof(db_id
));
618 db_id
= *(uint32_t *)indata
.dptr
;
619 ctdb_db
= find_ctdb_db(ctdb
, db_id
);
620 if (ctdb_db
== NULL
) return -1;
621 return ctdb_db
->priority
;
624 case CTDB_CONTROL_TRANSACTION_CANCEL
:
625 CHECK_CONTROL_DATA_SIZE(0);
626 return ctdb_control_transaction_cancel(ctdb
);
628 case CTDB_CONTROL_REGISTER_NOTIFY
:
629 return ctdb_control_register_notify(ctdb
, client_id
, indata
);
631 case CTDB_CONTROL_DEREGISTER_NOTIFY
:
632 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_client_notify_deregister
));
633 return ctdb_control_deregister_notify(ctdb
, client_id
, indata
);
635 case CTDB_CONTROL_GET_LOG
:
636 return control_not_implemented("GET_LOG", NULL
);
638 case CTDB_CONTROL_CLEAR_LOG
:
639 return control_not_implemented("CLEAR_LOG", NULL
);
641 case CTDB_CONTROL_GET_DB_SEQNUM
:
642 CHECK_CONTROL_DATA_SIZE(sizeof(uint64_t));
643 return ctdb_control_get_db_seqnum(ctdb
, indata
, outdata
);
645 case CTDB_CONTROL_DB_SET_HEALTHY
:
646 CHECK_CONTROL_DATA_SIZE(sizeof(uint32_t));
647 return ctdb_control_db_set_healthy(ctdb
, indata
);
649 case CTDB_CONTROL_DB_GET_HEALTH
:
650 CHECK_CONTROL_DATA_SIZE(sizeof(uint32_t));
651 return ctdb_control_db_get_health(ctdb
, indata
, outdata
);
653 case CTDB_CONTROL_GET_PUBLIC_IP_INFO
:
654 CHECK_CONTROL_DATA_SIZE(sizeof(ctdb_sock_addr
));
655 return ctdb_control_get_public_ip_info(ctdb
, c
, indata
, outdata
);
657 case CTDB_CONTROL_GET_IFACES
:
658 CHECK_CONTROL_DATA_SIZE(0);
659 return ctdb_control_get_ifaces(ctdb
, c
, outdata
);
661 case CTDB_CONTROL_SET_IFACE_LINK_STATE
:
662 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_control_iface_info
));
663 return ctdb_control_set_iface_link(ctdb
, c
, indata
);
665 case CTDB_CONTROL_GET_STAT_HISTORY
:
666 CHECK_CONTROL_DATA_SIZE(0);
667 return ctdb_control_get_stat_history(ctdb
, c
, outdata
);
669 case CTDB_CONTROL_SCHEDULE_FOR_DELETION
: {
670 struct ctdb_control_schedule_for_deletion
*d
;
671 size_t size
= offsetof(struct ctdb_control_schedule_for_deletion
, key
);
672 CHECK_CONTROL_MIN_DATA_SIZE(size
);
673 d
= (struct ctdb_control_schedule_for_deletion
*)indata
.dptr
;
675 CHECK_CONTROL_DATA_SIZE(size
);
676 return ctdb_control_schedule_for_deletion(ctdb
, indata
);
678 case CTDB_CONTROL_GET_DB_STATISTICS
:
679 CHECK_CONTROL_DATA_SIZE(sizeof(uint32_t));
680 return ctdb_control_get_db_statistics(ctdb
, *(uint32_t *)indata
.dptr
, outdata
);
682 case CTDB_CONTROL_RELOAD_PUBLIC_IPS
:
683 CHECK_CONTROL_DATA_SIZE(0);
684 return ctdb_control_reload_public_ips(ctdb
, c
, async_reply
);
686 case CTDB_CONTROL_RECEIVE_RECORDS
:
687 return ctdb_control_receive_records(ctdb
, indata
, outdata
);
689 case CTDB_CONTROL_DB_DETACH
:
690 return ctdb_control_db_detach(ctdb
, indata
, client_id
);
693 DEBUG(DEBUG_CRIT
,(__location__
" Unknown CTDB control opcode %u\n", opcode
));
699 send a reply for a ctdb control
701 void ctdb_request_control_reply(struct ctdb_context
*ctdb
, struct ctdb_req_control
*c
,
702 TDB_DATA
*outdata
, int32_t status
, const char *errormsg
)
704 struct ctdb_reply_control
*r
;
707 /* some controls send no reply */
708 if (c
->flags
& CTDB_CTRL_FLAG_NOREPLY
) {
712 len
= offsetof(struct ctdb_reply_control
, data
) + (outdata
?outdata
->dsize
:0);
714 len
+= strlen(errormsg
);
716 r
= ctdb_transport_allocate(ctdb
, ctdb
, CTDB_REPLY_CONTROL
, len
, struct ctdb_reply_control
);
718 DEBUG(DEBUG_ERR
,(__location__
"Unable to allocate transport - OOM or transport is down\n"));
722 r
->hdr
.destnode
= c
->hdr
.srcnode
;
723 r
->hdr
.reqid
= c
->hdr
.reqid
;
725 r
->datalen
= outdata
?outdata
->dsize
:0;
726 if (outdata
&& outdata
->dsize
) {
727 memcpy(&r
->data
[0], outdata
->dptr
, outdata
->dsize
);
730 r
->errorlen
= strlen(errormsg
);
731 memcpy(&r
->data
[r
->datalen
], errormsg
, r
->errorlen
);
734 ctdb_queue_packet_opcode(ctdb
, &r
->hdr
, c
->opcode
);
740 called when a CTDB_REQ_CONTROL packet comes in
742 void ctdb_request_control(struct ctdb_context
*ctdb
, struct ctdb_req_header
*hdr
)
744 struct ctdb_req_control
*c
= (struct ctdb_req_control
*)hdr
;
745 TDB_DATA data
, *outdata
;
747 bool async_reply
= false;
748 const char *errormsg
= NULL
;
750 data
.dptr
= &c
->data
[0];
751 data
.dsize
= c
->datalen
;
753 outdata
= talloc_zero(c
, TDB_DATA
);
755 status
= ctdb_control_dispatch(ctdb
, c
, data
, outdata
, hdr
->srcnode
,
756 &errormsg
, &async_reply
);
759 ctdb_request_control_reply(ctdb
, c
, outdata
, status
, errormsg
);
764 called when a CTDB_REPLY_CONTROL packet comes in
766 void ctdb_reply_control(struct ctdb_context
*ctdb
, struct ctdb_req_header
*hdr
)
768 struct ctdb_reply_control
*c
= (struct ctdb_reply_control
*)hdr
;
770 struct ctdb_control_state
*state
;
771 const char *errormsg
= NULL
;
773 state
= ctdb_reqid_find(ctdb
, hdr
->reqid
, struct ctdb_control_state
);
775 DEBUG(DEBUG_ERR
,("pnn %u Invalid reqid %u in ctdb_reply_control\n",
776 ctdb
->pnn
, hdr
->reqid
));
780 if (hdr
->reqid
!= state
->reqid
) {
781 /* we found a record but it was the wrong one */
782 DEBUG(DEBUG_ERR
, ("Dropped orphaned control reply with reqid:%u\n", hdr
->reqid
));
786 data
.dptr
= &c
->data
[0];
787 data
.dsize
= c
->datalen
;
789 errormsg
= talloc_strndup(state
,
790 (char *)&c
->data
[c
->datalen
], c
->errorlen
);
793 /* make state a child of the packet, so it goes away when the packet
795 talloc_steal(hdr
, state
);
797 state
->callback(ctdb
, c
->status
, data
, errormsg
, state
->private_data
);
800 static int ctdb_control_destructor(struct ctdb_control_state
*state
)
802 ctdb_reqid_remove(state
->ctdb
, state
->reqid
);
807 handle a timeout of a control
809 static void ctdb_control_timeout(struct event_context
*ev
, struct timed_event
*te
,
810 struct timeval t
, void *private_data
)
812 struct ctdb_control_state
*state
= talloc_get_type(private_data
, struct ctdb_control_state
);
813 TALLOC_CTX
*tmp_ctx
= talloc_new(ev
);
815 CTDB_INCREMENT_STAT(state
->ctdb
, timeouts
.control
);
817 talloc_steal(tmp_ctx
, state
);
819 state
->callback(state
->ctdb
, -1, tdb_null
,
820 "ctdb_control timed out",
821 state
->private_data
);
822 talloc_free(tmp_ctx
);
827 send a control message to a node
829 int ctdb_daemon_send_control(struct ctdb_context
*ctdb
, uint32_t destnode
,
830 uint64_t srvid
, uint32_t opcode
, uint32_t client_id
,
833 ctdb_control_callback_fn_t callback
,
836 struct ctdb_req_control
*c
;
837 struct ctdb_control_state
*state
;
840 if (ctdb
->methods
== NULL
) {
841 DEBUG(DEBUG_INFO
,(__location__
" Failed to send control. Transport is DOWN\n"));
845 if (((destnode
== CTDB_BROADCAST_VNNMAP
) ||
846 (destnode
== CTDB_BROADCAST_ALL
) ||
847 (destnode
== CTDB_BROADCAST_CONNECTED
)) &&
848 !(flags
& CTDB_CTRL_FLAG_NOREPLY
)) {
849 DEBUG(DEBUG_CRIT
,("Attempt to broadcast control without NOREPLY\n"));
853 if (destnode
!= CTDB_BROADCAST_VNNMAP
&&
854 destnode
!= CTDB_BROADCAST_ALL
&&
855 destnode
!= CTDB_BROADCAST_CONNECTED
&&
856 (!ctdb_validate_pnn(ctdb
, destnode
) ||
857 (ctdb
->nodes
[destnode
]->flags
& NODE_FLAGS_DISCONNECTED
))) {
858 if (!(flags
& CTDB_CTRL_FLAG_NOREPLY
)) {
859 callback(ctdb
, -1, tdb_null
, "ctdb_control to disconnected node", private_data
);
864 /* the state is made a child of private_data if possible. This means any reply
865 will be discarded if the private_data goes away */
866 state
= talloc(private_data
?private_data
:ctdb
, struct ctdb_control_state
);
867 CTDB_NO_MEMORY(ctdb
, state
);
869 state
->reqid
= ctdb_reqid_new(ctdb
, state
);
870 state
->callback
= callback
;
871 state
->private_data
= private_data
;
873 state
->flags
= flags
;
875 talloc_set_destructor(state
, ctdb_control_destructor
);
877 len
= offsetof(struct ctdb_req_control
, data
) + data
.dsize
;
878 c
= ctdb_transport_allocate(ctdb
, state
, CTDB_REQ_CONTROL
, len
,
879 struct ctdb_req_control
);
880 CTDB_NO_MEMORY(ctdb
, c
);
881 talloc_set_name_const(c
, "ctdb_req_control packet");
883 c
->hdr
.destnode
= destnode
;
884 c
->hdr
.reqid
= state
->reqid
;
886 c
->client_id
= client_id
;
889 c
->datalen
= data
.dsize
;
891 memcpy(&c
->data
[0], data
.dptr
, data
.dsize
);
894 ctdb_queue_packet(ctdb
, &c
->hdr
);
896 if (flags
& CTDB_CTRL_FLAG_NOREPLY
) {
901 if (ctdb
->tunable
.control_timeout
) {
902 event_add_timed(ctdb
->ev
, state
,
903 timeval_current_ofs(ctdb
->tunable
.control_timeout
, 0),
904 ctdb_control_timeout
, state
);