?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3:script/tests: add a test for VSS write behaviour
[Samba.git] / ctdb / server / ctdb_control.c
blobc260b92452970e39a8b1598891817f6a788bd67d
1 /*
2 ctdb_control protocol code
3
4 Copyright (C) Andrew Tridgell 2007
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, see <http://www.gnu.org/licenses/>.
18 */
19 #include "replace.h"
20 #include "system/network.h"
21 #include "system/filesys.h"
22 #include "system/wait.h"
23
24 #include <talloc.h>
25 #include <tevent.h>
26
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"
32
33 #include "ctdb_private.h"
34 #include "ctdb_client.h"
35
36 #include "common/reqid.h"
37 #include "common/common.h"
38 #include "common/logging.h"
39
40
41 struct ctdb_control_state {
42 struct ctdb_context *ctdb;
43 uint32_t reqid;
44 ctdb_control_callback_fn_t callback;
45 void *private_data;
46 unsigned flags;
47 };
48
49
50 /*
51 dump talloc memory hierarchy, returning it as a blob to the client
52 */
53 int32_t ctdb_dump_memory(struct ctdb_context *ctdb, TDB_DATA *outdata)
54 {
55 char *report;
56 size_t reportlen;
57
58 report = talloc_report_str(outdata, NULL);
59 if (report == NULL) {
60 DEBUG(DEBUG_ERR,
61 (__location__ " talloc_report_str failed\n"));
62 return -1;
63 }
64 reportlen = talloc_get_size(report);
65
66 if (reportlen > 0) {
67 reportlen -= 1; /* strip trailing zero */
68 }
69
70 outdata->dptr = (uint8_t *)report;
71 outdata->dsize = reportlen;
72 return 0;
73 }
74
75 static int32_t control_not_implemented(const char *unsupported,
76 const char *alternate)
77 {
78 if (alternate == NULL) {
79 DEBUG(DEBUG_ERR,
80 ("Control %s is not implemented any more\n",
81 unsupported));
82 } else {
83 DEBUG(DEBUG_ERR,
84 ("Control %s is not implemented any more, use %s instead\n",
85 unsupported, alternate));
86 }
87 return -1;
88 }
89
90 /*
91 process a control request
92 */
93 static int32_t ctdb_control_dispatch(struct ctdb_context *ctdb,
94 struct ctdb_req_control_old *c,
95 TDB_DATA indata,
96 TDB_DATA *outdata, uint32_t srcnode,
97 const char **errormsg,
98 bool *async_reply)
99 {
100 uint32_t opcode = c->opcode;
101 uint64_t srvid = c->srvid;
102 uint32_t client_id = c->client_id;
103
104 switch (opcode) {
105 case CTDB_CONTROL_PROCESS_EXISTS: {
106 CHECK_CONTROL_DATA_SIZE(sizeof(pid_t));
107 return ctdb_control_process_exists(ctdb, *(pid_t *)indata.dptr);
108 }
109
110 case CTDB_CONTROL_SET_DEBUG: {
111 CHECK_CONTROL_DATA_SIZE(sizeof(int32_t));
112 DEBUGLEVEL = *(int32_t *)indata.dptr;
113 return 0;
114 }
115
116 case CTDB_CONTROL_GET_DEBUG: {
117 CHECK_CONTROL_DATA_SIZE(0);
118 outdata->dptr = (uint8_t *)&(DEBUGLEVEL);
119 outdata->dsize = sizeof(DEBUGLEVEL);
120 return 0;
121 }
122
123 case CTDB_CONTROL_STATISTICS: {
124 CHECK_CONTROL_DATA_SIZE(0);
125 ctdb->statistics.memory_used = talloc_total_size(NULL);
126 ctdb->statistics.num_clients = ctdb->num_clients;
127 ctdb->statistics.frozen = (ctdb_db_all_frozen(ctdb) ? 1 : 0);
128 ctdb->statistics.recovering = (ctdb->recovery_mode == CTDB_RECOVERY_ACTIVE);
129 ctdb->statistics.statistics_current_time = timeval_current();
130
131 outdata->dptr = (uint8_t *)&ctdb->statistics;
132 outdata->dsize = sizeof(ctdb->statistics);
133 return 0;
134 }
135
136 case CTDB_CONTROL_GET_ALL_TUNABLES: {
137 CHECK_CONTROL_DATA_SIZE(0);
138 outdata->dptr = (uint8_t *)&ctdb->tunable;
139 outdata->dsize = sizeof(ctdb->tunable);
140 return 0;
141 }
142
143 case CTDB_CONTROL_DUMP_MEMORY: {
144 CHECK_CONTROL_DATA_SIZE(0);
145 return ctdb_dump_memory(ctdb, outdata);
146 }
147
148 case CTDB_CONTROL_STATISTICS_RESET: {
149 struct ctdb_db_context *ctdb_db;
150
151 CHECK_CONTROL_DATA_SIZE(0);
152 ZERO_STRUCT(ctdb->statistics);
153 for (ctdb_db = ctdb->db_list;
154 ctdb_db != NULL;
155 ctdb_db = ctdb_db->next) {
156 ctdb_db_statistics_reset(ctdb_db);
157 }
158 ctdb->statistics.statistics_start_time = timeval_current();
159 return 0;
160 }
161
162 case CTDB_CONTROL_GETVNNMAP:
163 return ctdb_control_getvnnmap(ctdb, opcode, indata, outdata);
164
165 case CTDB_CONTROL_GET_DBMAP:
166 return ctdb_control_getdbmap(ctdb, opcode, indata, outdata);
167
168 case CTDB_CONTROL_GET_NODEMAPv4:
169 return control_not_implemented("GET_NODEMAPv4", "GET_NODEMAP");
170
171 case CTDB_CONTROL_GET_NODEMAP:
172 return ctdb_control_getnodemap(ctdb, opcode, indata, outdata);
173
174 case CTDB_CONTROL_GET_NODES_FILE:
175 return ctdb_control_getnodesfile(ctdb, opcode, indata, outdata);
176
177 case CTDB_CONTROL_RELOAD_NODES_FILE:
178 CHECK_CONTROL_DATA_SIZE(0);
179 return ctdb_control_reload_nodes_file(ctdb, opcode);
180
181 case CTDB_CONTROL_SET_DB_STICKY: {
182 uint32_t db_id;
183 struct ctdb_db_context *ctdb_db;
184
185 CHECK_CONTROL_DATA_SIZE(sizeof(db_id));
186 db_id = *(uint32_t *)indata.dptr;
187 ctdb_db = find_ctdb_db(ctdb, db_id);
188 if (ctdb_db == NULL) return -1;
189 return ctdb_set_db_sticky(ctdb, ctdb_db);
190 }
191
192 case CTDB_CONTROL_SETVNNMAP:
193 return ctdb_control_setvnnmap(ctdb, opcode, indata, outdata);
194
195 case CTDB_CONTROL_PULL_DB:
196 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_pulldb));
197 return ctdb_control_pull_db(ctdb, indata, outdata);
198
199 case CTDB_CONTROL_SET_DMASTER:
200 return control_not_implemented("SET_DMASTER", NULL);
201
202 case CTDB_CONTROL_PUSH_DB:
203 return ctdb_control_push_db(ctdb, indata);
204
205 case CTDB_CONTROL_GET_RECMODE: {
206 return ctdb->recovery_mode;
207 }
208
209 case CTDB_CONTROL_SET_RECMASTER: {
210 return ctdb_control_set_recmaster(ctdb, opcode, indata);
211 }
212
213 case CTDB_CONTROL_GET_RECMASTER:
214 return ctdb->recovery_master;
215
216 case CTDB_CONTROL_GET_PID:
217 return getpid();
218
219 case CTDB_CONTROL_GET_PNN:
220 return ctdb->pnn;
221
222 case CTDB_CONTROL_PING:
223 CHECK_CONTROL_DATA_SIZE(0);
224 return ctdb->num_clients;
225
226 case CTDB_CONTROL_GET_RUNSTATE:
227 CHECK_CONTROL_DATA_SIZE(0);
228 outdata->dptr = (uint8_t *)&ctdb->runstate;
229 outdata->dsize = sizeof(uint32_t);
230 return 0;
231
232
233 case CTDB_CONTROL_SET_DB_READONLY: {
234 uint32_t db_id;
235 struct ctdb_db_context *ctdb_db;
236
237 CHECK_CONTROL_DATA_SIZE(sizeof(db_id));
238 db_id = *(uint32_t *)indata.dptr;
239 ctdb_db = find_ctdb_db(ctdb, db_id);
240 if (ctdb_db == NULL) return -1;
241 return ctdb_set_db_readonly(ctdb, ctdb_db);
242 }
243 case CTDB_CONTROL_GET_DBNAME: {
244 uint32_t db_id;
245 struct ctdb_db_context *ctdb_db;
246
247 CHECK_CONTROL_DATA_SIZE(sizeof(db_id));
248 db_id = *(uint32_t *)indata.dptr;
249 ctdb_db = find_ctdb_db(ctdb, db_id);
250 if (ctdb_db == NULL) return -1;
251 outdata->dptr = discard_const(ctdb_db->db_name);
252 outdata->dsize = strlen(ctdb_db->db_name)+1;
253 return 0;
254 }
255
256 case CTDB_CONTROL_GETDBPATH: {
257 uint32_t db_id;
258 struct ctdb_db_context *ctdb_db;
259
260 CHECK_CONTROL_DATA_SIZE(sizeof(db_id));
261 db_id = *(uint32_t *)indata.dptr;
262 ctdb_db = find_ctdb_db(ctdb, db_id);
263 if (ctdb_db == NULL) return -1;
264 outdata->dptr = discard_const(ctdb_db->db_path);
265 outdata->dsize = strlen(ctdb_db->db_path)+1;
266 return 0;
267 }
268
269 case CTDB_CONTROL_DB_ATTACH:
270 return ctdb_control_db_attach(ctdb,
271 indata,
272 outdata,
273 0,
274 srcnode,
275 client_id,
276 c,
277 async_reply);
278
279 case CTDB_CONTROL_DB_ATTACH_PERSISTENT:
280 return ctdb_control_db_attach(ctdb,
281 indata,
282 outdata,
283 CTDB_DB_FLAGS_PERSISTENT,
284 srcnode,
285 client_id,
286 c,
287 async_reply);
288
289 case CTDB_CONTROL_DB_ATTACH_REPLICATED:
290 return ctdb_control_db_attach(ctdb,
291 indata,
292 outdata,
293 CTDB_DB_FLAGS_REPLICATED,
294 srcnode,
295 client_id,
296 c,
297 async_reply);
298
299 case CTDB_CONTROL_SET_CALL:
300 return control_not_implemented("SET_CALL", NULL);
301
302 case CTDB_CONTROL_TRAVERSE_START:
303 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_traverse_start));
304 return ctdb_control_traverse_start(ctdb, indata, outdata, srcnode, client_id);
305
306 case CTDB_CONTROL_TRAVERSE_START_EXT:
307 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_traverse_start_ext));
308 return ctdb_control_traverse_start_ext(ctdb, indata, outdata, srcnode, client_id);
309
310 case CTDB_CONTROL_TRAVERSE_ALL:
311 return ctdb_control_traverse_all(ctdb, indata, outdata);
312
313 case CTDB_CONTROL_TRAVERSE_ALL_EXT:
314 return ctdb_control_traverse_all_ext(ctdb, indata, outdata);
315
316 case CTDB_CONTROL_TRAVERSE_DATA:
317 return ctdb_control_traverse_data(ctdb, indata, outdata);
318
319 case CTDB_CONTROL_TRAVERSE_KILL:
320 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_traverse_start));
321 return ctdb_control_traverse_kill(ctdb, indata, outdata, srcnode);
322
323 case CTDB_CONTROL_REGISTER_SRVID:
324 return daemon_register_message_handler(ctdb, client_id, srvid);
325
326 case CTDB_CONTROL_DEREGISTER_SRVID:
327 return daemon_deregister_message_handler(ctdb, client_id, srvid);
328
329 case CTDB_CONTROL_CHECK_SRVIDS:
330 return control_not_implemented("CHECK_SRVIDS", NULL);
331
332 case CTDB_CONTROL_ENABLE_SEQNUM:
333 CHECK_CONTROL_DATA_SIZE(sizeof(uint32_t));
334 return ctdb_ltdb_enable_seqnum(ctdb, *(uint32_t *)indata.dptr);
335
336 case CTDB_CONTROL_UPDATE_SEQNUM:
337 CHECK_CONTROL_DATA_SIZE(sizeof(uint32_t));
338 return ctdb_ltdb_update_seqnum(ctdb, *(uint32_t *)indata.dptr, srcnode);
339
340 case CTDB_CONTROL_FREEZE:
341 CHECK_CONTROL_DATA_SIZE(0);
342 return ctdb_control_freeze(ctdb, c, async_reply);
343
344 case CTDB_CONTROL_THAW:
345 return control_not_implemented("THAW", NULL);
346
347 case CTDB_CONTROL_SET_RECMODE:
348 CHECK_CONTROL_DATA_SIZE(sizeof(uint32_t));
349 return ctdb_control_set_recmode(ctdb, c, indata, async_reply, errormsg);
350
351 case CTDB_CONTROL_GET_MONMODE:
352 return control_not_implemented("GET_MONMODE", NULL);
353
354 case CTDB_CONTROL_ENABLE_MONITOR:
355 return control_not_implemented("ENABLE_MONITOR", NULL);
356
357 case CTDB_CONTROL_RUN_EVENTSCRIPTS:
358 return control_not_implemented("RUN_EVENTSCRIPTS", NULL);
359
360 case CTDB_CONTROL_DISABLE_MONITOR:
361 return control_not_implemented("DISABLE_MONITOR", NULL);
362
363 case CTDB_CONTROL_SHUTDOWN:
364 DEBUG(DEBUG_NOTICE,("Received SHUTDOWN command.\n"));
365 ctdb_shutdown_sequence(ctdb, 0);
366 /* In case above returns due to duplicate shutdown */
367 return 0;
368
369 case CTDB_CONTROL_TAKEOVER_IPv4:
370 return control_not_implemented("TAKEOVER_IPv4", "TAKEOVER_IP");
371
372 case CTDB_CONTROL_TAKEOVER_IP:
373 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_public_ip));
374 return ctdb_control_takeover_ip(ctdb, c, indata, async_reply);
375
376 case CTDB_CONTROL_RELEASE_IPv4:
377 return control_not_implemented("RELEASE_IPv4", "RELEASE_IP");
378
379 case CTDB_CONTROL_RELEASE_IP:
380 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_public_ip));
381 return ctdb_control_release_ip(ctdb, c, indata, async_reply);
382
383 case CTDB_CONTROL_IPREALLOCATED:
384 CHECK_CONTROL_DATA_SIZE(0);
385 return ctdb_control_ipreallocated(ctdb, c, async_reply);
386
387 case CTDB_CONTROL_GET_PUBLIC_IPSv4:
388 return control_not_implemented("GET_PUBLIC_IPSv4",
389 "GET_PUBLIC_IPS");
390
391 case CTDB_CONTROL_GET_PUBLIC_IPS:
392 CHECK_CONTROL_DATA_SIZE(0);
393 return ctdb_control_get_public_ips(ctdb, c, outdata);
394
395 case CTDB_CONTROL_TCP_CLIENT:
396 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_connection));
397 return ctdb_control_tcp_client(ctdb, client_id, indata);
398
399 case CTDB_CONTROL_STARTUP:
400 CHECK_CONTROL_DATA_SIZE(0);
401 return ctdb_control_startup(ctdb, srcnode);
402
403 case CTDB_CONTROL_TCP_ADD:
404 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_connection));
405 return ctdb_control_tcp_add(ctdb, indata, false);
406
407 case CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE:
408 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_connection));
409 return ctdb_control_tcp_add(ctdb, indata, true);
410
411 case CTDB_CONTROL_TCP_REMOVE:
412 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_connection));
413 return ctdb_control_tcp_remove(ctdb, indata);
414
415 case CTDB_CONTROL_SET_TUNABLE:
416 return ctdb_control_set_tunable(ctdb, indata);
417
418 case CTDB_CONTROL_GET_TUNABLE:
419 return ctdb_control_get_tunable(ctdb, indata, outdata);
420
421 case CTDB_CONTROL_LIST_TUNABLES:
422 return ctdb_control_list_tunables(ctdb, outdata);
423
424 case CTDB_CONTROL_MODIFY_FLAGS:
425 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_node_flag_change));
426 return ctdb_control_modflags(ctdb, indata);
427
428 case CTDB_CONTROL_KILL_TCP:
429 return control_not_implemented("KILL_TCP", NULL);
430
431 case CTDB_CONTROL_GET_TCP_TICKLE_LIST:
432 CHECK_CONTROL_DATA_SIZE(sizeof(ctdb_sock_addr));
433 return ctdb_control_get_tcp_tickle_list(ctdb, indata, outdata);
434
435 case CTDB_CONTROL_SET_TCP_TICKLE_LIST:
436 /* data size is verified in the called function */
437 return ctdb_control_set_tcp_tickle_list(ctdb, indata);
438
439 case CTDB_CONTROL_REGISTER_SERVER_ID:
440 return control_not_implemented("REGISTER_SERVER_ID", NULL);
441
442 case CTDB_CONTROL_UNREGISTER_SERVER_ID:
443 return control_not_implemented("UNREGISTER_SERVER_ID", NULL);
444
445 case CTDB_CONTROL_CHECK_SERVER_ID:
446 return control_not_implemented("CHECK_SERVER_ID", NULL);
447
448 case CTDB_CONTROL_GET_SERVER_ID_LIST:
449 return control_not_implemented("SERVER_ID_LIST", NULL);
450
451 case CTDB_CONTROL_PERSISTENT_STORE:
452 return control_not_implemented("PERSISTENT_STORE", NULL);
453
454 case CTDB_CONTROL_UPDATE_RECORD:
455 return ctdb_control_update_record(ctdb, c, indata, async_reply);
456
457 case CTDB_CONTROL_SEND_GRATUITOUS_ARP:
458 return ctdb_control_send_gratious_arp(ctdb, indata);
459
460 case CTDB_CONTROL_TRANSACTION_START:
461 return control_not_implemented("TRANSACTION_START", NULL);
462
463 case CTDB_CONTROL_TRANSACTION_COMMIT:
464 return control_not_implemented("TRANSACTION_COMMIT", NULL);
465
466 case CTDB_CONTROL_WIPE_DATABASE:
467 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_transdb));
468 return ctdb_control_wipe_database(ctdb, indata);
469
470 case CTDB_CONTROL_UPTIME:
471 return ctdb_control_uptime(ctdb, outdata);
472
473 case CTDB_CONTROL_START_RECOVERY:
474 return ctdb_control_start_recovery(ctdb, c, async_reply);
475
476 case CTDB_CONTROL_END_RECOVERY:
477 return ctdb_control_end_recovery(ctdb, c, async_reply);
478
479 case CTDB_CONTROL_TRY_DELETE_RECORDS:
480 return ctdb_control_try_delete_records(ctdb, indata, outdata);
481
482 case CTDB_CONTROL_ADD_PUBLIC_IP:
483 return ctdb_control_add_public_address(ctdb, indata);
484
485 case CTDB_CONTROL_DEL_PUBLIC_IP:
486 return ctdb_control_del_public_address(ctdb, indata);
487
488 case CTDB_CONTROL_GET_CAPABILITIES:
489 return ctdb_control_get_capabilities(ctdb, outdata);
490
491 case CTDB_CONTROL_START_PERSISTENT_UPDATE:
492 return ctdb_control_start_persistent_update(ctdb, c, indata);
493
494 case CTDB_CONTROL_CANCEL_PERSISTENT_UPDATE:
495 return ctdb_control_cancel_persistent_update(ctdb, c, indata);
496
497 case CTDB_CONTROL_TRANS2_COMMIT:
498 case CTDB_CONTROL_TRANS2_COMMIT_RETRY:
499 return control_not_implemented("TRANS2_COMMIT", "TRANS3_COMMIT");
500
501 case CTDB_CONTROL_TRANS2_ERROR:
502 return control_not_implemented("TRANS2_ERROR", NULL);
503
504 case CTDB_CONTROL_TRANS2_FINISHED:
505 return control_not_implemented("TRANS2_FINISHED", NULL);
506
507 case CTDB_CONTROL_TRANS2_ACTIVE:
508 return control_not_implemented("TRANS2_ACTIVE", NULL);
509
510 case CTDB_CONTROL_TRANS3_COMMIT:
511 return ctdb_control_trans3_commit(ctdb, c, indata, async_reply);
512
513 case CTDB_CONTROL_RECD_PING:
514 CHECK_CONTROL_DATA_SIZE(0);
515 return ctdb_control_recd_ping(ctdb);
516
517 case CTDB_CONTROL_GET_EVENT_SCRIPT_STATUS:
518 return control_not_implemented("GET_EVENT_SCRIPT_STATUS", NULL);
519
520 case CTDB_CONTROL_RECD_RECLOCK_LATENCY:
521 CHECK_CONTROL_DATA_SIZE(sizeof(double));
522 CTDB_UPDATE_RECLOCK_LATENCY(ctdb, "recd reclock", reclock.recd, *((double *)indata.dptr));
523 return 0;
524 case CTDB_CONTROL_GET_RECLOCK_FILE:
525 CHECK_CONTROL_DATA_SIZE(0);
526 if (ctdb->recovery_lock != NULL) {
527 outdata->dptr = discard_const(ctdb->recovery_lock);
528 outdata->dsize = strlen(ctdb->recovery_lock) + 1;
529 }
530 return 0;
531 case CTDB_CONTROL_SET_RECLOCK_FILE:
532 return control_not_implemented("SET_RECLOCK", NULL);
533
534 case CTDB_CONTROL_STOP_NODE:
535 CHECK_CONTROL_DATA_SIZE(0);
536 return ctdb_control_stop_node(ctdb);
537
538 case CTDB_CONTROL_CONTINUE_NODE:
539 CHECK_CONTROL_DATA_SIZE(0);
540 return ctdb_control_continue_node(ctdb);
541
542 case CTDB_CONTROL_SET_NATGWSTATE:
543 return control_not_implemented("SET_NATGWSTATE", NULL);
544
545 case CTDB_CONTROL_SET_LMASTERROLE: {
546 uint32_t lmasterrole;
547
548 CHECK_CONTROL_DATA_SIZE(sizeof(uint32_t));
549 lmasterrole = *(uint32_t *)indata.dptr;
550 if (lmasterrole == 0) {
551 ctdb->capabilities &= ~CTDB_CAP_LMASTER;
552 } else {
553 ctdb->capabilities |= CTDB_CAP_LMASTER;
554 }
555 return 0;
556 }
557
558 case CTDB_CONTROL_SET_RECMASTERROLE: {
559 uint32_t recmasterrole;
560
561 CHECK_CONTROL_DATA_SIZE(sizeof(uint32_t));
562 recmasterrole = *(uint32_t *)indata.dptr;
563 if (recmasterrole == 0) {
564 ctdb->capabilities &= ~CTDB_CAP_RECMASTER;
565 } else {
566 ctdb->capabilities |= CTDB_CAP_RECMASTER;
567 }
568 return 0;
569 }
570
571 case CTDB_CONTROL_ENABLE_SCRIPT:
572 return control_not_implemented("ENABLE_SCRIPT", NULL);
573
574 case CTDB_CONTROL_DISABLE_SCRIPT:
575 return control_not_implemented("DISABLE_SCRIPT", NULL);
576
577 case CTDB_CONTROL_SET_BAN_STATE:
578 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_ban_state));
579 return ctdb_control_set_ban_state(ctdb, indata);
580
581 case CTDB_CONTROL_GET_BAN_STATE:
582 CHECK_CONTROL_DATA_SIZE(0);
583 return ctdb_control_get_ban_state(ctdb, outdata);
584
585 case CTDB_CONTROL_SET_DB_PRIORITY:
586 return control_not_implemented("SET_DB_PRIORITY", NULL);
587
588 case CTDB_CONTROL_GET_DB_PRIORITY:
589 return control_not_implemented("GET_DB_PRIORITY", NULL);
590
591 case CTDB_CONTROL_TRANSACTION_CANCEL:
592 return control_not_implemented("TRANSACTION_CANCEL", NULL);
593
594 case CTDB_CONTROL_REGISTER_NOTIFY:
595 return ctdb_control_register_notify(ctdb, client_id, indata);
596
597 case CTDB_CONTROL_DEREGISTER_NOTIFY:
598 CHECK_CONTROL_DATA_SIZE(sizeof(uint64_t));
599 return ctdb_control_deregister_notify(ctdb, client_id, indata);
600
601 case CTDB_CONTROL_GET_LOG:
602 return control_not_implemented("GET_LOG", NULL);
603
604 case CTDB_CONTROL_CLEAR_LOG:
605 return control_not_implemented("CLEAR_LOG", NULL);
606
607 case CTDB_CONTROL_GET_DB_SEQNUM:
608 CHECK_CONTROL_DATA_SIZE(sizeof(uint64_t));
609 return ctdb_control_get_db_seqnum(ctdb, indata, outdata);
610
611 case CTDB_CONTROL_DB_SET_HEALTHY:
612 CHECK_CONTROL_DATA_SIZE(sizeof(uint32_t));
613 return ctdb_control_db_set_healthy(ctdb, indata);
614
615 case CTDB_CONTROL_DB_GET_HEALTH:
616 CHECK_CONTROL_DATA_SIZE(sizeof(uint32_t));
617 return ctdb_control_db_get_health(ctdb, indata, outdata);
618
619 case CTDB_CONTROL_GET_PUBLIC_IP_INFO:
620 CHECK_CONTROL_DATA_SIZE(sizeof(ctdb_sock_addr));
621 return ctdb_control_get_public_ip_info(ctdb, c, indata, outdata);
622
623 case CTDB_CONTROL_GET_IFACES:
624 CHECK_CONTROL_DATA_SIZE(0);
625 return ctdb_control_get_ifaces(ctdb, c, outdata);
626
627 case CTDB_CONTROL_SET_IFACE_LINK_STATE:
628 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_iface));
629 return ctdb_control_set_iface_link(ctdb, c, indata);
630
631 case CTDB_CONTROL_GET_STAT_HISTORY:
632 CHECK_CONTROL_DATA_SIZE(0);
633 return ctdb_control_get_stat_history(ctdb, c, outdata);
634
635 case CTDB_CONTROL_SCHEDULE_FOR_DELETION: {
636 struct ctdb_control_schedule_for_deletion *d;
637 size_t size = offsetof(struct ctdb_control_schedule_for_deletion, key);
638 CHECK_CONTROL_MIN_DATA_SIZE(size);
639 d = (struct ctdb_control_schedule_for_deletion *)indata.dptr;
640 size += d->keylen;
641 CHECK_CONTROL_DATA_SIZE(size);
642 return ctdb_control_schedule_for_deletion(ctdb, indata);
643 }
644 case CTDB_CONTROL_GET_DB_STATISTICS:
645 CHECK_CONTROL_DATA_SIZE(sizeof(uint32_t));
646 return ctdb_control_get_db_statistics(ctdb, *(uint32_t *)indata.dptr, outdata);
647
648 case CTDB_CONTROL_RELOAD_PUBLIC_IPS:
649 CHECK_CONTROL_DATA_SIZE(0);
650 return ctdb_control_reload_public_ips(ctdb, c, async_reply);
651
652 case CTDB_CONTROL_RECEIVE_RECORDS:
653 return control_not_implemented("RECEIVE_RECORDS", NULL);
654
655 case CTDB_CONTROL_DB_DETACH:
656 return ctdb_control_db_detach(ctdb, indata, client_id);
657
658 case CTDB_CONTROL_DB_FREEZE:
659 CHECK_CONTROL_DATA_SIZE(sizeof(uint32_t));
660 return ctdb_control_db_freeze(ctdb, c, *(uint32_t *)indata.dptr,
661 async_reply);
662
663 case CTDB_CONTROL_DB_THAW:
664 CHECK_CONTROL_DATA_SIZE(sizeof(uint32_t));
665 return ctdb_control_db_thaw(ctdb, *(uint32_t *)indata.dptr);
666
667 case CTDB_CONTROL_DB_TRANSACTION_START:
668 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_transdb));
669 return ctdb_control_db_transaction_start(ctdb, indata);
670
671 case CTDB_CONTROL_DB_TRANSACTION_COMMIT:
672 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_transdb));
673 return ctdb_control_db_transaction_commit(ctdb, indata);
674
675 case CTDB_CONTROL_DB_TRANSACTION_CANCEL:
676 CHECK_CONTROL_DATA_SIZE(sizeof(uint32_t));
677 return ctdb_control_db_transaction_cancel(ctdb, indata);
678
679 case CTDB_CONTROL_DB_PULL:
680 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_pulldb_ext));
681 return ctdb_control_db_pull(ctdb, c, indata, outdata);
682
683 case CTDB_CONTROL_DB_PUSH_START:
684 CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_pulldb_ext));
685 return ctdb_control_db_push_start(ctdb, indata);
686
687 case CTDB_CONTROL_DB_PUSH_CONFIRM:
688 CHECK_CONTROL_DATA_SIZE(sizeof(uint32_t));
689 return ctdb_control_db_push_confirm(ctdb, indata, outdata);
690
691 case CTDB_CONTROL_DB_OPEN_FLAGS: {
692 uint32_t db_id;
693 struct ctdb_db_context *ctdb_db;
694 int tdb_flags;
695
696 CHECK_CONTROL_DATA_SIZE(sizeof(db_id));
697 db_id = *(uint32_t *)indata.dptr;
698 ctdb_db = find_ctdb_db(ctdb, db_id);
699 if (ctdb_db == NULL) {
700 return -1;
701 }
702
703 tdb_flags = tdb_get_flags(ctdb_db->ltdb->tdb);
704
705 outdata->dptr = talloc_size(outdata, sizeof(tdb_flags));
706 if (outdata->dptr == NULL) {
707 return -1;
708 }
709
710 outdata->dsize = sizeof(tdb_flags);
711 memcpy(outdata->dptr, &tdb_flags, outdata->dsize);
712 return 0;
713 }
714
715 case CTDB_CONTROL_CHECK_PID_SRVID:
716 CHECK_CONTROL_DATA_SIZE((sizeof(pid_t) + sizeof(uint64_t)));
717 return ctdb_control_check_pid_srvid(ctdb, indata);
718
719 case CTDB_CONTROL_TUNNEL_REGISTER:
720 return ctdb_control_tunnel_register(ctdb, client_id, srvid);
721
722 case CTDB_CONTROL_TUNNEL_DEREGISTER:
723 return ctdb_control_tunnel_deregister(ctdb, client_id, srvid);
724
725 default:
726 DEBUG(DEBUG_CRIT,(__location__ " Unknown CTDB control opcode %u\n", opcode));
727 return -1;
728 }
729 }
730
731 /*
732 send a reply for a ctdb control
733 */
734 void ctdb_request_control_reply(struct ctdb_context *ctdb, struct ctdb_req_control_old *c,
735 TDB_DATA *outdata, int32_t status, const char *errormsg)
736 {
737 struct ctdb_reply_control_old *r;
738 size_t len;
739
740 /* some controls send no reply */
741 if (c->flags & CTDB_CTRL_FLAG_NOREPLY) {
742 return;
743 }
744
745 len = offsetof(struct ctdb_reply_control_old, data) + (outdata?outdata->dsize:0);
746 if (errormsg) {
747 len += strlen(errormsg);
748 }
749 r = ctdb_transport_allocate(ctdb, ctdb, CTDB_REPLY_CONTROL, len, struct ctdb_reply_control_old);
750 if (r == NULL) {
751 DEBUG(DEBUG_ERR,(__location__ "Unable to allocate transport - OOM or transport is down\n"));
752 return;
753 }
754
755 r->hdr.destnode = c->hdr.srcnode;
756 r->hdr.reqid = c->hdr.reqid;
757 r->status = status;
758 r->datalen = outdata?outdata->dsize:0;
759 if (outdata && outdata->dsize) {
760 memcpy(&r->data[0], outdata->dptr, outdata->dsize);
761 }
762 if (errormsg) {
763 r->errorlen = strlen(errormsg);
764 memcpy(&r->data[r->datalen], errormsg, r->errorlen);
765 }
766
767 ctdb_queue_packet_opcode(ctdb, &r->hdr, c->opcode);
768
769 talloc_free(r);
770 }
771
772 /*
773 called when a CTDB_REQ_CONTROL packet comes in
774 */
775 void ctdb_request_control(struct ctdb_context *ctdb, struct ctdb_req_header *hdr)
776 {
777 struct ctdb_req_control_old *c = (struct ctdb_req_control_old *)hdr;
778 TDB_DATA data, *outdata;
779 int32_t status;
780 bool async_reply = false;
781 const char *errormsg = NULL;
782
783 data.dptr = &c->data[0];
784 data.dsize = c->datalen;
785
786 outdata = talloc_zero(c, TDB_DATA);
787
788 status = ctdb_control_dispatch(ctdb, c, data, outdata, hdr->srcnode,
789 &errormsg, &async_reply);
790
791 if (!async_reply) {
792 ctdb_request_control_reply(ctdb, c, outdata, status, errormsg);
793 }
794 }
795
796 /*
797 called when a CTDB_REPLY_CONTROL packet comes in
798 */
799 void ctdb_reply_control(struct ctdb_context *ctdb, struct ctdb_req_header *hdr)
800 {
801 struct ctdb_reply_control_old *c = (struct ctdb_reply_control_old *)hdr;
802 TDB_DATA data;
803 struct ctdb_control_state *state;
804 const char *errormsg = NULL;
805
806 state = reqid_find(ctdb->idr, hdr->reqid, struct ctdb_control_state);
807 if (state == NULL) {
808 DEBUG(DEBUG_ERR,("pnn %u Invalid reqid %u in ctdb_reply_control\n",
809 ctdb->pnn, hdr->reqid));
810 return;
811 }
812
813 if (hdr->reqid != state->reqid) {
814 /* we found a record but it was the wrong one */
815 DEBUG(DEBUG_ERR, ("Dropped orphaned control reply with reqid:%u\n", hdr->reqid));
816 return;
817 }
818
819 data.dptr = &c->data[0];
820 data.dsize = c->datalen;
821 if (c->errorlen) {
822 errormsg = talloc_strndup(state,
823 (char *)&c->data[c->datalen], c->errorlen);
824 }
825
826 /* make state a child of the packet, so it goes away when the packet
827 is freed. */
828 talloc_steal(hdr, state);
829
830 state->callback(ctdb, c->status, data, errormsg, state->private_data);
831 }
832
833 static int ctdb_control_destructor(struct ctdb_control_state *state)
834 {
835 reqid_remove(state->ctdb->idr, state->reqid);
836 return 0;
837 }
838
839 /*
840 handle a timeout of a control
841 */
842 static void ctdb_control_timeout(struct tevent_context *ev,
843 struct tevent_timer *te,
844 struct timeval t, void *private_data)
845 {
846 struct ctdb_control_state *state = talloc_get_type(private_data, struct ctdb_control_state);
847 TALLOC_CTX *tmp_ctx = talloc_new(ev);
848
849 CTDB_INCREMENT_STAT(state->ctdb, timeouts.control);
850
851 talloc_steal(tmp_ctx, state);
852
853 state->callback(state->ctdb, -1, tdb_null,
854 "ctdb_control timed out",
855 state->private_data);
856 talloc_free(tmp_ctx);
857 }
858
859
860 /*
861 send a control message to a node
862 */
863 int ctdb_daemon_send_control(struct ctdb_context *ctdb, uint32_t destnode,
864 uint64_t srvid, uint32_t opcode, uint32_t client_id,
865 uint32_t flags,
866 TDB_DATA data,
867 ctdb_control_callback_fn_t callback,
868 void *private_data)
869 {
870 struct ctdb_req_control_old *c;
871 struct ctdb_control_state *state;
872 size_t len;
873
874 if (ctdb->methods == NULL) {
875 DEBUG(DEBUG_INFO,(__location__ " Failed to send control. Transport is DOWN\n"));
876 return -1;
877 }
878
879 if (((destnode == CTDB_BROADCAST_ACTIVE) ||
880 (destnode == CTDB_BROADCAST_ALL) ||
881 (destnode == CTDB_BROADCAST_CONNECTED)) &&
882 !(flags & CTDB_CTRL_FLAG_NOREPLY)) {
883 DEBUG(DEBUG_CRIT,("Attempt to broadcast control without NOREPLY\n"));
884 return -1;
885 }
886
887 if (destnode != CTDB_BROADCAST_ACTIVE &&
888 destnode != CTDB_BROADCAST_ALL &&
889 destnode != CTDB_BROADCAST_CONNECTED &&
890 (!ctdb_validate_pnn(ctdb, destnode) ||
891 (ctdb->nodes[destnode]->flags & NODE_FLAGS_DISCONNECTED))) {
892 if (!(flags & CTDB_CTRL_FLAG_NOREPLY)) {
893 callback(ctdb, -1, tdb_null, "ctdb_control to disconnected node", private_data);
894 }
895 return 0;
896 }
897
898 /* the state is made a child of private_data if possible. This means any reply
899 will be discarded if the private_data goes away */
900 state = talloc(private_data?private_data:ctdb, struct ctdb_control_state);
901 CTDB_NO_MEMORY(ctdb, state);
902
903 state->reqid = reqid_new(ctdb->idr, state);
904 state->callback = callback;
905 state->private_data = private_data;
906 state->ctdb = ctdb;
907 state->flags = flags;
908
909 talloc_set_destructor(state, ctdb_control_destructor);
910
911 len = offsetof(struct ctdb_req_control_old, data) + data.dsize;
912 c = ctdb_transport_allocate(ctdb, state, CTDB_REQ_CONTROL, len,
913 struct ctdb_req_control_old);
914 CTDB_NO_MEMORY(ctdb, c);
915 talloc_set_name_const(c, "ctdb_req_control packet");
916
917 c->hdr.destnode = destnode;
918 c->hdr.reqid = state->reqid;
919 c->opcode = opcode;
920 c->client_id = client_id;
921 c->flags = flags;
922 c->srvid = srvid;
923 c->datalen = data.dsize;
924 if (data.dsize) {
925 memcpy(&c->data[0], data.dptr, data.dsize);
926 }
927
928 ctdb_queue_packet(ctdb, &c->hdr);
929
930 if (flags & CTDB_CTRL_FLAG_NOREPLY) {
931 talloc_free(state);
932 return 0;
933 }
934
935 if (ctdb->tunable.control_timeout) {
936 tevent_add_timer(ctdb->ev, state,
937 timeval_current_ofs(ctdb->tunable.control_timeout, 0),
938 ctdb_control_timeout, state);
939 }
940
941 talloc_free(c);
942 return 0;
943 }
Samba GIT mirror