ctdb/client/client_control_sync.c

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