?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3:idmap_ad: add support for ADS_AUTH_SASL_{STARTTLS,LDAPS}
[Samba.git] / ctdb / client / client_control_sync.c
blob18bd411b64c63c1ec88ebd2610152ea4de1b2fc0
1 /*
2 CTDB client code
3
4 Copyright (C) Amitay Isaacs 2015
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include "replace.h"
21 #include "system/network.h"
22 #include "system/filesys.h"
23
24 #include <talloc.h>
25 #include <tevent.h>
26 #include <tdb.h>
27
28 #include "common/logging.h"
29
30 #include "lib/util/debug.h"
31
32 #include "protocol/protocol.h"
33 #include "protocol/protocol_api.h"
34 #include "client/client_private.h"
35 #include "client/client.h"
36 #include "client/client_sync.h"
37
38 int ctdb_ctrl_process_exists(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
39 struct ctdb_client_context *client,
40 int destnode, struct timeval timeout,
41 pid_t pid, int *status)
42 {
43 struct ctdb_req_control request;
44 struct ctdb_reply_control *reply;
45 int ret;
46
47 ctdb_req_control_process_exists(&request, pid);
48 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
49 &request, &reply);
50 if (ret != 0) {
51 DEBUG(DEBUG_ERR,
52 ("Control PROCESS_EXISTS failed to node %u, ret=%d\n",
53 destnode, ret));
54 return ret;
55 }
56
57 ret = ctdb_reply_control_process_exists(reply, status);
58 if (ret != 0) {
59 DEBUG(DEBUG_ERR,
60 ("Control PROCESS_EXISTS failed, ret=%d\n", ret));
61 return ret;
62 }
63
64 return 0;
65 }
66
67 int ctdb_ctrl_statistics(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
68 struct ctdb_client_context *client,
69 int destnode, struct timeval timeout,
70 struct ctdb_statistics **stats)
71 {
72 struct ctdb_req_control request;
73 struct ctdb_reply_control *reply;
74 int ret;
75
76 ctdb_req_control_statistics(&request);
77 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
78 &request, &reply);
79 if (ret != 0) {
80 DEBUG(DEBUG_ERR,
81 ("Control STATISTICS failed to node %u, ret=%d\n",
82 destnode, ret));
83 return ret;
84 }
85
86 ret = ctdb_reply_control_statistics(reply, mem_ctx, stats);
87 if (ret != 0) {
88 DEBUG(DEBUG_ERR,
89 ("Control STATISTICS failed, ret=%d\n", ret));
90 return ret;
91 }
92
93 return 0;
94 }
95
96 int ctdb_ctrl_ping(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
97 struct ctdb_client_context *client,
98 int destnode, struct timeval timeout,
99 int *num_clients)
100 {
101 struct ctdb_req_control request;
102 struct ctdb_reply_control *reply;
103 int ret;
104
105 ctdb_req_control_ping(&request);
106 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
107 &request, &reply);
108 if (ret != 0) {
109 DEBUG(DEBUG_ERR,
110 ("Control PING failed to node %u, ret=%d\n",
111 destnode, ret));
112 return ret;
113 }
114
115 ret = ctdb_reply_control_ping(reply, num_clients);
116 if (ret != 0) {
117 DEBUG(DEBUG_ERR,
118 ("Control PING failed, ret=%d\n", ret));
119 return ret;
120 }
121
122 return 0;
123 }
124
125 int ctdb_ctrl_getdbpath(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
126 struct ctdb_client_context *client,
127 int destnode, struct timeval timeout,
128 uint32_t db_id,
129 const char **db_path)
130 {
131 struct ctdb_req_control request;
132 struct ctdb_reply_control *reply;
133 int ret;
134
135 ctdb_req_control_getdbpath(&request, db_id);
136 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
137 &request, &reply);
138 if (ret != 0) {
139 DEBUG(DEBUG_ERR,
140 ("Control GETDBPATH failed to node %u, ret=%d\n",
141 destnode, ret));
142 return ret;
143 }
144
145 ret = ctdb_reply_control_getdbpath(reply, mem_ctx, db_path);
146 if (ret != 0) {
147 DEBUG(DEBUG_ERR,
148 ("Control GETDBPATH failed, ret=%d\n", ret));
149 return ret;
150 }
151
152 return 0;
153 }
154
155 int ctdb_ctrl_getvnnmap(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
156 struct ctdb_client_context *client,
157 int destnode, struct timeval timeout,
158 struct ctdb_vnn_map **vnnmap)
159 {
160 struct ctdb_req_control request;
161 struct ctdb_reply_control *reply;
162 int ret;
163
164 ctdb_req_control_getvnnmap(&request);
165 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
166 &request, &reply);
167 if (ret != 0) {
168 DEBUG(DEBUG_ERR,
169 ("Control GETVNNMAP failed to node %u, ret=%d\n",
170 destnode, ret));
171 return ret;
172 }
173
174 ret = ctdb_reply_control_getvnnmap(reply, mem_ctx, vnnmap);
175 if (ret != 0) {
176 DEBUG(DEBUG_ERR,
177 ("Control GETVNNMAP failed, ret=%d\n", ret));
178 return ret;
179 }
180
181 return 0;
182 }
183
184 int ctdb_ctrl_getdebug(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
185 struct ctdb_client_context *client,
186 int destnode, struct timeval timeout,
187 int *loglevel)
188 {
189 struct ctdb_req_control request;
190 struct ctdb_reply_control *reply;
191 int ret;
192
193 ctdb_req_control_get_debug(&request);
194 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
195 &request, &reply);
196 if (ret != 0) {
197 DEBUG(DEBUG_ERR,
198 ("Control GET_DEBUG failed to node %u, ret=%d\n",
199 destnode, ret));
200 return ret;
201 }
202
203 ret = ctdb_reply_control_get_debug(reply, loglevel);
204 if (ret != 0) {
205 DEBUG(DEBUG_ERR,
206 ("Control GET_DEBUG failed, ret=%d\n", ret));
207 return ret;
208 }
209
210 return 0;
211 }
212
213 int ctdb_ctrl_setdebug(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
214 struct ctdb_client_context *client,
215 int destnode, struct timeval timeout,
216 int loglevel)
217 {
218 struct ctdb_req_control request;
219 struct ctdb_reply_control *reply;
220 int ret;
221
222 ctdb_req_control_set_debug(&request, loglevel);
223 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
224 &request, &reply);
225 if (ret != 0) {
226 DEBUG(DEBUG_ERR,
227 ("Control SET_DEBUG failed to node %u, ret=%d\n",
228 destnode, ret));
229 return ret;
230 }
231
232 ret = ctdb_reply_control_set_debug(reply);
233 if (ret != 0) {
234 DEBUG(DEBUG_ERR,
235 ("Control SET_DEBUG failed, ret=%d\n", ret));
236 return ret;
237 }
238
239 return 0;
240 }
241
242 int ctdb_ctrl_get_dbmap(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
243 struct ctdb_client_context *client,
244 int destnode, struct timeval timeout,
245 struct ctdb_dbid_map **dbmap)
246 {
247 struct ctdb_req_control request;
248 struct ctdb_reply_control *reply;
249 int ret;
250
251 ctdb_req_control_get_dbmap(&request);
252 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
253 &request, &reply);
254 if (ret != 0) {
255 DEBUG(DEBUG_ERR,
256 ("Control GET_DBMAP failed to node %u, ret=%d\n",
257 destnode, ret));
258 return ret;
259 }
260
261 ret = ctdb_reply_control_get_dbmap(reply, mem_ctx, dbmap);
262 if (ret != 0) {
263 DEBUG(DEBUG_ERR,
264 ("Control GET_DBMAP failed, ret=%d\n", ret));
265 return ret;
266 }
267
268 return 0;
269 }
270
271 int ctdb_ctrl_get_recmode(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
272 struct ctdb_client_context *client,
273 int destnode, struct timeval timeout,
274 int *recmode)
275 {
276 struct ctdb_req_control request;
277 struct ctdb_reply_control *reply;
278 int ret;
279
280 ctdb_req_control_get_recmode(&request);
281 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
282 &request, &reply);
283 if (ret != 0) {
284 DEBUG(DEBUG_ERR,
285 ("Control GET_RECMODE failed to node %u, ret=%d\n",
286 destnode, ret));
287 return ret;
288 }
289
290 ret = ctdb_reply_control_get_recmode(reply, recmode);
291 if (ret != 0) {
292 DEBUG(DEBUG_ERR,
293 ("Control GET_RECMODE failed, ret=%d\n", ret));
294 return ret;
295 }
296
297 return 0;
298 }
299
300 int ctdb_ctrl_set_recmode(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
301 struct ctdb_client_context *client,
302 int destnode, struct timeval timeout,
303 int recmode)
304 {
305 struct ctdb_req_control request;
306 struct ctdb_reply_control *reply;
307 int ret;
308
309 ctdb_req_control_set_recmode(&request, recmode);
310 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
311 &request, &reply);
312 if (ret != 0) {
313 DEBUG(DEBUG_ERR,
314 ("Control SET_RECMODE failed to node %u, ret=%d\n",
315 destnode, ret));
316 return ret;
317 }
318
319 ret = ctdb_reply_control_set_recmode(reply);
320 if (ret != 0) {
321 DEBUG(DEBUG_ERR,
322 ("Control SET_RECMODE failed, ret=%d\n", ret));
323 return ret;
324 }
325
326 return 0;
327 }
328
329 int ctdb_ctrl_statistics_reset(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
330 struct ctdb_client_context *client,
331 int destnode, struct timeval timeout)
332 {
333 struct ctdb_req_control request;
334 struct ctdb_reply_control *reply;
335 int ret;
336
337 ctdb_req_control_statistics_reset(&request);
338 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
339 &request, &reply);
340 if (ret != 0) {
341 DEBUG(DEBUG_ERR,
342 ("Control STATISTICS_RESET failed to node %u, ret=%d\n",
343 destnode, ret));
344 return ret;
345 }
346
347 ret = ctdb_reply_control_statistics_reset(reply);
348 if (ret != 0) {
349 DEBUG(DEBUG_ERR,
350 ("Control STATISTICS_RESET failed, ret=%d\n", ret));
351 return ret;
352 }
353
354 return 0;
355 }
356
357 int ctdb_ctrl_db_attach(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
358 struct ctdb_client_context *client,
359 int destnode, struct timeval timeout,
360 const char *db_name, uint32_t *db_id)
361 {
362 struct ctdb_req_control request;
363 struct ctdb_reply_control *reply;
364 int ret;
365
366 ctdb_req_control_db_attach(&request, db_name);
367 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
368 &request, &reply);
369 if (ret != 0) {
370 DEBUG(DEBUG_ERR,
371 ("Control DB_ATTACH failed to node %u, ret=%d\n",
372 destnode, ret));
373 return ret;
374 }
375
376 ret = ctdb_reply_control_db_attach(reply, db_id);
377 if (ret != 0) {
378 DEBUG(DEBUG_ERR,
379 ("Control DB_ATTACH failed, ret=%d\n", ret));
380 return ret;
381 }
382
383 return 0;
384 }
385
386 int ctdb_ctrl_traverse_start(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
387 struct ctdb_client_context *client,
388 int destnode, struct timeval timeout,
389 struct ctdb_traverse_start *traverse)
390 {
391 struct ctdb_req_control request;
392 struct ctdb_reply_control *reply;
393 int ret;
394
395 ctdb_req_control_traverse_start(&request, traverse);
396 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
397 &request, &reply);
398 if (ret != 0) {
399 DEBUG(DEBUG_ERR,
400 ("Control TRAVERSE_START failed to node %u, ret=%d\n",
401 destnode, ret));
402 return ret;
403 }
404
405 ret = ctdb_reply_control_traverse_start(reply);
406 if (ret != 0) {
407 DEBUG(DEBUG_ERR,
408 ("Control TRAVERSE_START failed, ret=%d\n", ret));
409 return ret;
410 }
411
412 return 0;
413 }
414
415 int ctdb_ctrl_register_srvid(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
416 struct ctdb_client_context *client,
417 int destnode, struct timeval timeout,
418 uint64_t srvid)
419 {
420 struct ctdb_req_control request;
421 struct ctdb_reply_control *reply;
422 int ret;
423
424 ctdb_req_control_register_srvid(&request, srvid);
425 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
426 &request, &reply);
427 if (ret != 0) {
428 DEBUG(DEBUG_ERR,
429 ("Control REGISTER_SRVID failed to node %u, ret=%d\n",
430 destnode, ret));
431 return ret;
432 }
433
434 ret = ctdb_reply_control_register_srvid(reply);
435 if (ret != 0) {
436 DEBUG(DEBUG_ERR,
437 ("Control REGISTER_SRVID failed, ret=%d\n", ret));
438 return ret;
439 }
440
441 return 0;
442 }
443
444 int ctdb_ctrl_deregister_srvid(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
445 struct ctdb_client_context *client,
446 int destnode, struct timeval timeout,
447 uint64_t srvid)
448 {
449 struct ctdb_req_control request;
450 struct ctdb_reply_control *reply;
451 int ret;
452
453 ctdb_req_control_deregister_srvid(&request, srvid);
454 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
455 &request, &reply);
456 if (ret != 0) {
457 DEBUG(DEBUG_ERR,
458 ("Control DEREGISTER_SRVID failed to node %u, ret=%d\n",
459 destnode, ret));
460 return ret;
461 }
462
463 ret = ctdb_reply_control_deregister_srvid(reply);
464 if (ret != 0) {
465 DEBUG(DEBUG_ERR,
466 ("Control DEREGISTER_SRVID failed, ret=%d\n", ret));
467 return ret;
468 }
469
470 return 0;
471 }
472
473 int ctdb_ctrl_get_dbname(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
474 struct ctdb_client_context *client,
475 int destnode, struct timeval timeout,
476 uint32_t db_id, const char **db_name)
477 {
478 struct ctdb_req_control request;
479 struct ctdb_reply_control *reply;
480 int ret;
481
482 ctdb_req_control_get_dbname(&request, db_id);
483 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
484 &request, &reply);
485 if (ret != 0) {
486 DEBUG(DEBUG_ERR,
487 ("Control GET_DBNAME failed to node %u, ret=%d\n",
488 destnode, ret));
489 return ret;
490 }
491
492 ret = ctdb_reply_control_get_dbname(reply, mem_ctx, db_name);
493 if (ret != 0) {
494 DEBUG(DEBUG_ERR,
495 ("Control GET_DBNAME failed, ret=%d\n", ret));
496 return ret;
497 }
498
499 return 0;
500 }
501
502 int ctdb_ctrl_enable_seqnum(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
503 struct ctdb_client_context *client,
504 int destnode, struct timeval timeout,
505 uint32_t db_id)
506 {
507 struct ctdb_req_control request;
508 struct ctdb_reply_control *reply;
509 int ret;
510
511 ctdb_req_control_enable_seqnum(&request, db_id);
512 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
513 &request, &reply);
514 if (ret != 0) {
515 DEBUG(DEBUG_ERR,
516 ("Control ENABLE_SEQNUM failed to node %u, ret=%d\n",
517 destnode, ret));
518 return ret;
519 }
520
521 ret = ctdb_reply_control_enable_seqnum(reply);
522 if (ret != 0) {
523 DEBUG(DEBUG_ERR,
524 ("Control ENABLE_SEQNUM failed, ret=%d\n", ret));
525 return ret;
526 }
527
528 return 0;
529 }
530
531 int ctdb_ctrl_update_seqnum(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
532 struct ctdb_client_context *client,
533 int destnode, struct timeval timeout,
534 uint32_t db_id)
535 {
536 struct ctdb_req_control request;
537 struct ctdb_reply_control *reply;
538 int ret;
539
540 ctdb_req_control_update_seqnum(&request, db_id);
541 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
542 &request, &reply);
543 if (ret != 0) {
544 DEBUG(DEBUG_ERR,
545 ("Control UPDATE_SEQNUM failed to node %u, ret=%d\n",
546 destnode, ret));
547 return ret;
548 }
549
550 ret = ctdb_reply_control_update_seqnum(reply);
551 if (ret != 0) {
552 DEBUG(DEBUG_ERR,
553 ("Control UPDATE_SEQNUM failed, ret=%d\n", ret));
554 return ret;
555 }
556
557 return 0;
558 }
559
560 int ctdb_ctrl_dump_memory(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
561 struct ctdb_client_context *client,
562 int destnode, struct timeval timeout,
563 const char **mem_str)
564 {
565 struct ctdb_req_control request;
566 struct ctdb_reply_control *reply;
567 int ret;
568
569 ctdb_req_control_dump_memory(&request);
570 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
571 &request, &reply);
572 if (ret != 0) {
573 DEBUG(DEBUG_ERR,
574 ("Control DUMP_MEMORY failed to node %u, ret=%d\n",
575 destnode, ret));
576 return ret;
577 }
578
579 ret = ctdb_reply_control_dump_memory(reply, mem_ctx, mem_str);
580 if (ret != 0) {
581 DEBUG(DEBUG_ERR,
582 ("Control DUMP_MEMORY failed, ret=%d\n", ret));
583 return ret;
584 }
585
586 return 0;
587 }
588
589 int ctdb_ctrl_get_pid(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
590 struct ctdb_client_context *client,
591 int destnode, struct timeval timeout,
592 pid_t *pid)
593 {
594 struct ctdb_req_control request;
595 struct ctdb_reply_control *reply;
596 int ret;
597
598 ctdb_req_control_get_pid(&request);
599 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
600 &request, &reply);
601 if (ret != 0) {
602 DEBUG(DEBUG_ERR,
603 ("Control GET_PID failed to node %u, ret=%d\n",
604 destnode, ret));
605 return ret;
606 }
607
608 ret = ctdb_reply_control_get_pid(reply, pid);
609 if (ret != 0) {
610 DEBUG(DEBUG_ERR,
611 ("Control GET_PID failed, ret=%d\n", ret));
612 return ret;
613 }
614
615 return 0;
616 }
617
618 int ctdb_ctrl_freeze(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
619 struct ctdb_client_context *client,
620 int destnode, struct timeval timeout,
621 int priority)
622 {
623 struct ctdb_req_control request;
624 struct ctdb_reply_control *reply;
625 int ret;
626
627 ctdb_req_control_freeze(&request, priority);
628 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
629 &request, &reply);
630 if (ret != 0) {
631 DEBUG(DEBUG_ERR,
632 ("Control FREEZE failed to node %u, ret=%d\n",
633 destnode, ret));
634 return ret;
635 }
636
637 ret = ctdb_reply_control_freeze(reply);
638 if (ret != 0) {
639 DEBUG(DEBUG_ERR,
640 ("Control FREEZE failed, ret=%d\n", ret));
641 return ret;
642 }
643
644 return 0;
645 }
646
647 int ctdb_ctrl_get_pnn(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
648 struct ctdb_client_context *client,
649 int destnode, struct timeval timeout,
650 uint32_t *pnn)
651 {
652 struct ctdb_req_control request;
653 struct ctdb_reply_control *reply;
654 int ret;
655
656 ctdb_req_control_get_pnn(&request);
657 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
658 &request, &reply);
659 if (ret != 0) {
660 DEBUG(DEBUG_ERR,
661 ("Control GET_PNN failed to node %u, ret=%d\n",
662 destnode, ret));
663 return ret;
664 }
665
666 ret = ctdb_reply_control_get_pnn(reply, pnn);
667 if (ret != 0) {
668 DEBUG(DEBUG_ERR,
669 ("Control GET_PNN failed, ret=%d\n", ret));
670 return ret;
671 }
672
673 return 0;
674 }
675
676 int ctdb_ctrl_shutdown(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
677 struct ctdb_client_context *client,
678 int destnode, struct timeval timeout)
679 {
680 struct ctdb_req_control request;
681 struct ctdb_reply_control *reply;
682 int ret;
683
684 ctdb_req_control_shutdown(&request);
685 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
686 &request, &reply);
687 if (ret != 0) {
688 DEBUG(DEBUG_ERR,
689 ("Control SHUTDOWN failed to node %u, ret=%d\n",
690 destnode, ret));
691 return ret;
692 }
693
694 ret = ctdb_reply_control_shutdown(reply);
695 if (ret != 0) {
696 DEBUG(DEBUG_ERR,
697 ("Control SHUTDOWN failed, ret=%d\n", ret));
698 return ret;
699 }
700
701 return 0;
702 }
703
704 int ctdb_ctrl_tcp_add(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
705 struct ctdb_client_context *client,
706 int destnode, struct timeval timeout,
707 struct ctdb_connection *conn)
708 {
709 struct ctdb_req_control request;
710 struct ctdb_reply_control *reply;
711 int ret;
712
713 ctdb_req_control_tcp_add(&request, conn);
714 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
715 &request, &reply);
716 if (ret != 0) {
717 DEBUG(DEBUG_ERR,
718 ("Control TCP_ADD failed to node %u, ret=%d\n",
719 destnode, ret));
720 return ret;
721 }
722
723 ret = ctdb_reply_control_tcp_add(reply);
724 if (ret != 0) {
725 DEBUG(DEBUG_ERR,
726 ("Control TCP_ADD failed, ret=%d\n", ret));
727 return ret;
728 }
729
730 return 0;
731 }
732
733 int ctdb_ctrl_tcp_remove(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
734 struct ctdb_client_context *client,
735 int destnode, struct timeval timeout,
736 struct ctdb_connection *conn)
737 {
738 struct ctdb_req_control request;
739 struct ctdb_reply_control *reply;
740 int ret;
741
742 ctdb_req_control_tcp_remove(&request, conn);
743 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
744 &request, &reply);
745 if (ret != 0) {
746 DEBUG(DEBUG_ERR,
747 ("Control TCP_REMOVE failed to node %u, ret=%d\n",
748 destnode, ret));
749 return ret;
750 }
751
752 ret = ctdb_reply_control_tcp_remove(reply);
753 if (ret != 0) {
754 DEBUG(DEBUG_ERR,
755 ("Control TCP_REMOVE failed, ret=%d\n", ret));
756 return ret;
757 }
758
759 return 0;
760 }
761
762 int ctdb_ctrl_set_tunable(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
763 struct ctdb_client_context *client,
764 int destnode, struct timeval timeout,
765 struct ctdb_tunable *tunable)
766 {
767 struct ctdb_req_control request;
768 struct ctdb_reply_control *reply;
769 int ret;
770
771 ctdb_req_control_set_tunable(&request, tunable);
772 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
773 &request, &reply);
774 if (ret != 0) {
775 DEBUG(DEBUG_ERR,
776 ("Control SET_TUNABLE failed to node %u, ret=%d\n",
777 destnode, ret));
778 return ret;
779 }
780
781 ret = ctdb_reply_control_set_tunable(reply);
782 if (ret != 0) {
783 DEBUG(DEBUG_ERR,
784 ("Control SET_TUNABLE failed, ret=%d\n", ret));
785 return ret;
786 }
787
788 return 0;
789 }
790
791 int ctdb_ctrl_get_tunable(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
792 struct ctdb_client_context *client,
793 int destnode, struct timeval timeout,
794 const char *var, uint32_t *value)
795 {
796 struct ctdb_req_control request;
797 struct ctdb_reply_control *reply;
798 int ret;
799
800 ctdb_req_control_get_tunable(&request, var);
801 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
802 &request, &reply);
803 if (ret != 0) {
804 DEBUG(DEBUG_ERR,
805 ("Control GET_TUNABLE failed to node %u, ret=%d\n",
806 destnode, ret));
807 return ret;
808 }
809
810 ret = ctdb_reply_control_get_tunable(reply, value);
811 if (ret != 0) {
812 DEBUG(DEBUG_ERR,
813 ("Control GET_TUNABLE failed, ret=%d\n", ret));
814 return ret;
815 }
816
817 return 0;
818 }
819
820 int ctdb_ctrl_list_tunables(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
821 struct ctdb_client_context *client,
822 int destnode, struct timeval timeout,
823 struct ctdb_var_list **var_list)
824 {
825 struct ctdb_req_control request;
826 struct ctdb_reply_control *reply;
827 int ret;
828
829 ctdb_req_control_list_tunables(&request);
830 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
831 &request, &reply);
832 if (ret != 0) {
833 DEBUG(DEBUG_ERR,
834 ("Control LIST_TUNABLES failed to node %u, ret=%d\n",
835 destnode, ret));
836 return ret;
837 }
838
839 ret = ctdb_reply_control_list_tunables(reply, mem_ctx, var_list);
840 if (ret != 0) {
841 DEBUG(DEBUG_ERR,
842 ("Control LIST_TUNABLES failed, ret=%d\n", ret));
843 return ret;
844 }
845
846 return 0;
847 }
848
849 int ctdb_ctrl_modify_flags(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
850 struct ctdb_client_context *client,
851 int destnode, struct timeval timeout,
852 uint32_t pnn, uint32_t old_flags,
853 uint32_t new_flags)
854 {
855 struct ctdb_req_control request;
856 struct ctdb_reply_control *reply;
857 struct ctdb_node_flag_change flag_change;
858 int ret;
859
860 flag_change.pnn = pnn;
861 flag_change.old_flags = old_flags;
862 flag_change.new_flags = new_flags;
863
864 ctdb_req_control_modify_flags(&request, &flag_change);
865 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
866 &request, &reply);
867 if (ret != 0) {
868 DEBUG(DEBUG_ERR,
869 ("Control MODIFY_FLAGS failed to node %u, ret=%d\n",
870 destnode, ret));
871 return ret;
872 }
873
874 ret = ctdb_reply_control_modify_flags(reply);
875 if (ret != 0) {
876 DEBUG(DEBUG_ERR,
877 ("Control MODIFY_FLAGS failed, ret=%d\n", ret));
878 return ret;
879 }
880
881 return 0;
882 }
883
884 int ctdb_ctrl_get_all_tunables(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
885 struct ctdb_client_context *client,
886 int destnode, struct timeval timeout,
887 struct ctdb_tunable_list **tun_list)
888 {
889 struct ctdb_req_control request;
890 struct ctdb_reply_control *reply;
891 int ret;
892
893 ctdb_req_control_get_all_tunables(&request);
894 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
895 &request, &reply);
896 if (ret != 0) {
897 DEBUG(DEBUG_ERR,
898 ("Control GET_ALL_TUNABLES failed to node %u, ret=%d\n",
899 destnode, ret));
900 return ret;
901 }
902
903 ret = ctdb_reply_control_get_all_tunables(reply, mem_ctx, tun_list);
904 if (ret != 0) {
905 DEBUG(DEBUG_ERR,
906 ("Control GET_ALL_TUNABLES failed, ret=%d\n", ret));
907 return ret;
908 }
909
910 return 0;
911 }
912
913 int ctdb_ctrl_get_tcp_tickle_list(TALLOC_CTX *mem_ctx,
914 struct tevent_context *ev,
915 struct ctdb_client_context *client,
916 int destnode, struct timeval timeout,
917 ctdb_sock_addr *addr,
918 struct ctdb_tickle_list **tickles)
919 {
920 struct ctdb_req_control request;
921 struct ctdb_reply_control *reply;
922 int ret;
923
924 ctdb_req_control_get_tcp_tickle_list(&request, addr);
925 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
926 &request, &reply);
927 if (ret != 0) {
928 DEBUG(DEBUG_ERR,
929 ("Control GET_TCP_TICKLE_LIST failed to node %u, ret=%d\n",
930 destnode, ret));
931 return ret;
932 }
933
934 ret = ctdb_reply_control_get_tcp_tickle_list(reply, mem_ctx, tickles);
935 if (ret != 0) {
936 DEBUG(DEBUG_ERR,
937 ("Control GET_TCP_TICKLE_LIST failed, ret=%d\n", ret));
938 return ret;
939 }
940
941 return 0;
942 }
943
944 int ctdb_ctrl_set_tcp_tickle_list(TALLOC_CTX *mem_ctx,
945 struct tevent_context *ev,
946 struct ctdb_client_context *client,
947 int destnode, struct timeval timeout,
948 struct ctdb_tickle_list *tickles)
949 {
950 struct ctdb_req_control request;
951 struct ctdb_reply_control *reply;
952 int ret;
953
954 ctdb_req_control_set_tcp_tickle_list(&request, tickles);
955 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
956 &request, &reply);
957 if (ret != 0) {
958 DEBUG(DEBUG_ERR,
959 ("Control SET_TCP_TICKLE_LIST failed to node %u, ret=%d\n",
960 destnode, ret));
961 return ret;
962 }
963
964 ret = ctdb_reply_control_set_tcp_tickle_list(reply);
965 if (ret != 0) {
966 DEBUG(DEBUG_ERR,
967 ("Control SET_TCP_TICKLE_LIST failed, ret=%d\n", ret));
968 return ret;
969 }
970
971 return 0;
972 }
973
974 int ctdb_ctrl_db_attach_persistent(TALLOC_CTX *mem_ctx,
975 struct tevent_context *ev,
976 struct ctdb_client_context *client,
977 int destnode, struct timeval timeout,
978 const char *db_name, uint32_t *db_id)
979 {
980 struct ctdb_req_control request;
981 struct ctdb_reply_control *reply;
982 int ret;
983
984 ctdb_req_control_db_attach_persistent(&request, db_name);
985 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
986 &request, &reply);
987 if (ret != 0) {
988 DEBUG(DEBUG_ERR,
989 ("Control DB_ATTACH_PERSISTENT failed to node %u, ret=%d\n",
990 destnode, ret));
991 return ret;
992 }
993
994 ret = ctdb_reply_control_db_attach_persistent(reply, db_id);
995 if (ret != 0) {
996 DEBUG(DEBUG_ERR,
997 ("Control DB_ATTACH_PERSISTENT failed, ret=%d\n", ret));
998 return ret;
999 }
1000
1001 return 0;
1002 }
1003
1004 int ctdb_ctrl_send_gratuitous_arp(TALLOC_CTX *mem_ctx,
1005 struct tevent_context *ev,
1006 struct ctdb_client_context *client,
1007 int destnode, struct timeval timeout,
1008 struct ctdb_addr_info *addr_info)
1009 {
1010 struct ctdb_req_control request;
1011 struct ctdb_reply_control *reply;
1012 int ret;
1013
1014 ctdb_req_control_send_gratuitous_arp(&request, addr_info);
1015 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
1016 &request, &reply);
1017 if (ret != 0) {
1018 DEBUG(DEBUG_ERR,
1019 ("Control SEND_GRATUITOUS_ARP failed to node %u, ret=%d\n",
1020 destnode, ret));
1021 return ret;
1022 }
1023
1024 ret = ctdb_reply_control_send_gratuitous_arp(reply);
1025 if (ret != 0) {
1026 DEBUG(DEBUG_ERR,
1027 ("Control SEND_GRATUITOUS_ARP failed, ret=%d\n", ret));
1028 return ret;
1029 }
1030
1031 return 0;
1032 }
1033
1034 int ctdb_ctrl_wipe_database(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
1035 struct ctdb_client_context *client,
1036 int destnode, struct timeval timeout,
1037 uint32_t db_id, uint32_t tid)
1038 {
1039 struct ctdb_req_control request;
1040 struct ctdb_reply_control *reply;
1041 struct ctdb_transdb transdb;
1042 int ret;
1043
1044 transdb.db_id = db_id;
1045 transdb.tid = tid;
1046
1047 ctdb_req_control_wipe_database(&request, &transdb);
1048 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
1049 &request, &reply);
1050 if (ret != 0) {
1051 DEBUG(DEBUG_ERR,
1052 ("Control WIPE_DATABASE failed to node %u, ret=%d\n",
1053 destnode, ret));
1054 return ret;
1055 }
1056
1057 ret = ctdb_reply_control_wipe_database(reply);
1058 if (ret != 0) {
1059 DEBUG(DEBUG_ERR,
1060 ("Control WIPE_DATABASE failed, ret=%d\n", ret));
1061 return ret;
1062 }
1063
1064 return 0;
1065 }
1066
1067 int ctdb_ctrl_uptime(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
1068 struct ctdb_client_context *client,
1069 int destnode, struct timeval timeout,
1070 struct ctdb_uptime **uptime)
1071 {
1072 struct ctdb_req_control request;
1073 struct ctdb_reply_control *reply;
1074 int ret;
1075
1076 ctdb_req_control_uptime(&request);
1077 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
1078 &request, &reply);
1079 if (ret != 0) {
1080 DEBUG(DEBUG_ERR,
1081 ("Control UPTIME failed to node %u, ret=%d\n",
1082 destnode, ret));
1083 return ret;
1084 }
1085
1086 ret = ctdb_reply_control_uptime(reply, mem_ctx, uptime);
1087 if (ret != 0) {
1088 DEBUG(DEBUG_ERR,
1089 ("Control UPTIME failed, ret=%d\n", ret));
1090 return ret;
1091 }
1092
1093 return 0;
1094 }
1095
1096 int ctdb_ctrl_start_recovery(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
1097 struct ctdb_client_context *client,
1098 int destnode, struct timeval timeout)
1099 {
1100 struct ctdb_req_control request;
1101 struct ctdb_reply_control *reply;
1102 int ret;
1103
1104 ctdb_req_control_start_recovery(&request);
1105 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
1106 &request, &reply);
1107 if (ret != 0) {
1108 DEBUG(DEBUG_ERR,
1109 ("Control START_RECOVERY failed to node %u, ret=%d\n",
1110 destnode, ret));
1111 return ret;
1112 }
1113
1114 ret = ctdb_reply_control_start_recovery(reply);
1115 if (ret != 0) {
1116 DEBUG(DEBUG_ERR,
1117 ("Control START_RECOVERY failed, ret=%d\n", ret));
1118 return ret;
1119 }
1120
1121 return 0;
1122 }
1123
1124 int ctdb_ctrl_end_recovery(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
1125 struct ctdb_client_context *client,
1126 int destnode, struct timeval timeout)
1127 {
1128 struct ctdb_req_control request;
1129 struct ctdb_reply_control *reply;
1130 int ret;
1131
1132 ctdb_req_control_end_recovery(&request);
1133 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
1134 &request, &reply);
1135 if (ret != 0) {
1136 DEBUG(DEBUG_ERR,
1137 ("Control END_RECOVERY failed to node %u, ret=%d\n",
1138 destnode, ret));
1139 return ret;
1140 }
1141
1142 ret = ctdb_reply_control_end_recovery(reply);
1143 if (ret != 0) {
1144 DEBUG(DEBUG_ERR,
1145 ("Control END_RECOVERY failed, ret=%d\n", ret));
1146 return ret;
1147 }
1148
1149 return 0;
1150 }
1151
1152 int ctdb_ctrl_reload_nodes_file(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
1153 struct ctdb_client_context *client,
1154 int destnode, struct timeval timeout)
1155 {
1156 struct ctdb_req_control request;
1157 struct ctdb_reply_control *reply;
1158 int ret;
1159
1160 ctdb_req_control_reload_nodes_file(&request);
1161 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
1162 &request, &reply);
1163 if (ret != 0) {
1164 DEBUG(DEBUG_ERR,
1165 ("Control RELOAD_NODES_FILE failed to node %u, ret=%d\n",
1166 destnode, ret));
1167 return ret;
1168 }
1169
1170 ret = ctdb_reply_control_reload_nodes_file(reply);
1171 if (ret != 0) {
1172 DEBUG(DEBUG_ERR,
1173 ("Control RELOAD_NODES_FILE failed, ret=%d\n", ret));
1174 return ret;
1175 }
1176
1177 return 0;
1178 }
1179
1180 int ctdb_ctrl_add_public_ip(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
1181 struct ctdb_client_context *client,
1182 int destnode, struct timeval timeout,
1183 struct ctdb_addr_info *addr_info)
1184 {
1185 struct ctdb_req_control request;
1186 struct ctdb_reply_control *reply;
1187 int ret;
1188
1189 ctdb_req_control_add_public_ip(&request, addr_info);
1190 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
1191 &request, &reply);
1192 if (ret != 0) {
1193 DEBUG(DEBUG_ERR,
1194 ("Control ADD_PUBLIC_IP failed to node %u, ret=%d\n",
1195 destnode, ret));
1196 return ret;
1197 }
1198
1199 ret = ctdb_reply_control_add_public_ip(reply);
1200 if (ret != 0) {
1201 DEBUG(DEBUG_ERR,
1202 ("Control ADD_PUBLIC_IP failed, ret=%d\n", ret));
1203 return ret;
1204 }
1205
1206 return 0;
1207 }
1208
1209 int ctdb_ctrl_del_public_ip(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
1210 struct ctdb_client_context *client,
1211 int destnode, struct timeval timeout,
1212 struct ctdb_addr_info *addr_info)
1213 {
1214 struct ctdb_req_control request;
1215 struct ctdb_reply_control *reply;
1216 int ret;
1217
1218 ctdb_req_control_del_public_ip(&request, addr_info);
1219 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
1220 &request, &reply);
1221 if (ret != 0) {
1222 DEBUG(DEBUG_ERR,
1223 ("Control DEL_PUBLIC_IP failed to node %u, ret=%d\n",
1224 destnode, ret));
1225 return ret;
1226 }
1227
1228 ret = ctdb_reply_control_del_public_ip(reply);
1229 if (ret != 0) {
1230 DEBUG(DEBUG_ERR,
1231 ("Control DEL_PUBLIC_IP failed, ret=%d\n", ret));
1232 return ret;
1233 }
1234
1235 return 0;
1236 }
1237
1238 int ctdb_ctrl_get_capabilities(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
1239 struct ctdb_client_context *client,
1240 int destnode, struct timeval timeout,
1241 uint32_t *caps)
1242 {
1243 struct ctdb_req_control request;
1244 struct ctdb_reply_control *reply;
1245 int ret;
1246
1247 ctdb_req_control_get_capabilities(&request);
1248 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
1249 &request, &reply);
1250 if (ret != 0) {
1251 DEBUG(DEBUG_ERR,
1252 ("Control GET_CAPABILITIES failed to node %u, ret=%d\n",
1253 destnode, ret));
1254 return ret;
1255 }
1256
1257 ret = ctdb_reply_control_get_capabilities(reply, caps);
1258 if (ret != 0) {
1259 DEBUG(DEBUG_ERR,
1260 ("Control GET_CAPABILITIES failed, ret=%d\n", ret));
1261 return ret;
1262 }
1263
1264 return 0;
1265 }
1266
1267 int ctdb_ctrl_release_ip(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
1268 struct ctdb_client_context *client,
1269 int destnode, struct timeval timeout,
1270 struct ctdb_public_ip *pubip)
1271 {
1272 struct ctdb_req_control request;
1273 struct ctdb_reply_control *reply;
1274 int ret;
1275
1276 ctdb_req_control_release_ip(&request, pubip);
1277 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
1278 &request, &reply);
1279 if (ret != 0) {
1280 DEBUG(DEBUG_ERR,
1281 ("Control RELEASE_IP failed to node %u, ret=%d\n",
1282 destnode, ret));
1283 return ret;
1284 }
1285
1286 ret = ctdb_reply_control_release_ip(reply);
1287 if (ret != 0) {
1288 DEBUG(DEBUG_ERR,
1289 ("Control RELEASE_IP failed, ret=%d\n", ret));
1290 return ret;
1291 }
1292
1293 return 0;
1294 }
1295
1296 int ctdb_ctrl_takeover_ip(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
1297 struct ctdb_client_context *client,
1298 int destnode, struct timeval timeout,
1299 struct ctdb_public_ip *pubip)
1300 {
1301 struct ctdb_req_control request;
1302 struct ctdb_reply_control *reply;
1303 int ret;
1304
1305 ctdb_req_control_takeover_ip(&request, pubip);
1306 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
1307 &request, &reply);
1308 if (ret != 0) {
1309 DEBUG(DEBUG_ERR,
1310 ("Control TAKEOVER_IP failed to node %u, ret=%d\n",
1311 destnode, ret));
1312 return ret;
1313 }
1314
1315 ret = ctdb_reply_control_takeover_ip(reply);
1316 if (ret != 0) {
1317 DEBUG(DEBUG_ERR,
1318 ("Control TAKEOVER_IP failed, ret=%d\n", ret));
1319 return ret;
1320 }
1321
1322 return 0;
1323 }
1324
1325 int ctdb_ctrl_get_public_ips(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
1326 struct ctdb_client_context *client,
1327 int destnode, struct timeval timeout,
1328 bool available_only,
1329 struct ctdb_public_ip_list **pubip_list)
1330 {
1331 struct ctdb_req_control request;
1332 struct ctdb_reply_control *reply;
1333 int ret;
1334
1335 ctdb_req_control_get_public_ips(&request, available_only);
1336 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
1337 &request, &reply);
1338 if (ret != 0) {
1339 DEBUG(DEBUG_ERR,
1340 ("Control GET_PUBLIC_IPS failed to node %u, ret=%d\n",
1341 destnode, ret));
1342 return ret;
1343 }
1344
1345 ret = ctdb_reply_control_get_public_ips(reply, mem_ctx, pubip_list);
1346 if (ret != 0) {
1347 DEBUG(DEBUG_ERR,
1348 ("Control GET_PUBLIC_IPS failed, ret=%d\n", ret));
1349 return ret;
1350 }
1351
1352 return 0;
1353 }
1354
1355 int ctdb_ctrl_get_nodemap(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
1356 struct ctdb_client_context *client,
1357 int destnode, struct timeval timeout,
1358 struct ctdb_node_map **nodemap)
1359 {
1360 struct ctdb_req_control request;
1361 struct ctdb_reply_control *reply;
1362 int ret;
1363
1364 ctdb_req_control_get_nodemap(&request);
1365 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
1366 &request, &reply);
1367 if (ret != 0) {
1368 DEBUG(DEBUG_ERR,
1369 ("Control GET_NODEMAP failed to node %u, ret=%d\n",
1370 destnode, ret));
1371 return ret;
1372 }
1373
1374 ret = ctdb_reply_control_get_nodemap(reply, mem_ctx, nodemap);
1375 if (ret != 0) {
1376 DEBUG(DEBUG_ERR,
1377 ("Control GET_NODEMAP failed, ret=%d\n", ret));
1378 return ret;
1379 }
1380
1381 return 0;
1382 }
1383
1384 int ctdb_ctrl_traverse_kill(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
1385 struct ctdb_client_context *client,
1386 int destnode, struct timeval timeout,
1387 struct ctdb_traverse_start *traverse)
1388 {
1389 struct ctdb_req_control request;
1390 struct ctdb_reply_control *reply;
1391 int ret;
1392
1393 ctdb_req_control_traverse_kill(&request, traverse);
1394 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
1395 &request, &reply);
1396 if (ret != 0) {
1397 DEBUG(DEBUG_ERR,
1398 ("Control TRAVERSE_KILL failed to node %u, ret=%d\n",
1399 destnode, ret));
1400 return ret;
1401 }
1402
1403 ret = ctdb_reply_control_traverse_kill(reply);
1404 if (ret != 0) {
1405 DEBUG(DEBUG_ERR,
1406 ("Control TRAVERSE_KILL failed, ret=%d\n", ret));
1407 return ret;
1408 }
1409
1410 return 0;
1411 }
1412
1413 int ctdb_ctrl_get_reclock_file(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
1414 struct ctdb_client_context *client,
1415 int destnode, struct timeval timeout,
1416 const char **reclock_file)
1417 {
1418 struct ctdb_req_control request;
1419 struct ctdb_reply_control *reply;
1420 int ret;
1421
1422 ctdb_req_control_get_reclock_file(&request);
1423 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
1424 &request, &reply);
1425 if (ret != 0) {
1426 DEBUG(DEBUG_ERR,
1427 ("Control GET_RECLOCK_FILE failed to node %u, ret=%d\n",
1428 destnode, ret));
1429 return ret;
1430 }
1431
1432 ret = ctdb_reply_control_get_reclock_file(reply, mem_ctx, reclock_file);
1433 if (ret != 0) {
1434 DEBUG(DEBUG_ERR,
1435 ("Control GET_RECLOCK_FILE failed, ret=%d\n", ret));
1436 return ret;
1437 }
1438
1439 return 0;
1440 }
1441
1442 int ctdb_ctrl_stop_node(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
1443 struct ctdb_client_context *client,
1444 int destnode, struct timeval timeout)
1445 {
1446 struct ctdb_req_control request;
1447 struct ctdb_reply_control *reply;
1448 int ret;
1449
1450 ctdb_req_control_stop_node(&request);
1451 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
1452 &request, &reply);
1453 if (ret != 0) {
1454 DEBUG(DEBUG_ERR,
1455 ("Control STOP_NODE failed to node %u, ret=%d\n",
1456 destnode, ret));
1457 return ret;
1458 }
1459
1460 ret = ctdb_reply_control_stop_node(reply);
1461 if (ret != 0) {
1462 DEBUG(DEBUG_ERR,
1463 ("Control STOP_NODE failed, ret=%d\n", ret));
1464 return ret;
1465 }
1466
1467 return 0;
1468 }
1469
1470 int ctdb_ctrl_continue_node(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
1471 struct ctdb_client_context *client,
1472 int destnode, struct timeval timeout)
1473 {
1474 struct ctdb_req_control request;
1475 struct ctdb_reply_control *reply;
1476 int ret;
1477
1478 ctdb_req_control_continue_node(&request);
1479 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
1480 &request, &reply);
1481 if (ret != 0) {
1482 DEBUG(DEBUG_ERR,
1483 ("Control CONTINUE_NODE failed to node %u, ret=%d\n",
1484 destnode, ret));
1485 return ret;
1486 }
1487
1488 ret = ctdb_reply_control_continue_node(reply);
1489 if (ret != 0) {
1490 DEBUG(DEBUG_ERR,
1491 ("Control CONTINUE_NODE failed, ret=%d\n", ret));
1492 return ret;
1493 }
1494
1495 return 0;
1496 }
1497
1498 int ctdb_ctrl_set_lmasterrole(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
1499 struct ctdb_client_context *client,
1500 int destnode, struct timeval timeout,
1501 uint32_t lmaster_role)
1502 {
1503 struct ctdb_req_control request;
1504 struct ctdb_reply_control *reply;
1505 int ret;
1506
1507 ctdb_req_control_set_lmasterrole(&request, lmaster_role);
1508 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
1509 &request, &reply);
1510 if (ret != 0) {
1511 DEBUG(DEBUG_ERR,
1512 ("Control SET_LMASTERROLE failed to node %u, ret=%d\n",
1513 destnode, ret));
1514 return ret;
1515 }
1516
1517 ret = ctdb_reply_control_set_lmasterrole(reply);
1518 if (ret != 0) {
1519 DEBUG(DEBUG_ERR,
1520 ("Control SET_LMASTERROLE failed, ret=%d\n", ret));
1521 return ret;
1522 }
1523
1524 return 0;
1525 }
1526
1527 int ctdb_ctrl_set_recmasterrole(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
1528 struct ctdb_client_context *client,
1529 int destnode, struct timeval timeout,
1530 uint32_t recmaster_role)
1531 {
1532 struct ctdb_req_control request;
1533 struct ctdb_reply_control *reply;
1534 int ret;
1535
1536 ctdb_req_control_set_recmasterrole(&request, recmaster_role);
1537 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
1538 &request, &reply);
1539 if (ret != 0) {
1540 DEBUG(DEBUG_ERR,
1541 ("Control SET_RECMASTERROLE failed to node %u, ret=%d\n",
1542 destnode, ret));
1543 return ret;
1544 }
1545
1546 ret = ctdb_reply_control_set_recmasterrole(reply);
1547 if (ret != 0) {
1548 DEBUG(DEBUG_ERR,
1549 ("Control SET_RECMASTERROLE failed, ret=%d\n", ret));
1550 return ret;
1551 }
1552
1553 return 0;
1554 }
1555
1556 int ctdb_ctrl_set_ban_state(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
1557 struct ctdb_client_context *client,
1558 int destnode, struct timeval timeout,
1559 struct ctdb_ban_state *ban_state)
1560 {
1561 struct ctdb_req_control request;
1562 struct ctdb_reply_control *reply;
1563 int ret;
1564
1565 ctdb_req_control_set_ban_state(&request, ban_state);
1566 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
1567 &request, &reply);
1568 if (ret != 0) {
1569 DEBUG(DEBUG_ERR,
1570 ("Control SET_BAN_STATE failed to node %u, ret=%d\n",
1571 destnode, ret));
1572 return ret;
1573 }
1574
1575 ret = ctdb_reply_control_set_ban_state(reply);
1576 if (ret != 0) {
1577 DEBUG(DEBUG_ERR,
1578 ("Control SET_BAN_STATE failed, ret=%d\n", ret));
1579 return ret;
1580 }
1581
1582 return 0;
1583 }
1584
1585 int ctdb_ctrl_get_ban_state(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
1586 struct ctdb_client_context *client,
1587 int destnode, struct timeval timeout,
1588 struct ctdb_ban_state **ban_state)
1589 {
1590 struct ctdb_req_control request;
1591 struct ctdb_reply_control *reply;
1592 int ret;
1593
1594 ctdb_req_control_get_ban_state(&request);
1595 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
1596 &request, &reply);
1597 if (ret != 0) {
1598 DEBUG(DEBUG_ERR,
1599 ("Control GET_BAN_STATE failed to node %u, ret=%d\n",
1600 destnode, ret));
1601 return ret;
1602 }
1603
1604 ret = ctdb_reply_control_get_ban_state(reply, mem_ctx, ban_state);
1605 if (ret != 0) {
1606 DEBUG(DEBUG_ERR,
1607 ("Control GET_BAN_STATE failed, ret=%d\n", ret));
1608 return ret;
1609 }
1610
1611 return 0;
1612 }
1613
1614 int ctdb_ctrl_register_notify(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
1615 struct ctdb_client_context *client,
1616 int destnode, struct timeval timeout,
1617 struct ctdb_notify_data *notify)
1618 {
1619 struct ctdb_req_control request;
1620 struct ctdb_reply_control *reply;
1621 int ret;
1622
1623 ctdb_req_control_register_notify(&request, notify);
1624 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
1625 &request, &reply);
1626 if (ret != 0) {
1627 DEBUG(DEBUG_ERR,
1628 ("Control REGISTER_NOTIFY failed to node %u, ret=%d\n",
1629 destnode, ret));
1630 return ret;
1631 }
1632
1633 ret = ctdb_reply_control_register_notify(reply);
1634 if (ret != 0) {
1635 DEBUG(DEBUG_ERR,
1636 ("Control REGISTER_NOTIFY failed, ret=%d\n", ret));
1637 return ret;
1638 }
1639
1640 return 0;
1641 }
1642
1643 int ctdb_ctrl_deregister_notify(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
1644 struct ctdb_client_context *client,
1645 int destnode, struct timeval timeout,
1646 uint64_t srvid)
1647 {
1648 struct ctdb_req_control request;
1649 struct ctdb_reply_control *reply;
1650 int ret;
1651
1652 ctdb_req_control_deregister_notify(&request, srvid);
1653 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
1654 &request, &reply);
1655 if (ret != 0) {
1656 DEBUG(DEBUG_ERR,
1657 ("Control DEREGISTER_NOTIFY failed to node %u, ret=%d\n",
1658 destnode, ret));
1659 return ret;
1660 }
1661
1662 ret = ctdb_reply_control_deregister_notify(reply);
1663 if (ret != 0) {
1664 DEBUG(DEBUG_ERR,
1665 ("Control DEREGISTER_NOTIFY failed, ret=%d\n", ret));
1666 return ret;
1667 }
1668
1669 return 0;
1670 }
1671
1672 int ctdb_ctrl_trans3_commit(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
1673 struct ctdb_client_context *client,
1674 int destnode, struct timeval timeout,
1675 struct ctdb_rec_buffer *recbuf)
1676 {
1677 struct ctdb_req_control request;
1678 struct ctdb_reply_control *reply;
1679 int ret;
1680
1681 ctdb_req_control_trans3_commit(&request, recbuf);
1682 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
1683 &request, &reply);
1684 if (ret != 0) {
1685 DEBUG(DEBUG_ERR,
1686 ("Control TRANS3_COMMIT failed to node %u, ret=%d\n",
1687 destnode, ret));
1688 return ret;
1689 }
1690
1691 ret = ctdb_reply_control_trans3_commit(reply);
1692 if (ret != 0) {
1693 DEBUG(DEBUG_ERR,
1694 ("Control TRANS3_COMMIT failed, ret=%d\n", ret));
1695 return ret;
1696 }
1697
1698 return 0;
1699 }
1700
1701 int ctdb_ctrl_get_db_seqnum(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
1702 struct ctdb_client_context *client,
1703 int destnode, struct timeval timeout,
1704 uint32_t db_id, uint64_t *seqnum)
1705 {
1706 struct ctdb_req_control request;
1707 struct ctdb_reply_control *reply;
1708 int ret;
1709
1710 ctdb_req_control_get_db_seqnum(&request, db_id);
1711 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
1712 &request, &reply);
1713 if (ret != 0) {
1714 DEBUG(DEBUG_ERR,
1715 ("Control GET_DB_SEQNUM failed to node %u, ret=%d\n",
1716 destnode, ret));
1717 return ret;
1718 }
1719
1720 ret = ctdb_reply_control_get_db_seqnum(reply, seqnum);
1721 if (ret != 0) {
1722 DEBUG(DEBUG_ERR,
1723 ("Control GET_DB_SEQNUM failed, ret=%d\n", ret));
1724 return ret;
1725 }
1726
1727 return 0;
1728 }
1729
1730 int ctdb_ctrl_db_set_healthy(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
1731 struct ctdb_client_context *client,
1732 int destnode, struct timeval timeout,
1733 uint32_t db_id)
1734 {
1735 struct ctdb_req_control request;
1736 struct ctdb_reply_control *reply;
1737 int ret;
1738
1739 ctdb_req_control_db_set_healthy(&request, db_id);
1740 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
1741 &request, &reply);
1742 if (ret != 0) {
1743 DEBUG(DEBUG_ERR,
1744 ("Control DB_SET_HEALTHY failed to node %u, ret=%d\n",
1745 destnode, ret));
1746 return ret;
1747 }
1748
1749 ret = ctdb_reply_control_db_set_healthy(reply);
1750 if (ret != 0) {
1751 DEBUG(DEBUG_ERR,
1752 ("Control DB_SET_HEALTHY failed, ret=%d\n", ret));
1753 return ret;
1754 }
1755
1756 return 0;
1757 }
1758
1759 int ctdb_ctrl_db_get_health(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
1760 struct ctdb_client_context *client,
1761 int destnode, struct timeval timeout,
1762 uint32_t db_id, const char **reason)
1763 {
1764 struct ctdb_req_control request;
1765 struct ctdb_reply_control *reply;
1766 int ret;
1767
1768 ctdb_req_control_db_get_health(&request, db_id);
1769 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
1770 &request, &reply);
1771 if (ret != 0) {
1772 DEBUG(DEBUG_ERR,
1773 ("Control DB_GET_HEALTH failed to node %u, ret=%d\n",
1774 destnode, ret));
1775 return ret;
1776 }
1777
1778 ret = ctdb_reply_control_db_get_health(reply, mem_ctx, reason);
1779 if (ret != 0) {
1780 DEBUG(DEBUG_ERR,
1781 ("Control DB_GET_HEALTH failed, ret=%d\n", ret));
1782 return ret;
1783 }
1784
1785 return 0;
1786 }
1787
1788 int ctdb_ctrl_get_public_ip_info(TALLOC_CTX *mem_ctx,
1789 struct tevent_context *ev,
1790 struct ctdb_client_context *client,
1791 int destnode, struct timeval timeout,
1792 ctdb_sock_addr *addr,
1793 struct ctdb_public_ip_info **ipinfo)
1794 {
1795 struct ctdb_req_control request;
1796 struct ctdb_reply_control *reply;
1797 int ret;
1798
1799 ctdb_req_control_get_public_ip_info(&request, addr);
1800 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
1801 &request, &reply);
1802 if (ret != 0) {
1803 DEBUG(DEBUG_ERR,
1804 ("Control GET_PUBLIC_IP_INFO failed to node %u, ret=%d\n",
1805 destnode, ret));
1806 return ret;
1807 }
1808
1809 ret = ctdb_reply_control_get_public_ip_info(reply, mem_ctx, ipinfo);
1810 if (ret != 0) {
1811 DEBUG(DEBUG_ERR,
1812 ("Control GET_PUBLIC_IP_INFO failed, ret=%d\n", ret));
1813 return ret;
1814 }
1815
1816 return 0;
1817 }
1818
1819 int ctdb_ctrl_get_ifaces(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
1820 struct ctdb_client_context *client,
1821 int destnode, struct timeval timeout,
1822 struct ctdb_iface_list **iface_list)
1823 {
1824 struct ctdb_req_control request;
1825 struct ctdb_reply_control *reply;
1826 int ret;
1827
1828 ctdb_req_control_get_ifaces(&request);
1829 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
1830 &request, &reply);
1831 if (ret != 0) {
1832 DEBUG(DEBUG_ERR,
1833 ("Control GET_IFACES failed to node %u, ret=%d\n",
1834 destnode, ret));
1835 return ret;
1836 }
1837
1838 ret = ctdb_reply_control_get_ifaces(reply, mem_ctx, iface_list);
1839 if (ret != 0) {
1840 DEBUG(DEBUG_ERR,
1841 ("Control GET_IFACES failed, ret=%d\n", ret));
1842 return ret;
1843 }
1844
1845 return 0;
1846 }
1847
1848 int ctdb_ctrl_set_iface_link_state(TALLOC_CTX *mem_ctx,
1849 struct tevent_context *ev,
1850 struct ctdb_client_context *client,
1851 int destnode, struct timeval timeout,
1852 struct ctdb_iface *iface)
1853 {
1854 struct ctdb_req_control request;
1855 struct ctdb_reply_control *reply;
1856 int ret;
1857
1858 ctdb_req_control_set_iface_link_state(&request, iface);
1859 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
1860 &request, &reply);
1861 if (ret != 0) {
1862 DEBUG(DEBUG_ERR,
1863 ("Control SET_IFACE_LINK_STATE failed to node %u, ret=%d\n",
1864 destnode, ret));
1865 return ret;
1866 }
1867
1868 ret = ctdb_reply_control_set_iface_link_state(reply);
1869 if (ret != 0) {
1870 DEBUG(DEBUG_ERR,
1871 ("Control SET_IFACE_LINK_STATE failed, ret=%d\n", ret));
1872 return ret;
1873 }
1874
1875 return 0;
1876 }
1877
1878 int ctdb_ctrl_tcp_add_delayed_update(TALLOC_CTX *mem_ctx,
1879 struct tevent_context *ev,
1880 struct ctdb_client_context *client,
1881 int destnode, struct timeval timeout,
1882 struct ctdb_connection *conn)
1883 {
1884 struct ctdb_req_control request;
1885 struct ctdb_reply_control *reply;
1886 int ret;
1887
1888 ctdb_req_control_tcp_add_delayed_update(&request, conn);
1889 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
1890 &request, &reply);
1891 if (ret != 0) {
1892 DEBUG(DEBUG_ERR,
1893 ("Control TCP_ADD_DELAYED_UPDATE failed to node %u, ret=%d\n",
1894 destnode, ret));
1895 return ret;
1896 }
1897
1898 ret = ctdb_reply_control_tcp_add_delayed_update(reply);
1899 if (ret != 0) {
1900 DEBUG(DEBUG_ERR,
1901 ("Control TCP_ADD_DELAYED_UPDATE failed, ret=%d\n", ret));
1902 return ret;
1903 }
1904
1905 return 0;
1906 }
1907
1908 int ctdb_ctrl_get_stat_history(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
1909 struct ctdb_client_context *client,
1910 int destnode, struct timeval timeout,
1911 struct ctdb_statistics_list **stats_list)
1912 {
1913 struct ctdb_req_control request;
1914 struct ctdb_reply_control *reply;
1915 int ret;
1916
1917 ctdb_req_control_get_stat_history(&request);
1918 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
1919 &request, &reply);
1920 if (ret != 0) {
1921 DEBUG(DEBUG_ERR,
1922 ("Control GET_STAT_HISTORY failed to node %u, ret=%d\n",
1923 destnode, ret));
1924 return ret;
1925 }
1926
1927 ret = ctdb_reply_control_get_stat_history(reply, mem_ctx, stats_list);
1928 if (ret != 0) {
1929 DEBUG(DEBUG_ERR,
1930 ("Control GET_STAT_HISTORY failed, ret=%d\n", ret));
1931 return ret;
1932 }
1933
1934 return 0;
1935 }
1936
1937 int ctdb_ctrl_schedule_for_deletion(TALLOC_CTX *mem_ctx,
1938 struct tevent_context *ev,
1939 struct ctdb_client_context *client,
1940 int destnode, struct timeval timeout,
1941 struct ctdb_key_data *key)
1942 {
1943 struct ctdb_req_control request;
1944 struct ctdb_reply_control *reply;
1945 int ret;
1946
1947 ctdb_req_control_schedule_for_deletion(&request, key);
1948 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
1949 &request, &reply);
1950 if (ret != 0) {
1951 DEBUG(DEBUG_ERR,
1952 ("Control SCHEDULE_FOR_DELETION failed to node %u, ret=%d\n",
1953 destnode, ret));
1954 return ret;
1955 }
1956
1957 ret = ctdb_reply_control_schedule_for_deletion(reply);
1958 if (ret != 0) {
1959 DEBUG(DEBUG_ERR,
1960 ("Control SCHEDULE_FOR_DELETION failed, ret=%d\n", ret));
1961 return ret;
1962 }
1963
1964 return 0;
1965 }
1966
1967 int ctdb_ctrl_set_db_readonly(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
1968 struct ctdb_client_context *client,
1969 int destnode, struct timeval timeout,
1970 uint32_t db_id)
1971 {
1972 struct ctdb_req_control request;
1973 struct ctdb_reply_control *reply;
1974 int ret;
1975
1976 ctdb_req_control_set_db_readonly(&request, db_id);
1977 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
1978 &request, &reply);
1979 if (ret != 0) {
1980 DEBUG(DEBUG_ERR,
1981 ("Control SET_DB_READONY failed to node %u, ret=%d\n",
1982 destnode, ret));
1983 return ret;
1984 }
1985
1986 ret = ctdb_reply_control_set_db_readonly(reply);
1987 if (ret != 0) {
1988 DEBUG(DEBUG_ERR,
1989 ("Control SET_DB_READONY failed, ret=%d\n", ret));
1990 return ret;
1991 }
1992
1993 return 0;
1994 }
1995
1996 int ctdb_ctrl_traverse_start_ext(TALLOC_CTX *mem_ctx,
1997 struct tevent_context *ev,
1998 struct ctdb_client_context *client,
1999 int destnode, struct timeval timeout,
2000 struct ctdb_traverse_start_ext *traverse)
2001 {
2002 struct ctdb_req_control request;
2003 struct ctdb_reply_control *reply;
2004 int ret;
2005
2006 ctdb_req_control_traverse_start_ext(&request, traverse);
2007 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
2008 &request, &reply);
2009 if (ret != 0) {
2010 DEBUG(DEBUG_ERR,
2011 ("Control TRAVERSE_START_EXT failed to node %u, ret=%d\n",
2012 destnode, ret));
2013 return ret;
2014 }
2015
2016 ret = ctdb_reply_control_traverse_start_ext(reply);
2017 if (ret != 0) {
2018 DEBUG(DEBUG_ERR,
2019 ("Control TRAVERSE_START_EXT failed, ret=%d\n", ret));
2020 return ret;
2021 }
2022
2023 return 0;
2024 }
2025
2026 int ctdb_ctrl_get_db_statistics(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
2027 struct ctdb_client_context *client,
2028 int destnode, struct timeval timeout,
2029 uint32_t db_id,
2030 struct ctdb_db_statistics **dbstats)
2031 {
2032 struct ctdb_req_control request;
2033 struct ctdb_reply_control *reply;
2034 int ret;
2035
2036 ctdb_req_control_get_db_statistics(&request, db_id);
2037 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
2038 &request, &reply);
2039 if (ret != 0) {
2040 DEBUG(DEBUG_ERR,
2041 ("Control GET_DB_STATISTICS failed to node %u, ret=%d\n",
2042 destnode, ret));
2043 return ret;
2044 }
2045
2046 ret = ctdb_reply_control_get_db_statistics(reply, mem_ctx, dbstats);
2047 if (ret != 0) {
2048 DEBUG(DEBUG_ERR,
2049 ("Control GET_DB_STATISTICS failed, ret=%d\n", ret));
2050 return ret;
2051 }
2052
2053 return 0;
2054 }
2055
2056 int ctdb_ctrl_set_db_sticky(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
2057 struct ctdb_client_context *client,
2058 int destnode, struct timeval timeout,
2059 uint32_t db_id)
2060 {
2061 struct ctdb_req_control request;
2062 struct ctdb_reply_control *reply;
2063 int ret;
2064
2065 ctdb_req_control_set_db_sticky(&request, db_id);
2066 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
2067 &request, &reply);
2068 if (ret != 0) {
2069 DEBUG(DEBUG_ERR,
2070 ("Control SET_DB_STICKY failed to node %u, ret=%d\n",
2071 destnode, ret));
2072 return ret;
2073 }
2074
2075 ret = ctdb_reply_control_set_db_sticky(reply);
2076 if (ret != 0) {
2077 DEBUG(DEBUG_ERR,
2078 ("Control SET_DB_STICKY failed, ret=%d\n", ret));
2079 return ret;
2080 }
2081
2082 return 0;
2083 }
2084
2085 int ctdb_ctrl_reload_public_ips(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
2086 struct ctdb_client_context *client,
2087 int destnode, struct timeval timeout)
2088 {
2089 struct ctdb_req_control request;
2090 struct ctdb_reply_control *reply;
2091 int ret;
2092
2093 ctdb_req_control_reload_public_ips(&request);
2094 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
2095 &request, &reply);
2096 if (ret != 0) {
2097 DEBUG(DEBUG_ERR,
2098 ("Control RELOAD_PUBLIC_IPS failed to node %u, ret=%d\n",
2099 destnode, ret));
2100 return ret;
2101 }
2102
2103 ret = ctdb_reply_control_reload_public_ips(reply);
2104 if (ret != 0) {
2105 DEBUG(DEBUG_ERR,
2106 ("Control RELOAD_PUBLIC_IPS failed, ret=%d\n", ret));
2107 return ret;
2108 }
2109
2110 return 0;
2111 }
2112
2113 int ctdb_ctrl_get_runstate(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
2114 struct ctdb_client_context *client,
2115 int destnode, struct timeval timeout,
2116 enum ctdb_runstate *runstate)
2117 {
2118 struct ctdb_req_control request;
2119 struct ctdb_reply_control *reply;
2120 int ret;
2121
2122 ctdb_req_control_get_runstate(&request);
2123 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
2124 &request, &reply);
2125 if (ret != 0) {
2126 DEBUG(DEBUG_ERR,
2127 ("Control GET_RUNSTATE failed to node %u, ret=%d\n",
2128 destnode, ret));
2129 return ret;
2130 }
2131
2132 ret = ctdb_reply_control_get_runstate(reply, runstate);
2133 if (ret != 0) {
2134 DEBUG(DEBUG_ERR,
2135 ("Control GET_RUNSTATE failed, ret=%d\n", ret));
2136 return ret;
2137 }
2138
2139 return 0;
2140 }
2141
2142 int ctdb_ctrl_db_detach(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
2143 struct ctdb_client_context *client,
2144 int destnode, struct timeval timeout,
2145 uint32_t db_id)
2146 {
2147 struct ctdb_req_control request;
2148 struct ctdb_reply_control *reply;
2149 int ret;
2150
2151 ctdb_req_control_db_detach(&request, db_id);
2152 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
2153 &request, &reply);
2154 if (ret != 0) {
2155 DEBUG(DEBUG_ERR,
2156 ("Control DB_DETACH failed to node %u, ret=%d\n",
2157 destnode, ret));
2158 return ret;
2159 }
2160
2161 ret = ctdb_reply_control_db_detach(reply);
2162 if (ret != 0) {
2163 DEBUG(DEBUG_ERR,
2164 ("Control DB_DETACH failed, ret=%d\n", ret));
2165 return ret;
2166 }
2167
2168 return 0;
2169 }
2170
2171 int ctdb_ctrl_get_nodes_file(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
2172 struct ctdb_client_context *client,
2173 int destnode, struct timeval timeout,
2174 struct ctdb_node_map **nodemap)
2175 {
2176 struct ctdb_req_control request;
2177 struct ctdb_reply_control *reply;
2178 int ret;
2179
2180 ctdb_req_control_get_nodes_file(&request);
2181 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
2182 &request, &reply);
2183 if (ret != 0) {
2184 DEBUG(DEBUG_ERR,
2185 ("Control GET_NODES_FILE failed to node %u, ret=%d\n",
2186 destnode, ret));
2187 return ret;
2188 }
2189
2190 ret = ctdb_reply_control_get_nodes_file(reply, mem_ctx, nodemap);
2191 if (ret != 0) {
2192 DEBUG(DEBUG_ERR,
2193 ("Control GET_NODES_FILE failed, ret=%d\n", ret));
2194 return ret;
2195 }
2196
2197 return 0;
2198 }
2199
2200 int ctdb_ctrl_db_freeze(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
2201 struct ctdb_client_context *client,
2202 int destnode, struct timeval timeout, uint32_t db_id)
2203 {
2204 struct ctdb_req_control request;
2205 struct ctdb_reply_control *reply;
2206 int ret;
2207
2208 ctdb_req_control_db_freeze(&request, db_id);
2209 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
2210 &request, &reply);
2211 if (ret != 0) {
2212 DEBUG(DEBUG_ERR,
2213 ("Control DB_FREEZE failed to node %u, ret=%d\n",
2214 destnode, ret));
2215 return ret;
2216 }
2217
2218 ret = ctdb_reply_control_db_freeze(reply);
2219 if (ret != 0) {
2220 DEBUG(DEBUG_ERR,
2221 ("Control DB_FREEZE failed, ret=%d\n", ret));
2222 return ret;
2223 }
2224
2225 return 0;
2226 }
2227
2228 int ctdb_ctrl_db_thaw(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
2229 struct ctdb_client_context *client,
2230 int destnode, struct timeval timeout, uint32_t db_id)
2231 {
2232 struct ctdb_req_control request;
2233 struct ctdb_reply_control *reply;
2234 int ret;
2235
2236 ctdb_req_control_db_thaw(&request, db_id);
2237 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
2238 &request, &reply);
2239 if (ret != 0) {
2240 DEBUG(DEBUG_ERR,
2241 ("Control DB_THAW failed to node %u, ret=%d\n",
2242 destnode, ret));
2243 return ret;
2244 }
2245
2246 ret = ctdb_reply_control_db_thaw(reply);
2247 if (ret != 0) {
2248 DEBUG(DEBUG_ERR,
2249 ("Control DB_THAW failed, ret=%d\n", ret));
2250 return ret;
2251 }
2252
2253 return 0;
2254 }
2255
2256 int ctdb_ctrl_db_transaction_start(TALLOC_CTX *mem_ctx,
2257 struct tevent_context *ev,
2258 struct ctdb_client_context *client,
2259 int destnode, struct timeval timeout,
2260 struct ctdb_transdb *transdb)
2261 {
2262 struct ctdb_req_control request;
2263 struct ctdb_reply_control *reply;
2264 int ret;
2265
2266 ctdb_req_control_db_transaction_start(&request, transdb);
2267 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
2268 &request, &reply);
2269 if (ret != 0) {
2270 DEBUG(DEBUG_ERR,
2271 ("Control DB_TRANSACTION_START failed to node %u, ret=%d\n",
2272 destnode, ret));
2273 return ret;
2274 }
2275
2276 ret = ctdb_reply_control_db_transaction_start(reply);
2277 if (ret != 0) {
2278 DEBUG(DEBUG_ERR,
2279 ("Control DB_TRANSACTION_START failed, ret=%d\n", ret));
2280 return ret;
2281 }
2282
2283 return 0;
2284 }
2285
2286 int ctdb_ctrl_db_transaction_commit(TALLOC_CTX *mem_ctx,
2287 struct tevent_context *ev,
2288 struct ctdb_client_context *client,
2289 int destnode, struct timeval timeout,
2290 struct ctdb_transdb *transdb)
2291 {
2292 struct ctdb_req_control request;
2293 struct ctdb_reply_control *reply;
2294 int ret;
2295
2296 ctdb_req_control_db_transaction_commit(&request, transdb);
2297 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
2298 &request, &reply);
2299 if (ret != 0) {
2300 DEBUG(DEBUG_ERR,
2301 ("Control DB_TRANSACTION_COMMIT failed to node %u, ret=%d\n",
2302 destnode, ret));
2303 return ret;
2304 }
2305
2306 ret = ctdb_reply_control_db_transaction_commit(reply);
2307 if (ret != 0) {
2308 DEBUG(DEBUG_ERR,
2309 ("Control DB_TRANSACTION_COMMIT failed, ret=%d\n", ret));
2310 return ret;
2311 }
2312
2313 return 0;
2314 }
2315
2316 int ctdb_ctrl_db_transaction_cancel(TALLOC_CTX *mem_ctx,
2317 struct tevent_context *ev,
2318 struct ctdb_client_context *client,
2319 int destnode, struct timeval timeout,
2320 uint32_t db_id)
2321 {
2322 struct ctdb_req_control request;
2323 struct ctdb_reply_control *reply;
2324 int ret;
2325
2326 ctdb_req_control_db_transaction_cancel(&request, db_id);
2327 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
2328 &request, &reply);
2329 if (ret != 0) {
2330 DEBUG(DEBUG_ERR,
2331 ("Control DB_TRANSACTION_CANCEL failed to node %u, ret=%d\n",
2332 destnode, ret));
2333 return ret;
2334 }
2335
2336 ret = ctdb_reply_control_db_transaction_cancel(reply);
2337 if (ret != 0) {
2338 DEBUG(DEBUG_ERR,
2339 ("Control DB_TRANSACTION_CANCEL failed, ret=%d\n", ret));
2340 return ret;
2341 }
2342
2343 return 0;
2344 }
2345
2346 int ctdb_ctrl_db_pull(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
2347 struct ctdb_client_context *client,
2348 int destnode, struct timeval timeout,
2349 struct ctdb_pulldb_ext *pulldb, uint32_t *num_records)
2350 {
2351 struct ctdb_req_control request;
2352 struct ctdb_reply_control *reply;
2353 int ret;
2354
2355 ctdb_req_control_db_pull(&request, pulldb);
2356 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
2357 &request, &reply);
2358 if (ret != 0) {
2359 DEBUG(DEBUG_ERR,
2360 ("Control DB_PULL failed to node %u, ret=%d\n",
2361 destnode, ret));
2362 return ret;
2363 }
2364
2365 ret = ctdb_reply_control_db_pull(reply, num_records);
2366 if (ret != 0) {
2367 DEBUG(DEBUG_ERR, ("Control DB_PULL failed, ret=%d\n", ret));
2368 return ret;
2369 }
2370
2371 return 0;
2372 }
2373
2374 int ctdb_ctrl_db_push_start(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
2375 struct ctdb_client_context *client,
2376 int destnode, struct timeval timeout,
2377 struct ctdb_pulldb_ext *pulldb)
2378 {
2379 struct ctdb_req_control request;
2380 struct ctdb_reply_control *reply;
2381 int ret;
2382
2383 ctdb_req_control_db_push_start(&request, pulldb);
2384 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
2385 &request, &reply);
2386 if (ret != 0) {
2387 DEBUG(DEBUG_ERR,
2388 ("Control DB_PUSH_START failed to node %u, ret=%d\n",
2389 destnode, ret));
2390 return ret;
2391 }
2392
2393 ret = ctdb_reply_control_db_push_start(reply);
2394 if (ret != 0) {
2395 DEBUG(DEBUG_ERR,
2396 ("Control DB_PUSH_START failed, ret=%d\n", ret));
2397 return ret;
2398 }
2399
2400 return 0;
2401 }
2402
2403 int ctdb_ctrl_db_push_confirm(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
2404 struct ctdb_client_context *client,
2405 int destnode, struct timeval timeout,
2406 uint32_t db_id, uint32_t *num_records)
2407 {
2408 struct ctdb_req_control request;
2409 struct ctdb_reply_control *reply;
2410 int ret;
2411
2412 ctdb_req_control_db_push_confirm(&request, db_id);
2413 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
2414 &request, &reply);
2415 if (ret != 0) {
2416 DEBUG(DEBUG_ERR,
2417 ("Control DB_PUSH_CONFIRM failed to node %u, ret=%d\n",
2418 destnode, ret));
2419 return ret;
2420 }
2421
2422 ret = ctdb_reply_control_db_push_confirm(reply, num_records);
2423 if (ret != 0) {
2424 DEBUG(DEBUG_ERR,
2425 ("Control DB_PUSH_CONFIRM failed, ret=%d\n", ret));
2426 return ret;
2427 }
2428
2429 return 0;
2430 }
2431
2432 int ctdb_ctrl_db_open_flags(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
2433 struct ctdb_client_context *client,
2434 int destnode, struct timeval timeout,
2435 uint32_t db_id, int *tdb_flags)
2436 {
2437 struct ctdb_req_control request;
2438 struct ctdb_reply_control *reply;
2439 int ret;
2440
2441 ctdb_req_control_db_open_flags(&request, db_id);
2442 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
2443 &request, &reply);
2444 if (ret != 0) {
2445 DEBUG(DEBUG_ERR,
2446 ("Control DB_OPEN_FLAGS failed to node %u, ret=%d\n",
2447 destnode, ret));
2448 return ret;
2449 }
2450
2451 ret = ctdb_reply_control_db_open_flags(reply, tdb_flags);
2452 if (ret != 0) {
2453 DEBUG(DEBUG_ERR,
2454 ("Control DB_OPEN_FLAGS failed, ret=%d\n", ret));
2455 return ret;
2456 }
2457
2458 return 0;
2459 }
2460
2461 int ctdb_ctrl_db_attach_replicated(TALLOC_CTX *mem_ctx,
2462 struct tevent_context *ev,
2463 struct ctdb_client_context *client,
2464 int destnode, struct timeval timeout,
2465 const char *db_name, uint32_t *db_id)
2466 {
2467 struct ctdb_req_control request;
2468 struct ctdb_reply_control *reply;
2469 int ret;
2470
2471 ctdb_req_control_db_attach_replicated(&request, db_name);
2472 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
2473 &request, &reply);
2474 if (ret != 0) {
2475 DEBUG(DEBUG_ERR,
2476 ("Control DB_ATTACH_REPLICATED failed to node %u,"
2477 " ret=%d\n", destnode, ret));
2478 return ret;
2479 }
2480
2481 ret = ctdb_reply_control_db_attach_replicated(reply, db_id);
2482 if (ret != 0) {
2483 DEBUG(DEBUG_ERR,
2484 ("Control DB_ATTACH_REPLICATED failed, ret=%d\n", ret));
2485 return ret;
2486 }
2487
2488 return 0;
2489 }
2490
2491 int ctdb_ctrl_check_pid_srvid(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
2492 struct ctdb_client_context *client,
2493 int destnode, struct timeval timeout,
2494 struct ctdb_pid_srvid *pid_srvid, int *status)
2495 {
2496 struct ctdb_req_control request;
2497 struct ctdb_reply_control *reply;
2498 int ret;
2499
2500 ctdb_req_control_check_pid_srvid(&request, pid_srvid);
2501 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
2502 &request, &reply);
2503 if (ret != 0) {
2504 DEBUG(DEBUG_ERR,
2505 ("Control CHECK_PID_SRVID failed to node %u, ret=%d\n",
2506 destnode, ret));
2507 return ret;
2508 }
2509
2510 ret = ctdb_reply_control_check_pid_srvid(reply, status);
2511 if (ret != 0) {
2512 DEBUG(DEBUG_ERR,
2513 ("Control CHECK_PID_SRVID failed, ret=%d\n", ret));
2514 return ret;
2515 }
2516
2517 return 0;
2518 }
2519
2520 int ctdb_ctrl_tunnel_register(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
2521 struct ctdb_client_context *client,
2522 int destnode, struct timeval timeout,
2523 uint64_t tunnel_id)
2524 {
2525 struct ctdb_req_control request;
2526 struct ctdb_reply_control *reply;
2527 int ret;
2528
2529 ctdb_req_control_tunnel_register(&request, tunnel_id);
2530 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
2531 &request, &reply);
2532 if (ret != 0) {
2533 DEBUG(DEBUG_ERR,
2534 ("Control TUNNEL_REGISTER failed to node %u, ret=%d\n",
2535 destnode, ret));
2536 return ret;
2537 }
2538
2539 ret = ctdb_reply_control_tunnel_register(reply);
2540 if (ret != 0) {
2541 DEBUG(DEBUG_ERR,
2542 ("Control TUNNEL_REGISTER failed, ret=%d\n", ret));
2543 return ret;
2544 }
2545
2546 return 0;
2547 }
2548
2549 int ctdb_ctrl_tunnel_deregister(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
2550 struct ctdb_client_context *client,
2551 int destnode, struct timeval timeout,
2552 uint64_t tunnel_id)
2553 {
2554 struct ctdb_req_control request;
2555 struct ctdb_reply_control *reply;
2556 int ret;
2557
2558 ctdb_req_control_tunnel_deregister(&request, tunnel_id);
2559 ret = ctdb_client_control(mem_ctx, ev, client, destnode, timeout,
2560 &request, &reply);
2561 if (ret != 0) {
2562 DEBUG(DEBUG_ERR,
2563 ("Control TUNNEL_DEREGISTER failed to node %u, ret=%d\n",
2564 destnode, ret));
2565 return ret;
2566 }
2567
2568 ret = ctdb_reply_control_tunnel_deregister(reply);
2569 if (ret != 0) {
2570 DEBUG(DEBUG_ERR,
2571 ("Control TUNNEL_DEREGISTER failed, ret=%d\n", ret));
2572 return ret;
2573 }
2574
2575 return 0;
2576 }
2577
2578 int ctdb_ctrl_disable_node(TALLOC_CTX *mem_ctx,
2579 struct tevent_context *ev,
2580 struct ctdb_client_context *client,
2581 int destnode,
2582 struct timeval timeout)
2583 {
2584 struct ctdb_req_control request = {
2585 .opcode = 0,
2586 };
2587 struct ctdb_reply_control *reply = NULL;
2588 int ret;
2589
2590 ctdb_req_control_disable_node(&request);
2591 ret = ctdb_client_control(mem_ctx,
2592 ev,
2593 client,
2594 destnode,
2595 timeout,
2596 &request,
2597 &reply);
2598 if (ret != 0) {
2599 D_ERR("Control DISABLE_NODE failed to node %u, ret=%d\n",
2600 destnode,
2601 ret);
2602 return ret;
2603 }
2604
2605 ret = ctdb_reply_control_disable_node(reply);
2606 if (ret != 0) {
2607 D_ERR("Control DISABLE_NODE failed, ret=%d\n", ret);
2608 return ret;
2609 }
2610
2611 return 0;
2612 }
2613
2614 int ctdb_ctrl_enable_node(TALLOC_CTX *mem_ctx,
2615 struct tevent_context *ev,
2616 struct ctdb_client_context *client,
2617 int destnode,
2618 struct timeval timeout)
2619 {
2620 struct ctdb_req_control request = {
2621 .opcode = 0,
2622 };
2623 struct ctdb_reply_control *reply = NULL;
2624 int ret;
2625
2626 ctdb_req_control_enable_node(&request);
2627 ret = ctdb_client_control(mem_ctx,
2628 ev,
2629 client,
2630 destnode,
2631 timeout,
2632 &request,
2633 &reply);
2634 if (ret != 0) {
2635 D_ERR("Control ENABLE_NODE failed to node %u, ret=%d\n",
2636 destnode,
2637 ret);
2638 return ret;
2639 }
2640
2641 ret = ctdb_reply_control_enable_node(reply);
2642 if (ret != 0) {
2643 D_ERR("Control ENABLE_NODE failed, ret=%d\n", ret);
2644 return ret;
2645 }
2646
2647 return 0;
2648 }
Samba GIT mirror