ctdb/include/ctdb.h

   1 /*
   2    ctdb database library
   3
   4    Copyright (C) Ronnie sahlberg 2010
   5    Copyright (C) Rusty Russell 2010
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, see <http://www.gnu.org/licenses/>.
  19 */
  20
  21 #ifndef _CTDB_H
  22 #define _CTDB_H
  23 #include <sys/types.h>
  24 #include <stdint.h>
  25 #include <stdbool.h>
  26 #include <stdarg.h>
  27 #include <stdio.h>
  28 #include <tdb.h>
  29 #include <netinet/in.h>
  30 #include <ctdb_protocol.h>
  31
  32 /**
  33  * ctdb - a library for accessing tdbs controlled by ctdbd
  34  *
  35  * ctdbd (clustered tdb daemon) is a daemon designed to syncronize TDB
  36  * databases across a cluster.  Using this library, you can communicate with
  37  * the daemon to access the databases, pass messages across the cluster, and
  38  * control the daemon itself.
  39  *
  40  * The general API is event-driven and asynchronous: you call the
  41  * *_send functions, supplying callbacks, then when the ctdbd file
  42  * descriptor is usable, call ctdb_service() to perform read from it
  43  * and call your callbacks, which use the *_recv functions to unpack
  44  * the replies from ctdbd.
  45  *
  46  * There is also a synchronous wrapper for each function for trivial
  47  * programs; these can be found in the section marked "Synchronous API".
  48  */
  49
  50 /**
  51  * ctdb_log_fn_t - logging function for ctdbd
  52  * @log_priv: private (typesafe) arg via ctdb_connect
  53  * @severity: syslog-style severity
  54  * @format: printf-style format string.
  55  * @ap: arguments for formatting.
  56  *
  57  * The severity passed to log() are as per syslog(3).  In particular,
  58  * LOG_DEBUG is used for tracing, LOG_WARNING is used for unusual
  59  * conditions which don't necessarily return an error through the API,
  60  * LOG_ERR is used for errors such as lost communication with ctdbd or
  61  * out-of-memory, LOG_ALERT is used for library usage bugs, LOG_CRIT is
  62  * used for libctdb internal consistency checks.
  63  *
  64  * The log() function can be typesafe: the @log_priv arg to
  65  * ctdb_donnect and signature of log() should match.
  66  */
  67 typedef void (*ctdb_log_fn_t)(void *log_priv,
  68                               int severity, const char *format, va_list ap);
  69
  70 /**
  71  * ctdb_connect - connect to ctdb using the specified domain socket.
  72  * @addr: the socket address, or NULL for default
  73  * @log: the logging function
  74  * @log_priv: the private argument to the logging function.
  75  *
  76  * Returns a ctdb context if successful or NULL.  Use ctdb_disconnect() to
  77  * release the returned ctdb_connection when finished.
  78  *
  79  * See Also:
  80  *      ctdb_log_fn_t, ctdb_log_file()
  81  */
  82 struct ctdb_connection *ctdb_connect(const char *addr,
  83                                      ctdb_log_fn_t log_fn, void *log_priv);
  84
  85 /**
  86  * ctdb_log_file - example logging function
  87  *
  88  * Logs everything at priority LOG_WARNING or above to the file given (via
  89  * the log_priv argument, usually stderr).
  90  */
  91 void ctdb_log_file(FILE *, int, const char *, va_list);
  92
  93 /**
  94  * ctdb_log_level - level at which to call logging function
  95  *
  96  * This variable globally controls filtering on the logging function.
  97  * It is initialized to LOG_WARNING, meaning that strange but nonfatal
  98  * events, as well as errors and API misuses are reported.
  99  *
 100  * Set it to LOG_DEBUG to receive all messages.
 101  */
 102 extern int ctdb_log_level;
 103
 104 /**
 105  * ctdb_disconnect - close down a connection to ctdbd.
 106  * @ctdb: the ctdb connectio returned from ctdb_connect.
 107  *
 108  * The @ctdb arg will be freed by this call, and must not be used again.
 109  */
 110 void ctdb_disconnect(struct ctdb_connection *ctdb);
 111
 112 /***
 113  *
 114  *  Asynchronous API
 115  *
 116  ***/
 117
 118 /**
 119  * ctdb_num_active - get the number of active commands
 120  * @ctdb: the ctdb_connection from ctdb_connect.
 121  *
 122  * This command can be used to find the number of active commands we have
 123  * issued. An active command is a command we have queued, or sent
 124  * to the ctdb daemon but which we have not yet received a reply to.
 125  *
 126  * See Also:
 127  *      ctdb_num_in_flight(), ctdb_num_out_queue()
 128  */
 129 int ctdb_num_active(struct ctdb_connection *ctdb);
 130
 131 /**
 132  * ctdb_num_in_flight - get the number of commands in flight.
 133  * @ctdb: the ctdb_connection from ctdb_connect.
 134  *
 135  * This command can be used to find the number of commands we have
 136  * sent to the ctdb daemon to which we have not yet received/processed
 137  * the reply.
 138  *
 139  * See Also:
 140  *      ctdb_num_out_queue(), ctdb_num_active()
 141  */
 142 int ctdb_num_in_flight(struct ctdb_connection *ctdb);
 143
 144 /**
 145  * ctdb_num_out_queue - get the number of commands in the out queue
 146  * @ctdb: the ctdb_connection from ctdb_connect.
 147  *
 148  * This command can be used to find the number of commands we have
 149  * queued for delivery to the ctdb daemon but have not yet been
 150  * written to the domain socket.
 151  *
 152  * See Also:
 153  *      ctdb_num_in_flight(), ctdb_num_active()
 154  */
 155 int ctdb_num_out_queue(struct ctdb_connection *ctdb);
 156
 157 /**
 158  * ctdb_get_fd - get the filedescriptor to select/poll on
 159  * @ctdb: the ctdb_connection from ctdb_connect.
 160  *
 161  * By using poll or select on this file descriptor, you will know when to call
 162  * ctdb_service().
 163  *
 164  * See Also:
 165  *      ctdb_which_events(), ctdb_service()
 166  */
 167 int ctdb_get_fd(struct ctdb_connection *ctdb);
 168
 169 /**
 170  * ctdb_which_events - determine which events ctdb_service wants to see
 171  * @ctdb: the ctdb_connection from ctdb_connect.
 172  *
 173  * This returns POLLIN, possibly or'd with POLLOUT if there are writes
 174  * pending.  You can set this straight into poll.events.
 175  *
 176  * See Also:
 177  *      ctdb_service()
 178  */
 179 int ctdb_which_events(struct ctdb_connection *ctdb);
 180
 181 /**
 182  * ctdb_service - service any I/O and callbacks from ctdbd communication
 183  * @ctdb: the ctdb_connection from ctdb_connect.
 184  * @revents: which events are available.
 185  *
 186  * This is the core of the library: it read and writes to the ctdbd
 187  * socket.  It may call callbacks registered with the various _send
 188  * functions.
 189  *
 190  * revents is a bitset: POLLIN and/or POLLOUT may be set to indicate
 191  * it is worth attempting to read/write the (nonblocking)
 192  * filedescriptor respectively.
 193  *
 194  * Note that the synchronous functions call this internally.
 195  * Returns false on catastrophic failure.
 196  */
 197 bool ctdb_service(struct ctdb_connection *ctdb, int revents);
 198
 199 /**
 200  * struct ctdb_request - handle for an outstanding request
 201  *
 202  * This opaque structure returned from various *_send functions gives
 203  * you a handle by which you can cancel a request.  You can't do
 204  * anything else with it until the request is completed and it is
 205  * handed to your callback function.
 206  */
 207 struct ctdb_request;
 208
 209 /**
 210  * ctdb_request_free - free a completed request
 211  *
 212  * This frees a request: you should only call it once it has been
 213  * handed to your callback.  For incomplete requests, see ctdb_cancel().
 214  */
 215 void ctdb_request_free(struct ctdb_request *req);
 216
 217 /**
 218  * ctdb_callback_t - callback for completed requests.
 219  *
 220  * This would normally unpack the request using ctdb_*_recv().  You
 221  * must free the request using ctdb_request_free().
 222  *
 223  * Note that due to macro magic, actual your callback can be typesafe:
 224  * instead of taking a void *, it can take a type which matches the
 225  * actual private parameter.
 226  */
 227 typedef void (*ctdb_callback_t)(struct ctdb_connection *ctdb,
 228                                 struct ctdb_request *req, void *private_data);
 229
 230 /**
 231  * struct ctdb_db - connection to a particular open TDB
 232  *
 233  * This represents a particular open database: you receive it from
 234  * ctdb_attachdb or ctdb_attachdb_recv to manipulate a database.
 235  *
 236  * You have to free the handle with ctdb_detachdb() when finished with it.
 237  */
 238 struct ctdb_db;
 239
 240 /**
 241  * ctdb_attachdb_send - open a clustered TDB
 242  * @ctdb: the ctdb_connection from ctdb_connect.
 243  * @name: the filename of the database (no /).
 244  * @persistent: whether the database is persistent across ctdbd's life
 245  * @tdb_flags: the flags to pass to tdb_open.
 246  * @callback: the callback when we're attached or failed (typesafe)
 247  * @cbdata: the argument to callback()
 248  *
 249  * This function connects to a TDB controlled by ctdbd.  It can create
 250  * a new TDB if it does not exist, depending on tdb_flags.  Returns
 251  * the pending request, or NULL on error.
 252  */
 253 struct ctdb_request *
 254 ctdb_attachdb_send(struct ctdb_connection *ctdb,
 255                    const char *name, bool persistent, uint32_t tdb_flags,
 256                    ctdb_callback_t callback, void *cbdata);
 257
 258 /**
 259  * ctdb_attachdb_recv - read an ctdb_attach reply from ctdbd
 260  * @ctdb: the ctdb_connection from ctdb_connect.
 261  * @req: the completed request.
 262  *
 263  * This returns NULL if something went wrong, or otherwise the open database.
 264  */
 265 struct ctdb_db *ctdb_attachdb_recv(struct ctdb_connection *ctdb,
 266                                    struct ctdb_request *req);
 267
 268
 269 /**
 270  * struct ctdb_lock - a record lock on a clustered TDB database
 271  *
 272  * This locks a subset of the database across the entire cluster; it
 273  * is the fundamental sychronization element for ctdb.  You cannot have
 274  * more than one lock at once.
 275  *
 276  * You MUST NOT block during holding this lock and MUST release it
 277  * quickly by performing ctdb_release_lock(lock).
 278  * Do NOT make any system calls that may block while holding the lock.
 279  *
 280  * Try to release the lock as quickly as possible.
 281  */
 282 struct ctdb_lock;
 283
 284 /**
 285  * ctdb_rrl_callback_t - callback for ctdb_readrecordlock_async
 286  *
 287  * This is not the standard ctdb_callback_t, because there is often no
 288  * request required to access a database record (ie. if it is local already).
 289  * So the callback is handed the lock directly: it might be NULL if there
 290  * was an error obtaining the lock.
 291  *
 292  * See Also:
 293  *      ctdb_readrecordlock_async(), ctdb_readrecordlock()
 294  */
 295 typedef void (*ctdb_rrl_callback_t)(struct ctdb_db *ctdb_db,
 296                                     struct ctdb_lock *lock,
 297                                     TDB_DATA data,
 298                                     void *private_data);
 299
 300 /**
 301  * ctdb_readrecordlock_async - read and lock a record
 302  * @ctdb_db: the database handle from ctdb_attachdb/ctdb_attachdb_recv.
 303  * @key: the key of the record to lock.
 304  * @callback: the callback once the record is locked (typesafe).
 305  * @cbdata: the argument to callback()
 306  *
 307  * This returns true on success.  Commonly, we can obtain the record
 308  * immediately and so the callback will be invoked.  Otherwise a request
 309  * will be queued to ctdbd for the record.
 310  *
 311  * If failure is immediate, false is returned.  Otherwise, the callback
 312  * may receive a NULL lock arg to indicate asynchronous failure.
 313  */
 314 bool ctdb_readrecordlock_async(struct ctdb_db *ctdb_db, TDB_DATA key,
 315                                ctdb_rrl_callback_t callback, void *cbdata);
 316
 317 /**
 318  * ctdb_readonlyrecordlock_async - read and lock a record for read-only access
 319  * @ctdb_db: the database handle from ctdb_attachdb/ctdb_attachdb_recv.
 320  * @key: the key of the record to lock.
 321  * @callback: the callback once the record is locked (typesafe).
 322  * @cbdata: the argument to callback()
 323  *
 324  * This returns true on success.  Commonly, we can obtain the record
 325  * immediately and so the callback will be invoked.  Otherwise a request
 326  * will be queued to ctdbd for the record.
 327  *
 328  * If failure is immediate, false is returned.  Otherwise, the callback
 329  * may receive a NULL lock arg to indicate asynchronous failure.
 330  */
 331 bool ctdb_readonlyrecordlock_async(struct ctdb_db *ctdb_db, TDB_DATA key,
 332                                ctdb_rrl_callback_t callback, void *cbdata);
 333
 334
 335 /**
 336  * ctdb_writerecord - write a locked record in a TDB
 337  * @ctdb_db: the database handle from ctdb_attachdb/ctdb_attachdb_recv.
 338  * @lock: the lock from ctdb_readrecordlock/ctdb_readrecordlock_recv
 339  * @data: the new data to place in the record.
 340  */
 341 bool ctdb_writerecord(struct ctdb_db *ctdb_db,
 342                       struct ctdb_lock *lock, TDB_DATA data);
 343
 344 /**
 345  * ctdb_release_lock - release a record lock on a TDB
 346  * @ctdb_db: the database handle from ctdb_attachdb/ctdb_attachdb_recv.
 347  * @lock: the lock from ctdb_readrecordlock/ctdb_readrecordlock_async
 348  */
 349 void ctdb_release_lock(struct ctdb_db *ctdb_db, struct ctdb_lock *lock);
 350
 351
 352
 353 /**
 354  * ctdb_traverse_callback_t - callback for ctdb_traverse_async.
 355  * return 0 - to continue traverse
 356  * return 1 - to abort the traverse
 357  *
 358  * See Also:
 359  *      ctdb_traverse_async()
 360  */
 361 #define TRAVERSE_STATUS_RECORD          0
 362 #define TRAVERSE_STATUS_FINISHED        1
 363 #define TRAVERSE_STATUS_ERROR           2
 364 typedef int (*ctdb_traverse_callback_t)(struct ctdb_connection *ctdb,
 365                                     struct ctdb_db *ctdb_db,
 366                                     int status,
 367                                     TDB_DATA key,
 368                                     TDB_DATA data,
 369                                     void *private_data);
 370
 371 /**
 372  * ctdb_traverse_async - traverse a database.
 373  * @ctdb_db: the database handle from ctdb_attachdb/ctdb_attachdb_recv.
 374  * @callback: the callback once the record is locked (typesafe).
 375  * @cbdata: the argument to callback()
 376  *
 377  * This returns true on success.
 378  * when successfull, the callback will be invoked for each record
 379  * until the traversal is finished.
 380  *
 381  * status ==
 382  * TRAVERSE_STATUS_RECORD         key/data contains a record.
 383  * TRAVERSE_STATUS_FINISHED       traverse is finished. key/data is undefined.
 384  * TRAVERSE_STATUS_ERROR          an error occured during traverse.
 385  *                                key/data is undefined.
 386  *
 387  * If failure is immediate, false is returned.
 388  */
 389 bool ctdb_traverse_async(struct ctdb_db *ctdb_db,
 390                          ctdb_traverse_callback_t callback, void *cbdata);
 391
 392 /**
 393  * ctdb_message_fn_t - messaging callback for ctdb messages
 394  *
 395  * ctdbd provides a simple messaging API; you can register for a particular
 396  * 64-bit id on which you want to send messages, and send to other ids.
 397  *
 398  * See Also:
 399  *      ctdb_set_message_handler_send()
 400  */
 401 typedef void (*ctdb_message_fn_t)(struct ctdb_connection *,
 402                                   uint64_t srvid, TDB_DATA data, void *);
 403
 404 /**
 405  * ctdb_set_message_handler_send - register for messages to a srvid
 406  * @ctdb: the ctdb_connection from ctdb_connect.
 407  * @srvid: the 64 bit identifier for our messages.
 408  * @handler: the callback when we receive such a message (typesafe)
 409  * @handler_data: the argument to handler()
 410  * @callback: the callback when ctdb replies to our message (typesafe)
 411  * @cbdata: the argument to callback()
 412  *
 413  * Note: our callback will always be called before handler.
 414  *
 415  * See Also:
 416  *      ctdb_set_message_handler_recv(), ctdb_remove_message_handler_send()
 417  */
 418 struct ctdb_request *
 419 ctdb_set_message_handler_send(struct ctdb_connection *ctdb, uint64_t srvid,
 420                               ctdb_message_fn_t handler,
 421                               void *handler_data,
 422                               ctdb_callback_t callback,
 423                               void *cbdata);
 424
 425 /**
 426  * ctdb_set_message_handler_recv - read a set_message_handler result
 427  * @ctdb: the ctdb_connection from ctdb_connect.
 428  * @req: the completed request
 429  *
 430  * If this returns true, the registered handler may be called from the next
 431  * ctdb_service().  If this returns false, the registration failed.
 432  */
 433 bool ctdb_set_message_handler_recv(struct ctdb_connection *ctdb,
 434                                    struct ctdb_request *handle);
 435
 436 /**
 437  * ctdb_remove_message_handler_send - unregister for messages to a srvid
 438  * @ctdb: the ctdb_connection from ctdb_connect.
 439  * @srvid: the 64 bit identifier for our messages.
 440  * @handler: the callback when we receive such a message (typesafe)
 441  * @handler_data: the argument to handler()
 442  * @callback: the callback when ctdb replies to our message (typesafe)
 443  * @cbdata: the argument to callback()
 444  *
 445  * This undoes a successful ctdb_set_message_handler or
 446  * ctdb_set_message_handler_recv.
 447  */
 448 struct ctdb_request *
 449 ctdb_remove_message_handler_send(struct ctdb_connection *ctdb, uint64_t srvid,
 450                                  ctdb_message_fn_t handler, void *handler_data,
 451                                  ctdb_callback_t callback, void *cbdata);
 452
 453 /**
 454  * ctdb_remove_message_handler_recv - read a remove_message_handler result
 455  * @ctdb: the ctdb_connection from ctdb_connect.
 456  * @req: the completed request
 457  *
 458  * After this returns true, the registered handler will no longer be called.
 459  * If this returns false, the de-registration failed.
 460  */
 461 bool ctdb_remove_message_handler_recv(struct ctdb_connection *ctdb,
 462                                       struct ctdb_request *req);
 463
 464
 465 /**
 466  * ctdb_send_message - send a message via ctdbd
 467  * @ctdb: the ctdb_connection from ctdb_connect.
 468  * @pnn: the physical node number to send to
 469  * @srvid: the 64 bit identifier for this message type.
 470  * @data: the data to send
 471  *
 472  * This allows arbitrary messages to be sent across the cluster to those
 473  * listening (via ctdb_set_message_handler et al).
 474  *
 475  * This queues a message to be sent: you will need to call
 476  * ctdb_service() to actually send the message.  There is no callback
 477  * because there is no acknowledgement.
 478  *
 479  * See Also:
 480  *      ctdb_getpnn_send(), ctdb_getpnn()
 481  */
 482 bool ctdb_send_message(struct ctdb_connection *ctdb, uint32_t pnn, uint64_t srvid, TDB_DATA data);
 483
 484 /**
 485  * ctdb_getpnn_send - read the pnn number of a node.
 486  * @ctdb: the ctdb_connection from ctdb_connect.
 487  * @destnode: the destination node (see below)
 488  * @callback: the callback when ctdb replies to our message (typesafe)
 489  * @cbdata: the argument to callback()
 490  *
 491  * There are several special values for destnode, detailed in
 492  * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the
 493  * local ctdbd.
 494  */
 495 struct ctdb_request *
 496 ctdb_getpnn_send(struct ctdb_connection *ctdb,
 497                  uint32_t destnode,
 498                  ctdb_callback_t callback,
 499                  void *cbdata);
 500 /**
 501  * ctdb_getpnn_recv - read an ctdb_getpnn reply from ctdbd
 502  * @ctdb: the ctdb_connection from ctdb_connect.
 503  * @req: the completed request.
 504  * @pnn: a pointer to the pnn to fill in
 505  *
 506  * This returns false if something went wrong, or otherwise fills in pnn.
 507  */
 508 bool ctdb_getpnn_recv(struct ctdb_connection *ctdb,
 509                       struct ctdb_request *req, uint32_t *pnn);
 510
 511
 512 /**
 513  * ctdb_getdbstat_send - read statistics for a db
 514  * @ctdb: the ctdb_connection from ctdb_connect.
 515  * @destnode: the destination node (see below)
 516  * @db_id:    the database to collect the statistics from
 517  * @callback: the callback when ctdb replies to our message (typesafe)
 518  * @cbdata: the argument to callback()
 519  *
 520  * There are several special values for destnode, detailed in
 521  * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the
 522  * local ctdbd.
 523  */
 524 struct ctdb_request *
 525 ctdb_getdbstat_send(struct ctdb_connection *ctdb,
 526                      uint32_t destnode,
 527                      uint32_t db_id,
 528                      ctdb_callback_t callback,
 529                      void *cbdata);
 530 /**
 531  * ctdb_getdbstat_recv - read an ctdb_getdbstat reply from ctdbd
 532  * @ctdb: the ctdb_connection from ctdb_connect.
 533  * @req: the completed request.
 534  * @stat: a pointer to the *stat to fill in
 535  *
 536  * This returns false if something went wrong, or otherwise fills in **stats
 537  * stats must be freed later by calling ctdb_free_dbstat();
 538  */
 539 bool ctdb_getdbstat_recv(struct ctdb_connection *ctdb,
 540                          struct ctdb_request *req,
 541                          struct ctdb_db_statistics **stat);
 542
 543 void ctdb_free_dbstat(struct ctdb_db_statistics *stat);
 544
 545 /**
 546  * ctdb_check_message_handlers_send - check a list of message_handlers
 547  * if they are registered
 548  * message_handlers are registered on the daemon using the
 549  *   ctdb_set_message_handler_send() call
 550  *
 551  * @ctdb: the ctdb_connection from ctdb_connect.
 552  * @destnode: the destination node (see below)
 553  * @num: number of srvids to check
 554  * @mhs: @num message_handlers values to check
 555  * @callback: the callback when ctdb replies to our message (typesafe)
 556  * @cbdata: the argument to callback()
 557  *
 558  * There are several special values for destnode, detailed in
 559  * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the
 560  * local ctdbd.
 561  */
 562 struct ctdb_request *
 563 ctdb_check_message_handlers_send(struct ctdb_connection *ctdb,
 564                  uint32_t destnode,
 565                  uint32_t num,
 566                  uint64_t *mhs,
 567                  ctdb_callback_t callback,
 568                  void *cbdata);
 569 /**
 570  * ctdb_check_message_handlers_recv - read a ctdb_check_message_handlers
 571  * reply from ctdbd
 572  * @ctdb: the ctdb_connection from ctdb_connect.
 573  * @req: the completed request.
 574  * @num: number of message_handlers to check
 575  * @result: an array of @num uint8_t fields containing the result of the check
 576  *     0: message_handler does not exist
 577  *     1: message_handler exists
 578  *
 579  * This returns false if something went wrong, or otherwise fills in result.
 580  */
 581 bool
 582 ctdb_check_message_handlers_recv(struct ctdb_connection *ctdb,
 583                                   struct ctdb_request *req, uint32_t num,
 584                                   uint8_t *result);
 585
 586
 587 /**
 588  * ctdb_getcapabilities_send - read the capabilities of a node
 589  * @ctdb: the ctdb_connection from ctdb_connect.
 590  * @destnode: the destination node (see below)
 591  * @callback: the callback when ctdb replies to our message (typesafe)
 592  * @cbdata: the argument to callback()
 593  *
 594  * There are several special values for destnode, detailed in
 595  * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the
 596  * local ctdbd.
 597  */
 598 struct ctdb_request *
 599 ctdb_getcapabilities_send(struct ctdb_connection *ctdb,
 600                           uint32_t destnode,
 601                           ctdb_callback_t callback, void *cbdata);
 602
 603 /**
 604  * ctdb_getcapabilities_recv - read an ctdb_getcapabilities reply from ctdbd
 605  * @ctdb: the ctdb_connection from ctdb_connect.
 606  * @req: the completed request.
 607  * @capabilities: a pointer to the capabilities to fill in
 608  *
 609  * This returns false if something went wrong, or otherwise fills in
 610  * capabilities.
 611  */
 612 bool ctdb_getcapabilities_recv(struct ctdb_connection *ctdb,
 613                                struct ctdb_request *handle,
 614                                uint32_t *capabilities);
 615
 616 /**
 617  * ctdb_getdbseqnum_send - read the sequence number off a db
 618  * @ctdb: the ctdb_connection from ctdb_connect.
 619  * @destnode: the destination node (see below)
 620  * @dbid: database id
 621  * @callback: the callback when ctdb replies to our message (typesafe)
 622  * @cbdata: the argument to callback()
 623  *
 624  * There are several special values for destnode, detailed in
 625  * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the
 626  * local ctdbd.
 627  */
 628 struct ctdb_request *
 629 ctdb_getdbseqnum_send(struct ctdb_connection *ctdb,
 630                  uint32_t destnode,
 631                  uint32_t dbid,
 632                  ctdb_callback_t callback,
 633                  void *cbdata);
 634 /**
 635  * ctdb_getdbseqnum_recv - read the sequence number off a database
 636  * @ctdb: the ctdb_connection from ctdb_connect.
 637  * @req: the completed request.
 638  * @seqnum: a pointer to the seqnum to fill in
 639  *
 640  * This returns false if something went wrong, or otherwise fills in pnn.
 641  */
 642 bool ctdb_getdbseqnum_recv(struct ctdb_connection *ctdb,
 643                       struct ctdb_request *req, uint64_t *seqnum);
 644
 645 /**
 646  * ctdb_getnodemap_send - read the nodemap number from a node.
 647  * @ctdb: the ctdb_connection from ctdb_connect.
 648  * @destnode: the destination node (see below)
 649  * @callback: the callback when ctdb replies to our message (typesafe)
 650  * @cbdata: the argument to callback()
 651  *
 652  * There are several special values for destnode, detailed in
 653  * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the
 654  * local ctdbd.
 655  */
 656 struct ctdb_request *
 657 ctdb_getnodemap_send(struct ctdb_connection *ctdb,
 658                  uint32_t destnode,
 659                  ctdb_callback_t callback,
 660                  void *cbdata);
 661 /**
 662  * ctdb_getnodemap_recv - read an ctdb_getnodemap reply from ctdbd
 663  * @ctdb: the ctdb_connection from ctdb_connect.
 664  * @req: the completed request.
 665  * @nodemap: a pointer to the returned nodemap structure
 666  *
 667  * This returns false if something went wrong.
 668  * If the command failed, it guarantees to set nodemap to NULL.
 669  * A non-NULL value for nodemap means the command was successful.
 670  *
 671  * A non-NULL value of the nodemap must be release released/freed
 672  * by ctdb_free_nodemap().
 673  */
 674 bool ctdb_getnodemap_recv(struct ctdb_connection *ctdb,
 675                       struct ctdb_request *req, struct ctdb_node_map **nodemap);
 676
 677 /**
 678  * ctdb_getifaces_send - read the list of interfaces from a node.
 679  * @ctdb: the ctdb_connection from ctdb_connect.
 680  * @destnode: the destination node (see below)
 681  * @callback: the callback when ctdb replies to our message (typesafe)
 682  * @cbdata: the argument to callback()
 683  *
 684  * There are several special values for destnode, detailed in
 685  * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the
 686  * local ctdbd.
 687  */
 688 struct ctdb_request *
 689 ctdb_getifaces_send(struct ctdb_connection *ctdb,
 690                  uint32_t destnode,
 691                  ctdb_callback_t callback,
 692                  void *cbdata);
 693 /**
 694  * ctdb_getifaces_recv - read an ctdb_getifaces reply from ctdbd
 695  * @ctdb: the ctdb_connection from ctdb_connect.
 696  * @req: the completed request.
 697  * @ifaces: the list of interfaces
 698  *
 699  * This returns false if something went wrong.
 700  * If the command failed, it guarantees to set ifaces to NULL.
 701  * A non-NULL value for ifaces means the command was successful.
 702  *
 703  * A non-NULL value of the ifaces must be release released/freed
 704  * by ctdb_free_ifaces().
 705  */
 706 bool ctdb_getifaces_recv(struct ctdb_connection *ctdb,
 707                       struct ctdb_request *req, struct ctdb_ifaces_list **ifaces);
 708
 709 /* Free a datastructure returned by ctdb_getifaces[_recv] */
 710 void ctdb_free_ifaces(struct ctdb_ifaces_list *ifaces);
 711
 712 /**
 713  * ctdb_getpublicips_send - read the public ip list from a node.
 714  * @ctdb: the ctdb_connection from ctdb_connect.
 715  * @destnode: the destination node (see below)
 716  * @callback: the callback when ctdb replies to our message (typesafe)
 717  * @cbdata: the argument to callback()
 718  *
 719  * This control returns the list of public ips known to the local node.
 720  * Deamons only know about those ips that are listed in the local
 721  * public addresses file, which means the returned list of ips may
 722  * be only a subset of all ips across the entire cluster.
 723  *
 724  * There are several special values for destnode, detailed in
 725  * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the
 726  * local ctdbd.
 727  */
 728 struct ctdb_request *
 729 ctdb_getpublicips_send(struct ctdb_connection *ctdb,
 730                  uint32_t destnode,
 731                  ctdb_callback_t callback,
 732                  void *cbdata);
 733 /**
 734  * ctdb_getpublicips_recv - read the public ip list from a node
 735  * @ctdb: the ctdb_connection from ctdb_connect.
 736  * @req: the completed request.
 737  * @ips: a pointer to the returned public ip list
 738  *
 739  * This returns false if something went wrong.
 740  * If the command failed, it guarantees to set ips to NULL.
 741  * A non-NULL value for nodemap means the command was successful.
 742  *
 743  * A non-NULL value of the nodemap must be release released/freed
 744  * by ctdb_free_publicips().
 745  */
 746 bool ctdb_getpublicips_recv(struct ctdb_connection *ctdb,
 747                       struct ctdb_request *req, struct ctdb_all_public_ips **ips);
 748
 749
 750 /**
 751  * ctdb_getrecmaster_send - read the recovery master of a node
 752  * @ctdb: the ctdb_connection from ctdb_connect.
 753  * @destnode: the destination node (see below)
 754  * @callback: the callback when ctdb replies to our message (typesafe)
 755  * @cbdata: the argument to callback()
 756  *
 757  * There are several special values for destnode, detailed in
 758  * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the
 759  * local ctdbd.
 760  */
 761 struct ctdb_request *
 762 ctdb_getrecmaster_send(struct ctdb_connection *ctdb,
 763                         uint32_t destnode,
 764                         ctdb_callback_t callback, void *cbdata);
 765
 766 /**
 767  * ctdb_getrecmaster_recv - read an ctdb_getrecmaster reply from ctdbd
 768  * @ctdb: the ctdb_connection from ctdb_connect.
 769  * @req: the completed request.
 770  * @recmaster: a pointer to the recmaster to fill in
 771  *
 772  * This returns false if something went wrong, or otherwise fills in
 773  * recmaster.
 774  */
 775 bool ctdb_getrecmaster_recv(struct ctdb_connection *ctdb,
 776                             struct ctdb_request *handle,
 777                             uint32_t *recmaster);
 778
 779 /**
 780  * ctdb_getrecmode_send - read the recovery mode of a node
 781  * @ctdb: the ctdb_connection from ctdb_connect.
 782  * @destnode: the destination node (see below)
 783  * @callback: the callback when ctdb replies to our message (typesafe)
 784  * @cbdata: the argument to callback()
 785  *
 786  * There are several special values for destnode, detailed in
 787  * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the
 788  * local ctdbd.
 789  */
 790 struct ctdb_request *
 791 ctdb_getrecmode_send(struct ctdb_connection *ctdb,
 792                      uint32_t destnode,
 793                      ctdb_callback_t callback, void *cbdata);
 794
 795 /**
 796  * ctdb_getrecmode_recv - read an ctdb_getrecmode reply from ctdbd
 797  * @ctdb: the ctdb_connection from ctdb_connect.
 798  * @req: the completed request.
 799  * @recmode: a pointer to the recmode to fill in
 800  *
 801  * This returns false if something went wrong, or otherwise fills in
 802  * recmode.
 803  */
 804 bool ctdb_getrecmode_recv(struct ctdb_connection *ctdb,
 805                           struct ctdb_request *handle,
 806                           uint32_t *recmode);
 807
 808 /**
 809  * ctdb_getvnnmap_send - read the vnn map from a node.
 810  * @ctdb: the ctdb_connection from ctdb_connect.
 811  * @destnode: the destination node (see below)
 812  * @callback: the callback when ctdb replies to our message (typesafe)
 813  * @cbdata: the argument to callback()
 814  *
 815  * There are several special values for destnode, detailed in
 816  * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the
 817  * local ctdbd.
 818  */
 819 struct ctdb_request *
 820 ctdb_getvnnmap_send(struct ctdb_connection *ctdb,
 821                     uint32_t destnode,
 822                     ctdb_callback_t callback,
 823                     void *cbdata);
 824 /**
 825  * ctdb_getvnnmap_recv - read an ctdb_getvnnmap reply from ctdbd
 826  * @ctdb: the ctdb_connection from ctdb_connect.
 827  * @req: the completed request.
 828  * @vnnmap: the list of interfaces
 829  *
 830  * This returns false if something went wrong.
 831  * If the command failed, it guarantees to set vnnmap to NULL.
 832  * A non-NULL value for vnnmap means the command was successful.
 833  *
 834  * A non-NULL value of the vnnmap must be released/freed
 835  * by ctdb_free_vnnmap().
 836  */
 837 bool ctdb_getvnnmap_recv(struct ctdb_connection *ctdb,
 838                          struct ctdb_request *req, struct ctdb_vnn_map **vnnmap);
 839
 840 /**
 841  * ctdb_cancel - cancel an uncompleted request
 842  * @ctdb: the ctdb_connection from ctdb_connect.
 843  * @req: the uncompleted request.
 844  *
 845  * This cancels a request, returning true.  You may not cancel a
 846  * request which has already been completed (ie. once its callback has
 847  * been called); you should simply use ctdb_request_free() in that case.
 848  */
 849 void ctdb_cancel(struct ctdb_connection *ctdb, struct ctdb_request *req);
 850
 851 /***
 852  *
 853  *  Synchronous API
 854  *
 855  ***/
 856
 857 /**
 858  * ctdb_attachdb - open a clustered TDB (synchronous)
 859  * @ctdb: the ctdb_connection from ctdb_connect.
 860  * @name: the filename of the database (no /).
 861  * @persistent: whether the database is persistent across ctdbd's life
 862  * @tdb_flags: the flags to pass to tdb_open.
 863  *
 864  * Do a ctdb_attachdb_send and wait for it to complete.
 865  * Returns NULL on failure.
 866  */
 867 struct ctdb_db *ctdb_attachdb(struct ctdb_connection *ctdb,
 868                               const char *name, bool persistent,
 869                               uint32_t tdb_flags);
 870
 871 /**
 872  * ctdb_detachdb - close a clustered TDB.
 873  * @ctdb: the ctdb_connection from ctdb_connect.
 874  * @db: the database from ctdb_attachdb/ctdb_attachdb_send
 875  *
 876  * Closes a clustered tdb.
 877  */
 878 void ctdb_detachdb(struct ctdb_connection *ctdb, struct ctdb_db *db);
 879
 880 /**
 881  * ctdb_readrecordlock - read and lock a record (synchronous)
 882  * @ctdb: the ctdb_connection from ctdb_connect.
 883  * @ctdb_db: the database handle from ctdb_attachdb/ctdb_attachdb_recv.
 884  * @key: the key of the record to lock.
 885  * @req: a pointer to the request, if one is needed.
 886  *
 887  * Do a ctdb_readrecordlock_send and wait for it to complete.
 888  * Returns NULL on failure.
 889  */
 890 struct ctdb_lock *ctdb_readrecordlock(struct ctdb_connection *ctdb,
 891                                       struct ctdb_db *ctdb_db, TDB_DATA key,
 892                                       TDB_DATA *data);
 893
 894
 895 /**
 896  * ctdb_set_message_handler - register for messages to a srvid (synchronous)
 897  * @ctdb: the ctdb_connection from ctdb_connect.
 898  * @srvid: the 64 bit identifier for our messages.
 899  * @handler: the callback when we receive such a message (typesafe)
 900  * @cbdata: the argument to handler()
 901  *
 902  * If this returns true, the message handler can be called from any
 903  * ctdb_service() (which is also called indirectly by other
 904  * synchronous functions).  If this returns false, the registration
 905  * failed.
 906  */
 907 bool ctdb_set_message_handler(struct ctdb_connection *ctdb, uint64_t srvid,
 908                               ctdb_message_fn_t handler, void *cbdata);
 909
 910
 911 /**
 912  * ctdb_remove_message_handler - deregister for messages (synchronous)
 913  * @ctdb: the ctdb_connection from ctdb_connect.
 914  * @srvid: the 64 bit identifier for our messages.
 915  * @handler: the callback when we receive such a message (typesafe)
 916  * @handler_data: the argument to handler()
 917  *
 918  * If this returns true, the message handler will no longer be called.
 919  * If this returns false, the deregistration failed.
 920  */
 921 bool ctdb_remove_message_handler(struct ctdb_connection *ctdb, uint64_t srvid,
 922                                  ctdb_message_fn_t handler, void *handler_data);
 923
 924 /**
 925  * ctdb_getpnn - read the pnn number of a node (synchronous)
 926  * @ctdb: the ctdb_connection from ctdb_connect.
 927  * @destnode: the destination node (see below)
 928  * @pnn: a pointer to the pnn to fill in
 929  *
 930  * There are several special values for destnode, detailed in
 931  * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the
 932  * local ctdbd.
 933  *
 934  * Returns true and fills in *pnn on success.
 935  */
 936 bool ctdb_getpnn(struct ctdb_connection *ctdb,
 937                  uint32_t destnode,
 938                  uint32_t *pnn);
 939
 940 /**
 941  * ctdb_getdbstat - read the db stat of a node (synchronous)
 942  * @ctdb: the ctdb_connection from ctdb_connect.
 943  * @destnode: the destination node (see below)
 944  * @db_id:    the database to collect the statistics from
 945  * @stat: a pointer to the *stat to fill in
 946  *
 947  * There are several special values for destnode, detailed in
 948  * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the
 949  * local ctdbd.
 950  *
 951  * This returns false if something went wrong, or otherwise fills in **stat
 952  * stat must be freed later by calling ctdb_free_dbstat();
 953  */
 954 bool ctdb_getdbstat(struct ctdb_connection *ctdb,
 955                     uint32_t destnode,
 956                     uint32_t db_id,
 957                     struct ctdb_db_statistics **stat);
 958
 959
 960 /**
 961  * ctdb_check_message_handlers - check a list of message_handlers (synchronous)
 962  * @ctdb: the ctdb_connection from ctdb_connect.
 963  * @destnode: the destination node (see below)
 964  * @num: number of srvids to check
 965  * @mhs: @num message_handlers to check
 966  * @result: an array of @num uint8_t fields containing the result of the check
 967  *     0: message_handler does not exist
 968  *     1: message_handler exists
 969  *
 970  * There are several special values for destnode, detailed in
 971  * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the
 972  * local ctdbd.
 973  */
 974 bool
 975 ctdb_check_message_handlers(struct ctdb_connection *ctdb,
 976                            uint32_t destnode,
 977                            uint32_t num,
 978                            uint64_t *mhs,
 979                            uint8_t *result);
 980
 981 /**
 982  * ctdb_getcapabilities - read the capabilities of a node (synchronous)
 983  * @ctdb: the ctdb_connection from ctdb_connect.
 984  * @destnode: the destination node (see below)
 985  * @capabilities: a pointer to the capabilities to fill in
 986  *
 987  * There are several special values for destnode, detailed in
 988  * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the
 989  * local ctdbd.
 990  *
 991  * Returns true and fills in *capabilities on success.
 992  */
 993 bool ctdb_getcapabilities(struct ctdb_connection *ctdb,
 994                           uint32_t destnode,
 995                           uint32_t *capabilities);
 996
 997
 998 /**
 999  * ctdb_getdbseqnum - read the seqnum of a database
1000  * @ctdb: the ctdb_connection from ctdb_connect.
1001  * @destnode: the destination node (see below)
1002  * @dbid: database id
1003  * @seqnum: sequence number for the database
1004  *
1005  * There are several special values for destnode, detailed in
1006  * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the
1007  * local ctdbd.
1008  *
1009  * Returns true and fills in *pnn on success.
1010  */
1011 bool
1012 ctdb_getdbseqnum(struct ctdb_connection *ctdb,
1013                  uint32_t destnode,
1014                  uint32_t dbid,
1015                  uint64_t *seqnum);
1016
1017 /**
1018  * ctdb_getrecmaster - read the recovery master of a node (synchronous)
1019  * @ctdb: the ctdb_connection from ctdb_connect.
1020  * @destnode: the destination node (see below)
1021  * @recmaster: a pointer to the recmaster to fill in
1022  *
1023  * There are several special values for destnode, detailed in
1024  * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the
1025  * local ctdbd.
1026  *
1027  * Returns true and fills in *recmaster on success.
1028  */
1029 bool ctdb_getrecmaster(struct ctdb_connection *ctdb,
1030                        uint32_t destnode,
1031                        uint32_t *recmaster);
1032
1033
1034 /**
1035  * ctdb_getrecmode - read the recovery mode of a node (synchronous)
1036  * @ctdb: the ctdb_connection from ctdb_connect.
1037  * @destnode: the destination node (see below)
1038  * @recmode: a pointer to the recmode to fill in
1039  *
1040  * There are several special values for destnode, detailed in
1041  * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the
1042  * local ctdbd.
1043  *
1044  * Returns true and fills in *recmode on success.
1045  */
1046 bool ctdb_getrecmode(struct ctdb_connection *ctdb,
1047                      uint32_t destnode,
1048                      uint32_t *recmode);
1049
1050
1051 /**
1052  * ctdb_getnodemap - read the nodemap from a node (synchronous)
1053  * @ctdb: the ctdb_connection from ctdb_connect.
1054  * @destnode: the destination node (see below)
1055  * @nodemap: a pointer to the nodemap to fill in
1056  *
1057  * There are several special values for destnode, detailed in
1058  * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the
1059  * local ctdbd.
1060  *
1061  * Returns true and fills in *nodemap on success.
1062  * A non-NULL nodemap must be freed by calling ctdb_free_nodemap.
1063  */
1064 bool ctdb_getnodemap(struct ctdb_connection *ctdb,
1065                      uint32_t destnode, struct ctdb_node_map **nodemap);
1066
1067 /**
1068  * ctdb_getifaces - read the list of interfaces from a node (synchronous)
1069  * @ctdb: the ctdb_connection from ctdb_connect.
1070  * @destnode: the destination node (see below)
1071  * @ifaces: a pointer to the ifaces to fill in
1072  *
1073  * There are several special values for destnode, detailed in
1074  * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the
1075  * local ctdbd.
1076  *
1077  * Returns true and fills in *ifaces on success.
1078  * A non-NULL value of the ifaces must be release released/freed
1079  * by ctdb_free_ifaces().
1080  */
1081 bool ctdb_getifaces(struct ctdb_connection *ctdb,
1082                     uint32_t destnode, struct ctdb_ifaces_list **ifaces);
1083
1084 /*
1085  * This function is used to release/free the nodemap structure returned
1086  * by ctdb_getnodemap() and ctdb_getnodemap_recv()
1087  */
1088 void ctdb_free_nodemap(struct ctdb_node_map *nodemap);
1089
1090
1091 /**
1092  * ctdb_getpublicips - read the public ip list from a node.
1093  * @ctdb: the ctdb_connection from ctdb_connect.
1094  * @destnode: the destination node (see below)
1095  * @ips: a pointer to the returned public ip list
1096  *
1097  * This control returns the list of public ips known to the local node.
1098  * Deamons only know about those ips that are listed in the local
1099  * public addresses file, which means the returned list of ips may
1100  * be only a subset of all ips across the entire cluster.
1101  *
1102  * There are several special values for destnode, detailed in
1103  * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the
1104  * local ctdbd.
1105  *
1106  * This returns false if something went wrong.
1107  * If the command failed, it guarantees to set ips to NULL.
1108  * A non-NULL value for nodemap means the command was successful.
1109  *
1110  * A non-NULL value of the nodemap must be release released/freed
1111  * by ctdb_free_publicips().
1112  */
1113 bool ctdb_getpublicips(struct ctdb_connection *ctdb,
1114                      uint32_t destnode, struct ctdb_all_public_ips **ips);
1115
1116 /*
1117  * This function is used to release/free the public ip structure returned
1118  * by ctdb_getpublicips() and ctdb_getpublicips_recv()
1119  */
1120 void ctdb_free_publicips(struct ctdb_all_public_ips *ips);
1121
1122
1123 /**
1124  * ctdb_getvnnmap - read the vnn map from a node (synchronous)
1125  * @ctdb: the ctdb_connection from ctdb_connect.
1126  * @destnode: the destination node (see below)
1127  * @vnnmap: a pointer to the vnnmap to fill in
1128  *
1129  * There are several special values for destnode, detailed in
1130  * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the
1131  * local ctdbd.
1132  *
1133  * Returns true and fills in *vnnmap on success.
1134  * A non-NULL value of the vnnmap must be  released/freed
1135  * by ctdb_free_vnnmap().
1136  */
1137 bool ctdb_getvnnmap(struct ctdb_connection *ctdb,
1138                     uint32_t destnode, struct ctdb_vnn_map **vnnmap);
1139
1140 /*
1141  * This function is used to release/free the vnnmap structure returned
1142  * by ctdb_getvnnmap() and ctdb_getvnnmap_recv()
1143  */
1144 void ctdb_free_vnnmap(struct ctdb_vnn_map *vnnmap);
1145
1146 /* These ugly macro wrappers make the callbacks typesafe. */
1147 #include <ctdb_typesafe_cb.h>
1148 #define ctdb_sendcb(cb, cbdata)                                         \
1149          typesafe_cb_preargs(void, (cb), (cbdata),                      \
1150                              struct ctdb_connection *, struct ctdb_request *)
1151
1152 #define ctdb_msgcb(cb, cbdata)                                          \
1153         typesafe_cb_preargs(void, (cb), (cbdata),                       \
1154                             struct ctdb_connection *, uint64_t, TDB_DATA)
1155
1156 #define ctdb_connect(addr, log, logpriv)                                \
1157         ctdb_connect((addr),                                            \
1158                      typesafe_cb_postargs(void, (log), (logpriv),       \
1159                                           int, const char *, va_list),  \
1160                      (logpriv))
1161
1162 #define ctdb_set_message_handler(ctdb, srvid, handler, hdata)           \
1163         ctdb_set_message_handler((ctdb), (srvid),                       \
1164                                  ctdb_msgcb((handler), (hdata)), (hdata))
1165
1166 #define ctdb_remove_message_handler(ctdb, srvid, handler, hdata)        \
1167         ctdb_remove_message_handler((ctdb), (srvid),                    \
1168                                     ctdb_msgcb((handler), (hdata)), (hdata))
1169
1170 #define ctdb_attachdb_send(ctdb, name, persistent, tdb_flags, cb, cbdata) \
1171         ctdb_attachdb_send((ctdb), (name), (persistent), (tdb_flags),   \
1172                            ctdb_sendcb((cb), (cbdata)), (cbdata))
1173
1174 #define ctdb_readrecordlock_async(_ctdb_db, key, cb, cbdata)            \
1175         ctdb_readrecordlock_async((_ctdb_db), (key),                    \
1176                 typesafe_cb_preargs(void, (cb), (cbdata),               \
1177                                     struct ctdb_db *, struct ctdb_lock *, \
1178                                     TDB_DATA), (cbdata))
1179
1180 #define ctdb_set_message_handler_send(ctdb, srvid, handler, hdata, cb, cbdata) \
1181         ctdb_set_message_handler_send((ctdb), (srvid),                  \
1182                                       ctdb_msgcb((handler), (hdata)), (hdata), \
1183                                       ctdb_sendcb((cb), (cbdata)), (cbdata))
1184
1185 #define ctdb_remove_message_handler_send(ctdb, srvid, handler, hdata, cb, cbdata) \
1186         ctdb_remove_message_handler_send((ctdb), (srvid),               \
1187               ctdb_msgcb((handler), (hdata)), (hdata),                  \
1188               ctdb_sendcb((cb), (cbdata)), (cbdata))
1189
1190 #define ctdb_getpnn_send(ctdb, destnode, cb, cbdata)                    \
1191         ctdb_getpnn_send((ctdb), (destnode),                            \
1192                          ctdb_sendcb((cb), (cbdata)), (cbdata))
1193
1194 #define ctdb_getcapabilities_send(ctdb, destnode, cb, cbdata)           \
1195         ctdb_getcapabilities_send((ctdb), (destnode),                   \
1196                                   ctdb_sendcb((cb), (cbdata)), (cbdata))
1197
1198 #define ctdb_getdbstat_send(ctdb, destnode, db_id, cb, cbdata)          \
1199         ctdb_getdbstat_send((ctdb), (destnode), (db_id),                \
1200                             ctdb_sendcb((cb), (cbdata)), (cbdata))
1201
1202 #define ctdb_check_message_handlers_send(ctdb, destnode, num, mhs,      \
1203                          cb, cbdata)                                    \
1204         ctdb_check_message_handlers_send((ctdb), (destnode), (num),     \
1205                          (mhs),                                         \
1206                          ctdb_sendcb((cb), (cbdata)), (cbdata))
1207
1208 #define ctdb_getrecmaster_send(ctdb, destnode, cb, cbdata)              \
1209         ctdb_getrecmaster_send((ctdb), (destnode),                      \
1210                                ctdb_sendcb((cb), (cbdata)), (cbdata))
1211
1212 #define ctdb_getrecmode_send(ctdb, destnode, cb, cbdata)                \
1213         ctdb_getrecmode_send((ctdb), (destnode),                        \
1214                                ctdb_sendcb((cb), (cbdata)), (cbdata))
1215
1216 #define ctdb_getnodemap_send(ctdb, destnode, cb, cbdata)                \
1217         ctdb_getnodemap_send((ctdb), (destnode),                        \
1218                          ctdb_sendcb((cb), (cbdata)), (cbdata))
1219
1220 #define ctdb_getpublicips_send(ctdb, destnode, cb, cbdata)              \
1221         ctdb_getpublicips_send((ctdb), (destnode),                      \
1222                          ctdb_sendcb((cb), (cbdata)), (cbdata))
1223
1224 #define ctdb_getdbseqnum_send(ctdb, destnode, dbid, cb, cbdata)         \
1225         ctdb_getdbseqnum_send((ctdb), (destnode), (dbid),               \
1226                          ctdb_sendcb((cb), (cbdata)), (cbdata))
1227
1228 #define ctdb_getifaces_send(ctdb, destnode, cb, cbdata)                 \
1229         ctdb_getifaces_send((ctdb), (destnode),                         \
1230                          ctdb_sendcb((cb), (cbdata)), (cbdata))
1231
1232 #define ctdb_getvnnmap_send(ctdb, destnode, cb, cbdata)                 \
1233         ctdb_getvnnmap_send((ctdb), (destnode),                         \
1234                          ctdb_sendcb((cb), (cbdata)), (cbdata))
1235
1236 #endif