s4:dsdb fix compiler warnings
[Samba.git] / ctdb / include / ctdb.h
blobc3da06897cbc3f825002cf74556876da070ca0d7
1 /*
2 ctdb database library
4 Copyright (C) Ronnie sahlberg 2010
5 Copyright (C) Rusty Russell 2010
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.
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.
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/>.
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>
32 /**
33 * ctdb - a library for accessing tdbs controlled by ctdbd
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.
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.
46 * There is also a synchronous wrapper for each function for trivial
47 * programs; these can be found in the section marked "Synchronous API".
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.
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.
64 * The log() function can be typesafe: the @log_priv arg to
65 * ctdb_donnect and signature of log() should match.
67 typedef void (*ctdb_log_fn_t)(void *log_priv,
68 int severity, const char *format, va_list ap);
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.
76 * Returns a ctdb context if successful or NULL. Use ctdb_disconnect() to
77 * release the returned ctdb_connection when finished.
79 * See Also:
80 * ctdb_log_fn_t, ctdb_log_file()
82 struct ctdb_connection *ctdb_connect(const char *addr,
83 ctdb_log_fn_t log_fn, void *log_priv);
85 /**
86 * ctdb_log_file - example logging function
88 * Logs everything at priority LOG_WARNING or above to the file given (via
89 * the log_priv argument, usually stderr).
91 void ctdb_log_file(FILE *, int, const char *, va_list);
93 /**
94 * ctdb_log_level - level at which to call logging function
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.
100 * Set it to LOG_DEBUG to receive all messages.
102 extern int ctdb_log_level;
105 * ctdb_disconnect - close down a connection to ctdbd.
106 * @ctdb: the ctdb connectio returned from ctdb_connect.
108 * The @ctdb arg will be freed by this call, and must not be used again.
110 void ctdb_disconnect(struct ctdb_connection *ctdb);
112 /***
114 * Asynchronous API
116 ***/
119 * ctdb_num_active - get the number of active commands
120 * @ctdb: the ctdb_connection from ctdb_connect.
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.
126 * See Also:
127 * ctdb_num_in_flight(), ctdb_num_out_queue()
129 int ctdb_num_active(struct ctdb_connection *ctdb);
132 * ctdb_num_in_flight - get the number of commands in flight.
133 * @ctdb: the ctdb_connection from ctdb_connect.
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.
139 * See Also:
140 * ctdb_num_out_queue(), ctdb_num_active()
142 int ctdb_num_in_flight(struct ctdb_connection *ctdb);
145 * ctdb_num_out_queue - get the number of commands in the out queue
146 * @ctdb: the ctdb_connection from ctdb_connect.
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.
152 * See Also:
153 * ctdb_num_in_flight(), ctdb_num_active()
155 int ctdb_num_out_queue(struct ctdb_connection *ctdb);
158 * ctdb_get_fd - get the filedescriptor to select/poll on
159 * @ctdb: the ctdb_connection from ctdb_connect.
161 * By using poll or select on this file descriptor, you will know when to call
162 * ctdb_service().
164 * See Also:
165 * ctdb_which_events(), ctdb_service()
167 int ctdb_get_fd(struct ctdb_connection *ctdb);
170 * ctdb_which_events - determine which events ctdb_service wants to see
171 * @ctdb: the ctdb_connection from ctdb_connect.
173 * This returns POLLIN, possibly or'd with POLLOUT if there are writes
174 * pending. You can set this straight into poll.events.
176 * See Also:
177 * ctdb_service()
179 int ctdb_which_events(struct ctdb_connection *ctdb);
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.
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.
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.
194 * Note that the synchronous functions call this internally.
195 * Returns false on catastrophic failure.
197 bool ctdb_service(struct ctdb_connection *ctdb, int revents);
200 * struct ctdb_request - handle for an outstanding request
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.
207 struct ctdb_request;
210 * ctdb_request_free - free a completed request
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().
215 void ctdb_request_free(struct ctdb_request *req);
218 * ctdb_callback_t - callback for completed requests.
220 * This would normally unpack the request using ctdb_*_recv(). You
221 * must free the request using ctdb_request_free().
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.
227 typedef void (*ctdb_callback_t)(struct ctdb_connection *ctdb,
228 struct ctdb_request *req, void *private_data);
231 * struct ctdb_db - connection to a particular open TDB
233 * This represents a particular open database: you receive it from
234 * ctdb_attachdb or ctdb_attachdb_recv to manipulate a database.
236 * You have to free the handle with ctdb_detachdb() when finished with it.
238 struct ctdb_db;
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()
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.
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);
259 * ctdb_attachdb_recv - read an ctdb_attach reply from ctdbd
260 * @ctdb: the ctdb_connection from ctdb_connect.
261 * @req: the completed request.
263 * This returns NULL if something went wrong, or otherwise the open database.
265 struct ctdb_db *ctdb_attachdb_recv(struct ctdb_connection *ctdb,
266 struct ctdb_request *req);
270 * struct ctdb_lock - a record lock on a clustered TDB database
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.
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.
280 * Try to release the lock as quickly as possible.
282 struct ctdb_lock;
285 * ctdb_rrl_callback_t - callback for ctdb_readrecordlock_async
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.
292 * See Also:
293 * ctdb_readrecordlock_async(), ctdb_readrecordlock()
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);
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()
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.
311 * If failure is immediate, false is returned. Otherwise, the callback
312 * may receive a NULL lock arg to indicate asynchronous failure.
314 bool ctdb_readrecordlock_async(struct ctdb_db *ctdb_db, TDB_DATA key,
315 ctdb_rrl_callback_t callback, void *cbdata);
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()
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.
328 * If failure is immediate, false is returned. Otherwise, the callback
329 * may receive a NULL lock arg to indicate asynchronous failure.
331 bool ctdb_readonlyrecordlock_async(struct ctdb_db *ctdb_db, TDB_DATA key,
332 ctdb_rrl_callback_t callback, void *cbdata);
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.
341 bool ctdb_writerecord(struct ctdb_db *ctdb_db,
342 struct ctdb_lock *lock, TDB_DATA data);
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
349 void ctdb_release_lock(struct ctdb_db *ctdb_db, struct ctdb_lock *lock);
354 * ctdb_traverse_callback_t - callback for ctdb_traverse_async.
355 * return 0 - to continue traverse
356 * return 1 - to abort the traverse
358 * See Also:
359 * ctdb_traverse_async()
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);
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()
377 * This returns true on success.
378 * when successfull, the callback will be invoked for each record
379 * until the traversal is finished.
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.
387 * If failure is immediate, false is returned.
389 bool ctdb_traverse_async(struct ctdb_db *ctdb_db,
390 ctdb_traverse_callback_t callback, void *cbdata);
393 * ctdb_message_fn_t - messaging callback for ctdb messages
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.
398 * See Also:
399 * ctdb_set_message_handler_send()
401 typedef void (*ctdb_message_fn_t)(struct ctdb_connection *,
402 uint64_t srvid, TDB_DATA data, void *);
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()
413 * Note: our callback will always be called before handler.
415 * See Also:
416 * ctdb_set_message_handler_recv(), ctdb_remove_message_handler_send()
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);
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
430 * If this returns true, the registered handler may be called from the next
431 * ctdb_service(). If this returns false, the registration failed.
433 bool ctdb_set_message_handler_recv(struct ctdb_connection *ctdb,
434 struct ctdb_request *handle);
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()
445 * This undoes a successful ctdb_set_message_handler or
446 * ctdb_set_message_handler_recv.
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);
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
458 * After this returns true, the registered handler will no longer be called.
459 * If this returns false, the de-registration failed.
461 bool ctdb_remove_message_handler_recv(struct ctdb_connection *ctdb,
462 struct ctdb_request *req);
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
472 * This allows arbitrary messages to be sent across the cluster to those
473 * listening (via ctdb_set_message_handler et al).
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.
479 * See Also:
480 * ctdb_getpnn_send(), ctdb_getpnn()
482 bool ctdb_send_message(struct ctdb_connection *ctdb, uint32_t pnn, uint64_t srvid, TDB_DATA data);
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()
491 * There are several special values for destnode, detailed in
492 * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the
493 * local ctdbd.
495 struct ctdb_request *
496 ctdb_getpnn_send(struct ctdb_connection *ctdb,
497 uint32_t destnode,
498 ctdb_callback_t callback,
499 void *cbdata);
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
506 * This returns false if something went wrong, or otherwise fills in pnn.
508 bool ctdb_getpnn_recv(struct ctdb_connection *ctdb,
509 struct ctdb_request *req, uint32_t *pnn);
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()
520 * There are several special values for destnode, detailed in
521 * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the
522 * local ctdbd.
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);
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
536 * This returns false if something went wrong, or otherwise fills in **stats
537 * stats must be freed later by calling ctdb_free_dbstat();
539 bool ctdb_getdbstat_recv(struct ctdb_connection *ctdb,
540 struct ctdb_request *req,
541 struct ctdb_db_statistics **stat);
543 void ctdb_free_dbstat(struct ctdb_db_statistics *stat);
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
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()
558 * There are several special values for destnode, detailed in
559 * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the
560 * local ctdbd.
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);
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
579 * This returns false if something went wrong, or otherwise fills in result.
581 bool
582 ctdb_check_message_handlers_recv(struct ctdb_connection *ctdb,
583 struct ctdb_request *req, uint32_t num,
584 uint8_t *result);
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()
594 * There are several special values for destnode, detailed in
595 * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the
596 * local ctdbd.
598 struct ctdb_request *
599 ctdb_getcapabilities_send(struct ctdb_connection *ctdb,
600 uint32_t destnode,
601 ctdb_callback_t callback, void *cbdata);
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
609 * This returns false if something went wrong, or otherwise fills in
610 * capabilities.
612 bool ctdb_getcapabilities_recv(struct ctdb_connection *ctdb,
613 struct ctdb_request *handle,
614 uint32_t *capabilities);
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()
624 * There are several special values for destnode, detailed in
625 * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the
626 * local ctdbd.
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);
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
640 * This returns false if something went wrong, or otherwise fills in pnn.
642 bool ctdb_getdbseqnum_recv(struct ctdb_connection *ctdb,
643 struct ctdb_request *req, uint64_t *seqnum);
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()
652 * There are several special values for destnode, detailed in
653 * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the
654 * local ctdbd.
656 struct ctdb_request *
657 ctdb_getnodemap_send(struct ctdb_connection *ctdb,
658 uint32_t destnode,
659 ctdb_callback_t callback,
660 void *cbdata);
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
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.
671 * A non-NULL value of the nodemap must be release released/freed
672 * by ctdb_free_nodemap().
674 bool ctdb_getnodemap_recv(struct ctdb_connection *ctdb,
675 struct ctdb_request *req, struct ctdb_node_map **nodemap);
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()
684 * There are several special values for destnode, detailed in
685 * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the
686 * local ctdbd.
688 struct ctdb_request *
689 ctdb_getifaces_send(struct ctdb_connection *ctdb,
690 uint32_t destnode,
691 ctdb_callback_t callback,
692 void *cbdata);
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
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.
703 * A non-NULL value of the ifaces must be release released/freed
704 * by ctdb_free_ifaces().
706 bool ctdb_getifaces_recv(struct ctdb_connection *ctdb,
707 struct ctdb_request *req, struct ctdb_ifaces_list **ifaces);
709 /* Free a datastructure returned by ctdb_getifaces[_recv] */
710 void ctdb_free_ifaces(struct ctdb_ifaces_list *ifaces);
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()
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.
724 * There are several special values for destnode, detailed in
725 * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the
726 * local ctdbd.
728 struct ctdb_request *
729 ctdb_getpublicips_send(struct ctdb_connection *ctdb,
730 uint32_t destnode,
731 ctdb_callback_t callback,
732 void *cbdata);
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
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.
743 * A non-NULL value of the nodemap must be release released/freed
744 * by ctdb_free_publicips().
746 bool ctdb_getpublicips_recv(struct ctdb_connection *ctdb,
747 struct ctdb_request *req, struct ctdb_all_public_ips **ips);
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()
757 * There are several special values for destnode, detailed in
758 * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the
759 * local ctdbd.
761 struct ctdb_request *
762 ctdb_getrecmaster_send(struct ctdb_connection *ctdb,
763 uint32_t destnode,
764 ctdb_callback_t callback, void *cbdata);
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
772 * This returns false if something went wrong, or otherwise fills in
773 * recmaster.
775 bool ctdb_getrecmaster_recv(struct ctdb_connection *ctdb,
776 struct ctdb_request *handle,
777 uint32_t *recmaster);
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()
786 * There are several special values for destnode, detailed in
787 * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the
788 * local ctdbd.
790 struct ctdb_request *
791 ctdb_getrecmode_send(struct ctdb_connection *ctdb,
792 uint32_t destnode,
793 ctdb_callback_t callback, void *cbdata);
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
801 * This returns false if something went wrong, or otherwise fills in
802 * recmode.
804 bool ctdb_getrecmode_recv(struct ctdb_connection *ctdb,
805 struct ctdb_request *handle,
806 uint32_t *recmode);
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()
815 * There are several special values for destnode, detailed in
816 * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the
817 * local ctdbd.
819 struct ctdb_request *
820 ctdb_getvnnmap_send(struct ctdb_connection *ctdb,
821 uint32_t destnode,
822 ctdb_callback_t callback,
823 void *cbdata);
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
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.
834 * A non-NULL value of the vnnmap must be released/freed
835 * by ctdb_free_vnnmap().
837 bool ctdb_getvnnmap_recv(struct ctdb_connection *ctdb,
838 struct ctdb_request *req, struct ctdb_vnn_map **vnnmap);
841 * ctdb_cancel - cancel an uncompleted request
842 * @ctdb: the ctdb_connection from ctdb_connect.
843 * @req: the uncompleted request.
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.
849 void ctdb_cancel(struct ctdb_connection *ctdb, struct ctdb_request *req);
851 /***
853 * Synchronous API
855 ***/
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.
864 * Do a ctdb_attachdb_send and wait for it to complete.
865 * Returns NULL on failure.
867 struct ctdb_db *ctdb_attachdb(struct ctdb_connection *ctdb,
868 const char *name, bool persistent,
869 uint32_t tdb_flags);
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
876 * Closes a clustered tdb.
878 void ctdb_detachdb(struct ctdb_connection *ctdb, struct ctdb_db *db);
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.
887 * Do a ctdb_readrecordlock_send and wait for it to complete.
888 * Returns NULL on failure.
890 struct ctdb_lock *ctdb_readrecordlock(struct ctdb_connection *ctdb,
891 struct ctdb_db *ctdb_db, TDB_DATA key,
892 TDB_DATA *data);
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()
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.
907 bool ctdb_set_message_handler(struct ctdb_connection *ctdb, uint64_t srvid,
908 ctdb_message_fn_t handler, void *cbdata);
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()
918 * If this returns true, the message handler will no longer be called.
919 * If this returns false, the deregistration failed.
921 bool ctdb_remove_message_handler(struct ctdb_connection *ctdb, uint64_t srvid,
922 ctdb_message_fn_t handler, void *handler_data);
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
930 * There are several special values for destnode, detailed in
931 * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the
932 * local ctdbd.
934 * Returns true and fills in *pnn on success.
936 bool ctdb_getpnn(struct ctdb_connection *ctdb,
937 uint32_t destnode,
938 uint32_t *pnn);
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
947 * There are several special values for destnode, detailed in
948 * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the
949 * local ctdbd.
951 * This returns false if something went wrong, or otherwise fills in **stat
952 * stat must be freed later by calling ctdb_free_dbstat();
954 bool ctdb_getdbstat(struct ctdb_connection *ctdb,
955 uint32_t destnode,
956 uint32_t db_id,
957 struct ctdb_db_statistics **stat);
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
970 * There are several special values for destnode, detailed in
971 * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the
972 * local ctdbd.
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);
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
987 * There are several special values for destnode, detailed in
988 * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the
989 * local ctdbd.
991 * Returns true and fills in *capabilities on success.
993 bool ctdb_getcapabilities(struct ctdb_connection *ctdb,
994 uint32_t destnode,
995 uint32_t *capabilities);
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
1005 * There are several special values for destnode, detailed in
1006 * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the
1007 * local ctdbd.
1009 * Returns true and fills in *pnn on success.
1011 bool
1012 ctdb_getdbseqnum(struct ctdb_connection *ctdb,
1013 uint32_t destnode,
1014 uint32_t dbid,
1015 uint64_t *seqnum);
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
1023 * There are several special values for destnode, detailed in
1024 * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the
1025 * local ctdbd.
1027 * Returns true and fills in *recmaster on success.
1029 bool ctdb_getrecmaster(struct ctdb_connection *ctdb,
1030 uint32_t destnode,
1031 uint32_t *recmaster);
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
1040 * There are several special values for destnode, detailed in
1041 * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the
1042 * local ctdbd.
1044 * Returns true and fills in *recmode on success.
1046 bool ctdb_getrecmode(struct ctdb_connection *ctdb,
1047 uint32_t destnode,
1048 uint32_t *recmode);
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
1057 * There are several special values for destnode, detailed in
1058 * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the
1059 * local ctdbd.
1061 * Returns true and fills in *nodemap on success.
1062 * A non-NULL nodemap must be freed by calling ctdb_free_nodemap.
1064 bool ctdb_getnodemap(struct ctdb_connection *ctdb,
1065 uint32_t destnode, struct ctdb_node_map **nodemap);
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
1073 * There are several special values for destnode, detailed in
1074 * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the
1075 * local ctdbd.
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().
1081 bool ctdb_getifaces(struct ctdb_connection *ctdb,
1082 uint32_t destnode, struct ctdb_ifaces_list **ifaces);
1085 * This function is used to release/free the nodemap structure returned
1086 * by ctdb_getnodemap() and ctdb_getnodemap_recv()
1088 void ctdb_free_nodemap(struct ctdb_node_map *nodemap);
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
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.
1102 * There are several special values for destnode, detailed in
1103 * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the
1104 * local ctdbd.
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.
1110 * A non-NULL value of the nodemap must be release released/freed
1111 * by ctdb_free_publicips().
1113 bool ctdb_getpublicips(struct ctdb_connection *ctdb,
1114 uint32_t destnode, struct ctdb_all_public_ips **ips);
1117 * This function is used to release/free the public ip structure returned
1118 * by ctdb_getpublicips() and ctdb_getpublicips_recv()
1120 void ctdb_free_publicips(struct ctdb_all_public_ips *ips);
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
1129 * There are several special values for destnode, detailed in
1130 * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the
1131 * local ctdbd.
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().
1137 bool ctdb_getvnnmap(struct ctdb_connection *ctdb,
1138 uint32_t destnode, struct ctdb_vnn_map **vnnmap);
1141 * This function is used to release/free the vnnmap structure returned
1142 * by ctdb_getvnnmap() and ctdb_getvnnmap_recv()
1144 void ctdb_free_vnnmap(struct ctdb_vnn_map *vnnmap);
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 *)
1152 #define ctdb_msgcb(cb, cbdata) \
1153 typesafe_cb_preargs(void, (cb), (cbdata), \
1154 struct ctdb_connection *, uint64_t, TDB_DATA)
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))
1162 #define ctdb_set_message_handler(ctdb, srvid, handler, hdata) \
1163 ctdb_set_message_handler((ctdb), (srvid), \
1164 ctdb_msgcb((handler), (hdata)), (hdata))
1166 #define ctdb_remove_message_handler(ctdb, srvid, handler, hdata) \
1167 ctdb_remove_message_handler((ctdb), (srvid), \
1168 ctdb_msgcb((handler), (hdata)), (hdata))
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))
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))
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))
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))
1190 #define ctdb_getpnn_send(ctdb, destnode, cb, cbdata) \
1191 ctdb_getpnn_send((ctdb), (destnode), \
1192 ctdb_sendcb((cb), (cbdata)), (cbdata))
1194 #define ctdb_getcapabilities_send(ctdb, destnode, cb, cbdata) \
1195 ctdb_getcapabilities_send((ctdb), (destnode), \
1196 ctdb_sendcb((cb), (cbdata)), (cbdata))
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))
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))
1208 #define ctdb_getrecmaster_send(ctdb, destnode, cb, cbdata) \
1209 ctdb_getrecmaster_send((ctdb), (destnode), \
1210 ctdb_sendcb((cb), (cbdata)), (cbdata))
1212 #define ctdb_getrecmode_send(ctdb, destnode, cb, cbdata) \
1213 ctdb_getrecmode_send((ctdb), (destnode), \
1214 ctdb_sendcb((cb), (cbdata)), (cbdata))
1216 #define ctdb_getnodemap_send(ctdb, destnode, cb, cbdata) \
1217 ctdb_getnodemap_send((ctdb), (destnode), \
1218 ctdb_sendcb((cb), (cbdata)), (cbdata))
1220 #define ctdb_getpublicips_send(ctdb, destnode, cb, cbdata) \
1221 ctdb_getpublicips_send((ctdb), (destnode), \
1222 ctdb_sendcb((cb), (cbdata)), (cbdata))
1224 #define ctdb_getdbseqnum_send(ctdb, destnode, dbid, cb, cbdata) \
1225 ctdb_getdbseqnum_send((ctdb), (destnode), (dbid), \
1226 ctdb_sendcb((cb), (cbdata)), (cbdata))
1228 #define ctdb_getifaces_send(ctdb, destnode, cb, cbdata) \
1229 ctdb_getifaces_send((ctdb), (destnode), \
1230 ctdb_sendcb((cb), (cbdata)), (cbdata))
1232 #define ctdb_getvnnmap_send(ctdb, destnode, cb, cbdata) \
1233 ctdb_getvnnmap_send((ctdb), (destnode), \
1234 ctdb_sendcb((cb), (cbdata)), (cbdata))
1236 #endif