3 provide API to do non-blocking locks for single or all databases
5 Copyright (C) Amitay Isaacs 2012
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 #include "include/ctdb_private.h"
22 #include "include/ctdb_protocol.h"
26 #include "system/filesys.h"
27 #include "lib/util/dlinklist.h"
30 * Non-blocking Locking API
32 * 1. Create a child process to do blocking locks.
33 * 2. Once the locks are obtained, signal parent process via fd.
34 * 3. Invoke registered callback routine with locking status.
35 * 4. If the child process cannot get locks within certain time,
36 * execute an external script to debug.
38 * ctdb_lock_record() - get a lock on a record
39 * ctdb_lock_db() - get a lock on a DB
40 * ctdb_lock_alldb_prio() - get a lock on all DBs with given priority
41 * ctdb_lock_alldb() - get a lock on all DBs
43 * auto_mark - whether to mark/unmark DBs in before/after callback
53 static const char * const lock_type_str[] = {
62 /* lock_context is the common part for a lock request */
64 struct lock_context *next, *prev;
66 struct ctdb_context *ctdb;
67 struct ctdb_db_context *ctdb_db;
71 struct lock_request *request;
74 struct tevent_fd *tfd;
75 struct tevent_timer *ttimer;
76 struct timeval start_time;
81 /* lock_request is the client specific part for a lock request */
83 struct lock_context *lctx;
84 void (*callback)(void *, bool);
90 * Support samba 3.6.x (and older) versions which do not set db priority.
92 * By default, all databases are set to priority 1. So only when priority
93 * is set to 1, check for databases that need higher priority.
95 static bool later_db(struct ctdb_context *ctdb, const char *name)
97 if (ctdb->tunable.samba3_hack == 0) {
101 if (strstr(name, "brlock") ||
102 strstr(name, "g_lock") ||
103 strstr(name, "notify_onelevel") ||
104 strstr(name, "serverid") ||
105 strstr(name, "xattr_tdb")) {
112 typedef int (*db_handler_t)(struct ctdb_db_context *ctdb_db,
116 static int ctdb_db_iterator(struct ctdb_context *ctdb, uint32_t priority,
117 db_handler_t handler, void *private_data)
119 struct ctdb_db_context *ctdb_db;
122 for (ctdb_db = ctdb->db_list; ctdb_db; ctdb_db = ctdb_db->next) {
123 if (ctdb_db->priority != priority) {
126 if (later_db(ctdb, ctdb_db->db_name)) {
129 ret = handler(ctdb_db, priority, private_data);
135 /* If priority != 1, later_db check is not required and can return */
140 for (ctdb_db = ctdb->db_list; ctdb_db; ctdb_db = ctdb_db->next) {
141 if (!later_db(ctdb, ctdb_db->db_name)) {
144 ret = handler(ctdb_db, priority, private_data);
155 * lock all databases - mark only
157 static int db_lock_mark_handler(struct ctdb_db_context *ctdb_db, uint32_t priority,
160 int tdb_transaction_write_lock_mark(struct tdb_context *);
162 DEBUG(DEBUG_INFO, ("marking locked database %s, priority:%u\n",
163 ctdb_db->db_name, priority));
165 if (tdb_transaction_write_lock_mark(ctdb_db->ltdb->tdb) != 0) {
166 DEBUG(DEBUG_ERR, ("Failed to mark (transaction lock) database %s\n",
171 if (tdb_lockall_mark(ctdb_db->ltdb->tdb) != 0) {
172 DEBUG(DEBUG_ERR, ("Failed to mark (all lock) database %s\n",
180 int ctdb_lockall_mark_prio(struct ctdb_context *ctdb, uint32_t priority)
183 * This function is only used by the main dameon during recovery.
184 * At this stage, the databases have already been locked, by a
185 * dedicated child process. The freeze_mode variable is used to track
186 * whether the actual locks are held by the child process or not.
189 if (ctdb->freeze_mode[priority] != CTDB_FREEZE_FROZEN) {
190 DEBUG(DEBUG_ERR, ("Attempt to mark all databases locked when not frozen\n"));
194 return ctdb_db_iterator(ctdb, priority, db_lock_mark_handler, NULL);
197 static int ctdb_lockall_mark(struct ctdb_context *ctdb)
201 for (priority=1; priority<=NUM_DB_PRIORITIES; priority++) {
202 if (ctdb_db_iterator(ctdb, priority, db_lock_mark_handler, NULL) != 0) {
212 * lock all databases - unmark only
214 static int db_lock_unmark_handler(struct ctdb_db_context *ctdb_db, uint32_t priority,
217 int tdb_transaction_write_lock_unmark(struct tdb_context *);
219 DEBUG(DEBUG_INFO, ("unmarking locked database %s, priority:%u\n",
220 ctdb_db->db_name, priority));
222 if (tdb_transaction_write_lock_unmark(ctdb_db->ltdb->tdb) != 0) {
223 DEBUG(DEBUG_ERR, ("Failed to unmark (transaction lock) database %s\n",
228 if (tdb_lockall_unmark(ctdb_db->ltdb->tdb) != 0) {
229 DEBUG(DEBUG_ERR, ("Failed to unmark (all lock) database %s\n",
237 int ctdb_lockall_unmark_prio(struct ctdb_context *ctdb, uint32_t priority)
240 * This function is only used by the main daemon during recovery.
241 * At this stage, the databases have already been locked, by a
242 * dedicated child process. The freeze_mode variable is used to track
243 * whether the actual locks are held by the child process or not.
246 if (ctdb->freeze_mode[priority] != CTDB_FREEZE_FROZEN) {
247 DEBUG(DEBUG_ERR, ("Attempt to unmark all databases locked when not frozen\n"));
251 return ctdb_db_iterator(ctdb, priority, db_lock_unmark_handler, NULL);
254 static int ctdb_lockall_unmark(struct ctdb_context *ctdb)
258 for (priority=NUM_DB_PRIORITIES; priority>0; priority--) {
259 if (ctdb_db_iterator(ctdb, priority, db_lock_unmark_handler, NULL) != 0) {
268 static void ctdb_lock_schedule(struct ctdb_context *ctdb);
271 * Destructor to kill the child locking process
273 static int ctdb_lock_context_destructor(struct lock_context *lock_ctx)
275 if (lock_ctx->child > 0) {
276 ctdb_kill(lock_ctx->ctdb, lock_ctx->child, SIGKILL);
277 if (lock_ctx->type == LOCK_RECORD) {
278 DLIST_REMOVE(lock_ctx->ctdb_db->lock_current, lock_ctx);
280 DLIST_REMOVE(lock_ctx->ctdb->lock_current, lock_ctx);
282 if (lock_ctx->ctdb_db) {
283 lock_ctx->ctdb_db->lock_num_current--;
285 CTDB_DECREMENT_STAT(lock_ctx->ctdb, locks.num_current);
286 if (lock_ctx->ctdb_db) {
287 CTDB_DECREMENT_DB_STAT(lock_ctx->ctdb_db, locks.num_current);
290 if (lock_ctx->type == LOCK_RECORD) {
291 DLIST_REMOVE(lock_ctx->ctdb_db->lock_pending, lock_ctx);
293 DLIST_REMOVE(lock_ctx->ctdb->lock_pending, lock_ctx);
295 CTDB_DECREMENT_STAT(lock_ctx->ctdb, locks.num_pending);
296 if (lock_ctx->ctdb_db) {
297 CTDB_DECREMENT_DB_STAT(lock_ctx->ctdb_db, locks.num_pending);
301 ctdb_lock_schedule(lock_ctx->ctdb);
308 * Destructor to remove lock request
310 static int ctdb_lock_request_destructor(struct lock_request *lock_request)
312 lock_request->lctx->request = NULL;
316 void ctdb_lock_free_request_context(struct lock_request *lock_req)
318 struct lock_context *lock_ctx;
320 lock_ctx = lock_req->lctx;
321 talloc_free(lock_req);
322 talloc_free(lock_ctx);
327 * Process all the callbacks waiting for lock
329 * If lock has failed, callback is executed with locked=false
331 static void process_callbacks(struct lock_context *lock_ctx, bool locked)
333 struct lock_request *request;
335 if (lock_ctx->auto_mark && locked) {
336 switch (lock_ctx->type) {
338 tdb_chainlock_mark(lock_ctx->ctdb_db->ltdb->tdb, lock_ctx->key);
342 tdb_lockall_mark(lock_ctx->ctdb_db->ltdb->tdb);
345 case LOCK_ALLDB_PRIO:
346 ctdb_lockall_mark_prio(lock_ctx->ctdb, lock_ctx->priority);
350 ctdb_lockall_mark(lock_ctx->ctdb);
355 request = lock_ctx->request;
356 if (lock_ctx->auto_mark) {
357 /* Reset the destructor, so request is not removed from the list */
358 talloc_set_destructor(request, NULL);
360 request->callback(request->private_data, locked);
362 if (lock_ctx->auto_mark && locked) {
363 switch (lock_ctx->type) {
365 tdb_chainlock_unmark(lock_ctx->ctdb_db->ltdb->tdb, lock_ctx->key);
369 tdb_lockall_unmark(lock_ctx->ctdb_db->ltdb->tdb);
372 case LOCK_ALLDB_PRIO:
373 ctdb_lockall_unmark_prio(lock_ctx->ctdb, lock_ctx->priority);
377 ctdb_lockall_unmark(lock_ctx->ctdb);
384 static int lock_bucket_id(double t)
386 double ms = 1.e-3, s = 1;
391 } else if (t < 10*ms) {
393 } else if (t < 100*ms) {
395 } else if (t < 1*s) {
397 } else if (t < 2*s) {
399 } else if (t < 4*s) {
401 } else if (t < 8*s) {
403 } else if (t < 16*s) {
405 } else if (t < 32*s) {
407 } else if (t < 64*s) {
417 * Callback routine when the required locks are obtained.
418 * Called from parent context
420 static void ctdb_lock_handler(struct tevent_context *ev,
421 struct tevent_fd *tfd,
425 struct lock_context *lock_ctx;
426 TALLOC_CTX *tmp_ctx = NULL;
432 lock_ctx = talloc_get_type_abort(private_data, struct lock_context);
434 /* cancel the timeout event */
435 if (lock_ctx->ttimer) {
436 TALLOC_FREE(lock_ctx->ttimer);
439 t = timeval_elapsed(&lock_ctx->start_time);
440 id = lock_bucket_id(t);
442 if (lock_ctx->auto_mark) {
443 tmp_ctx = talloc_new(ev);
444 talloc_steal(tmp_ctx, lock_ctx);
447 /* Read the status from the child process */
448 if (read(lock_ctx->fd[0], &c, 1) != 1) {
451 locked = (c == 0 ? true : false);
454 /* Update statistics */
455 CTDB_INCREMENT_STAT(lock_ctx->ctdb, locks.num_calls);
456 if (lock_ctx->ctdb_db) {
457 CTDB_INCREMENT_DB_STAT(lock_ctx->ctdb_db, locks.num_calls);
461 if (lock_ctx->ctdb_db) {
462 CTDB_INCREMENT_STAT(lock_ctx->ctdb, locks.buckets[id]);
463 CTDB_UPDATE_LATENCY(lock_ctx->ctdb, lock_ctx->ctdb_db,
464 lock_type_str[lock_ctx->type], locks.latency,
465 lock_ctx->start_time);
467 CTDB_UPDATE_DB_LATENCY(lock_ctx->ctdb_db, lock_type_str[lock_ctx->type], locks.latency, t);
468 CTDB_INCREMENT_DB_STAT(lock_ctx->ctdb_db, locks.buckets[id]);
471 CTDB_INCREMENT_STAT(lock_ctx->ctdb, locks.num_failed);
472 if (lock_ctx->ctdb_db) {
473 CTDB_INCREMENT_DB_STAT(lock_ctx->ctdb_db, locks.num_failed);
477 process_callbacks(lock_ctx, locked);
479 if (lock_ctx->auto_mark) {
480 talloc_free(tmp_ctx);
486 * Callback routine when required locks are not obtained within timeout
487 * Called from parent context
489 static void ctdb_lock_timeout_handler(struct tevent_context *ev,
490 struct tevent_timer *ttimer,
491 struct timeval current_time,
494 static const char * debug_locks = NULL;
495 struct lock_context *lock_ctx;
496 struct ctdb_context *ctdb;
499 lock_ctx = talloc_get_type_abort(private_data, struct lock_context);
500 ctdb = lock_ctx->ctdb;
502 if (lock_ctx->ctdb_db) {
504 ("Unable to get %s lock on database %s for %.0lf seconds\n",
505 (lock_ctx->type == LOCK_RECORD ? "RECORD" : "DB"),
506 lock_ctx->ctdb_db->db_name,
507 timeval_elapsed(&lock_ctx->start_time)));
510 ("Unable to get ALLDB locks for %.0lf seconds\n",
511 timeval_elapsed(&lock_ctx->start_time)));
514 /* Fire a child process to find the blocking process. */
515 if (debug_locks == NULL) {
516 debug_locks = getenv("CTDB_DEBUG_LOCKS");
517 if (debug_locks == NULL) {
518 debug_locks = talloc_asprintf(ctdb,
520 getenv("CTDB_BASE"));
523 if (debug_locks != NULL) {
526 execl(debug_locks, debug_locks, NULL);
529 ctdb_track_child(ctdb, pid);
533 " Unable to setup lock debugging - no memory?\n"));
536 /* reset the timeout timer */
537 // talloc_free(lock_ctx->ttimer);
538 lock_ctx->ttimer = tevent_add_timer(ctdb->ev,
540 timeval_current_ofs(10, 0),
541 ctdb_lock_timeout_handler,
546 static int db_count_handler(struct ctdb_db_context *ctdb_db, uint32_t priority,
549 int *count = (int *)private_data;
561 static int db_name_handler(struct ctdb_db_context *ctdb_db, uint32_t priority,
564 struct db_namelist *list = (struct db_namelist *)private_data;
566 list->names[list->n] = talloc_strdup(list->names, ctdb_db->db_path);
572 static char **lock_helper_args(TALLOC_CTX *mem_ctx, struct lock_context *lock_ctx, int fd)
574 struct ctdb_context *ctdb = lock_ctx->ctdb;
578 struct db_namelist list;
580 switch (lock_ctx->type) {
589 case LOCK_ALLDB_PRIO:
591 ctdb_db_iterator(ctdb, lock_ctx->priority, db_count_handler, &nargs);
596 for (priority=1; priority<NUM_DB_PRIORITIES; priority++) {
597 ctdb_db_iterator(ctdb, priority, db_count_handler, &nargs);
602 /* Add extra argument for null termination */
605 args = talloc_array(mem_ctx, char *, nargs);
610 args[0] = talloc_strdup(args, "ctdb_lock_helper");
611 args[1] = talloc_asprintf(args, "%d", getpid());
612 args[2] = talloc_asprintf(args, "%d", fd);
614 switch (lock_ctx->type) {
616 args[3] = talloc_strdup(args, "RECORD");
617 args[4] = talloc_strdup(args, lock_ctx->ctdb_db->db_path);
618 if (lock_ctx->key.dsize == 0) {
619 args[5] = talloc_strdup(args, "NULL");
621 args[5] = hex_encode_talloc(args, lock_ctx->key.dptr, lock_ctx->key.dsize);
626 args[3] = talloc_strdup(args, "DB");
627 args[4] = talloc_strdup(args, lock_ctx->ctdb_db->db_path);
630 case LOCK_ALLDB_PRIO:
631 args[3] = talloc_strdup(args, "DB");
634 ctdb_db_iterator(ctdb, lock_ctx->priority, db_name_handler, &list);
638 args[3] = talloc_strdup(args, "DB");
641 for (priority=1; priority<NUM_DB_PRIORITIES; priority++) {
642 ctdb_db_iterator(ctdb, priority, db_name_handler, &list);
647 /* Make sure last argument is NULL */
648 args[nargs-1] = NULL;
650 for (i=0; i<nargs-1; i++) {
651 if (args[i] == NULL) {
661 * Find a lock request that can be scheduled
663 struct lock_context *ctdb_find_lock_context(struct ctdb_context *ctdb)
665 struct lock_context *lock_ctx, *next_ctx;
666 struct ctdb_db_context *ctdb_db;
668 /* First check if there are database lock requests */
669 lock_ctx = ctdb->lock_pending;
670 while (lock_ctx != NULL) {
671 next_ctx = lock_ctx->next;
672 if (! lock_ctx->request) {
673 DEBUG(DEBUG_INFO, ("Removing lock context without lock request\n"));
674 DLIST_REMOVE(ctdb->lock_pending, lock_ctx);
675 CTDB_DECREMENT_STAT(ctdb, locks.num_pending);
676 if (lock_ctx->ctdb_db) {
677 CTDB_DECREMENT_DB_STAT(lock_ctx->ctdb_db, locks.num_pending);
679 talloc_free(lock_ctx);
681 /* Found a lock context with lock requests */
691 /* Next check database queues */
692 for (ctdb_db = ctdb->db_list; ctdb_db; ctdb_db = ctdb_db->next) {
693 if (ctdb_db->lock_num_current == ctdb->tunable.lock_processes_per_db) {
696 lock_ctx = ctdb_db->lock_pending;
697 while (lock_ctx != NULL) {
698 next_ctx = lock_ctx->next;
699 if (! lock_ctx->request) {
700 DEBUG(DEBUG_INFO, ("Removing lock context without lock request\n"));
701 DLIST_REMOVE(ctdb_db->lock_pending, lock_ctx);
702 CTDB_DECREMENT_STAT(ctdb, locks.num_pending);
703 CTDB_DECREMENT_DB_STAT(ctdb_db, locks.num_pending);
704 talloc_free(lock_ctx);
721 * Schedule a new lock child process
722 * Set up callback handler and timeout handler
724 static void ctdb_lock_schedule(struct ctdb_context *ctdb)
726 struct lock_context *lock_ctx;
729 const char *helper = BINDIR "/ctdb_lock_helper";
730 static const char *prog = NULL;
736 t = getenv("CTDB_LOCK_HELPER");
738 prog = talloc_strdup(ctdb, t);
740 prog = talloc_strdup(ctdb, helper);
742 CTDB_NO_MEMORY_VOID(ctdb, prog);
745 /* Find a lock context with requests */
746 lock_ctx = ctdb_find_lock_context(ctdb);
747 if (lock_ctx == NULL) {
751 lock_ctx->child = -1;
752 ret = pipe(lock_ctx->fd);
754 DEBUG(DEBUG_ERR, ("Failed to create pipe in ctdb_lock_schedule\n"));
758 set_close_on_exec(lock_ctx->fd[0]);
760 /* Create data for child process */
761 tmp_ctx = talloc_new(lock_ctx);
762 if (tmp_ctx == NULL) {
763 DEBUG(DEBUG_ERR, ("Failed to allocate memory for helper args\n"));
764 close(lock_ctx->fd[0]);
765 close(lock_ctx->fd[1]);
769 /* Create arguments for lock helper */
770 args = lock_helper_args(tmp_ctx, lock_ctx, lock_ctx->fd[1]);
772 DEBUG(DEBUG_ERR, ("Failed to create lock helper args\n"));
773 close(lock_ctx->fd[0]);
774 close(lock_ctx->fd[1]);
775 talloc_free(tmp_ctx);
779 lock_ctx->child = vfork();
781 if (lock_ctx->child == (pid_t)-1) {
782 DEBUG(DEBUG_ERR, ("Failed to create a child in ctdb_lock_schedule\n"));
783 close(lock_ctx->fd[0]);
784 close(lock_ctx->fd[1]);
785 talloc_free(tmp_ctx);
791 if (lock_ctx->child == 0) {
792 ret = execv(prog, args);
794 DEBUG(DEBUG_ERR, ("Failed to execute helper %s (%d, %s)\n",
795 prog, errno, strerror(errno)));
801 ctdb_track_child(ctdb, lock_ctx->child);
802 close(lock_ctx->fd[1]);
804 talloc_set_destructor(lock_ctx, ctdb_lock_context_destructor);
806 talloc_free(tmp_ctx);
808 /* Set up timeout handler */
809 lock_ctx->ttimer = tevent_add_timer(ctdb->ev,
811 timeval_current_ofs(10, 0),
812 ctdb_lock_timeout_handler,
814 if (lock_ctx->ttimer == NULL) {
815 ctdb_kill(ctdb, lock_ctx->child, SIGKILL);
816 lock_ctx->child = -1;
817 talloc_set_destructor(lock_ctx, NULL);
818 close(lock_ctx->fd[0]);
822 /* Set up callback */
823 lock_ctx->tfd = tevent_add_fd(ctdb->ev,
829 if (lock_ctx->tfd == NULL) {
830 TALLOC_FREE(lock_ctx->ttimer);
831 ctdb_kill(ctdb, lock_ctx->child, SIGKILL);
832 lock_ctx->child = -1;
833 talloc_set_destructor(lock_ctx, NULL);
834 close(lock_ctx->fd[0]);
837 tevent_fd_set_auto_close(lock_ctx->tfd);
839 /* Move the context from pending to current */
840 if (lock_ctx->type == LOCK_RECORD) {
841 DLIST_REMOVE(lock_ctx->ctdb_db->lock_pending, lock_ctx);
842 DLIST_ADD_END(lock_ctx->ctdb_db->lock_current, lock_ctx, NULL);
844 DLIST_REMOVE(ctdb->lock_pending, lock_ctx);
845 DLIST_ADD_END(ctdb->lock_current, lock_ctx, NULL);
847 CTDB_DECREMENT_STAT(lock_ctx->ctdb, locks.num_pending);
848 CTDB_INCREMENT_STAT(lock_ctx->ctdb, locks.num_current);
849 if (lock_ctx->ctdb_db) {
850 lock_ctx->ctdb_db->lock_num_current++;
851 CTDB_DECREMENT_DB_STAT(lock_ctx->ctdb_db, locks.num_pending);
852 CTDB_INCREMENT_DB_STAT(lock_ctx->ctdb_db, locks.num_current);
858 * Lock record / db depending on type
860 static struct lock_request *ctdb_lock_internal(struct ctdb_context *ctdb,
861 struct ctdb_db_context *ctdb_db,
864 void (*callback)(void *, bool),
869 struct lock_context *lock_ctx = NULL;
870 struct lock_request *request;
872 if (callback == NULL) {
873 DEBUG(DEBUG_WARNING, ("No callback function specified, not locking\n"));
877 lock_ctx = talloc_zero(ctdb, struct lock_context);
878 if (lock_ctx == NULL) {
879 DEBUG(DEBUG_ERR, ("Failed to create a new lock context\n"));
883 if ((request = talloc_zero(lock_ctx, struct lock_request)) == NULL) {
884 talloc_free(lock_ctx);
888 lock_ctx->type = type;
889 lock_ctx->ctdb = ctdb;
890 lock_ctx->ctdb_db = ctdb_db;
891 lock_ctx->key.dsize = key.dsize;
893 lock_ctx->key.dptr = talloc_memdup(lock_ctx, key.dptr, key.dsize);
894 if (lock_ctx->key.dptr == NULL) {
895 DEBUG(DEBUG_ERR, (__location__ "Memory allocation error\n"));
896 talloc_free(lock_ctx);
899 lock_ctx->key_hash = ctdb_hash(&key);
901 lock_ctx->key.dptr = NULL;
903 lock_ctx->priority = priority;
904 lock_ctx->auto_mark = auto_mark;
906 lock_ctx->request = request;
907 lock_ctx->child = -1;
909 /* Non-record locks are required by recovery and should be scheduled
910 * immediately, so keep them at the head of the pending queue.
912 if (lock_ctx->type == LOCK_RECORD) {
913 DLIST_ADD_END(ctdb_db->lock_pending, lock_ctx, NULL);
915 DLIST_ADD_END(ctdb->lock_pending, lock_ctx, NULL);
917 CTDB_INCREMENT_STAT(ctdb, locks.num_pending);
919 CTDB_INCREMENT_DB_STAT(ctdb_db, locks.num_pending);
922 /* Start the timer when we activate the context */
923 lock_ctx->start_time = timeval_current();
925 request->lctx = lock_ctx;
926 request->callback = callback;
927 request->private_data = private_data;
929 talloc_set_destructor(request, ctdb_lock_request_destructor);
931 ctdb_lock_schedule(ctdb);
938 * obtain a lock on a record in a database
940 struct lock_request *ctdb_lock_record(struct ctdb_db_context *ctdb_db,
943 void (*callback)(void *, bool),
946 return ctdb_lock_internal(ctdb_db->ctdb,
958 * obtain a lock on a database
960 struct lock_request *ctdb_lock_db(struct ctdb_db_context *ctdb_db,
962 void (*callback)(void *, bool),
965 return ctdb_lock_internal(ctdb_db->ctdb,
977 * obtain locks on all databases of specified priority
979 struct lock_request *ctdb_lock_alldb_prio(struct ctdb_context *ctdb,
982 void (*callback)(void *, bool),
985 if (priority < 1 || priority > NUM_DB_PRIORITIES) {
986 DEBUG(DEBUG_ERR, ("Invalid db priority: %u\n", priority));
990 return ctdb_lock_internal(ctdb,
1002 * obtain locks on all databases
1004 struct lock_request *ctdb_lock_alldb(struct ctdb_context *ctdb,
1006 void (*callback)(void *, bool),
1009 return ctdb_lock_internal(ctdb,