#include "system/filesys.h"
#include "dbwrap/dbwrap.h"
#include "dbwrap/dbwrap_open.h"
+#include "dbwrap/dbwrap_watch.h"
#include "g_lock.h"
#include "util_tdb.h"
#include "ctdbd_conn.h"
#include "../lib/util/select.h"
+#include "../lib/util/tevent_ntstatus.h"
#include "system/select.h"
#include "messages.h"
-
-static NTSTATUS g_lock_force_unlock(struct g_lock_ctx *ctx, const char *name,
- struct server_id pid);
+#include "serverid.h"
struct g_lock_ctx {
struct db_context *db;
/*
* The "g_lock.tdb" file contains records, indexed by the 0-terminated
* lockname. The record contains an array of "struct g_lock_rec"
- * structures. Waiters have the lock_type with G_LOCK_PENDING or'ed.
+ * structures.
*/
struct g_lock_rec {
result->db = db_open(result, lock_path("g_lock.tdb"), 0,
TDB_CLEAR_IF_FIRST|TDB_INCOMPATIBLE_HASH,
- O_RDWR|O_CREAT, 0600);
+ O_RDWR|O_CREAT, 0600,
+ DBWRAP_LOCK_ORDER_2);
if (result->db == NULL) {
DEBUG(1, ("g_lock_init: Could not open g_lock.tdb\n"));
TALLOC_FREE(result);
return NULL;
}
+ dbwrap_watch_db(result->db, msg);
return result;
}
-static bool g_lock_conflicts(enum g_lock_type lock_type,
- const struct g_lock_rec *rec)
+static bool g_lock_conflicts(enum g_lock_type l1, enum g_lock_type l2)
{
- enum g_lock_type rec_lock = rec->lock_type;
-
- if ((rec_lock & G_LOCK_PENDING) != 0) {
- return false;
- }
-
/*
* Only tested write locks so far. Very likely this routine
* needs to be fixed for read locks....
*/
- if ((lock_type == G_LOCK_READ) && (rec_lock == G_LOCK_READ)) {
+ if ((l1 == G_LOCK_READ) && (l2 == G_LOCK_READ)) {
return false;
}
return true;
}
static bool g_lock_parse(TALLOC_CTX *mem_ctx, TDB_DATA data,
- int *pnum_locks, struct g_lock_rec **plocks)
+ unsigned *pnum_locks, struct g_lock_rec **plocks)
{
- int i, num_locks;
+ unsigned num_locks;
struct g_lock_rec *locks;
if ((data.dsize % sizeof(struct g_lock_rec)) != 0) {
DEBUG(1, ("invalid lock record length %d\n", (int)data.dsize));
return false;
}
-
num_locks = data.dsize / sizeof(struct g_lock_rec);
- locks = talloc_array(mem_ctx, struct g_lock_rec, num_locks);
+ locks = talloc_memdup(mem_ctx, data.dptr, data.dsize);
if (locks == NULL) {
- DEBUG(1, ("talloc failed\n"));
+ DEBUG(1, ("talloc_memdup failed\n"));
return false;
}
-
- memcpy(locks, data.dptr, data.dsize);
-
- DEBUG(10, ("locks:\n"));
- for (i=0; i<num_locks; i++) {
- DEBUGADD(10, ("%s: %s %s\n",
- server_id_str(talloc_tos(), &locks[i].pid),
- ((locks[i].lock_type & 1) == G_LOCK_READ) ?
- "read" : "write",
- (locks[i].lock_type & G_LOCK_PENDING) ?
- "(pending)" : "(owner)"));
-
- if (((locks[i].lock_type & G_LOCK_PENDING) == 0)
- && !process_exists(locks[i].pid)) {
-
- DEBUGADD(10, ("lock owner %s died -- discarding\n",
- server_id_str(talloc_tos(),
- &locks[i].pid)));
-
- if (i < (num_locks-1)) {
- locks[i] = locks[num_locks-1];
- }
- num_locks -= 1;
- }
- }
-
*plocks = locks;
*pnum_locks = num_locks;
return true;
}
-static void g_lock_cleanup(int *pnum_locks, struct g_lock_rec *locks)
+static NTSTATUS g_lock_trylock(struct db_record *rec, struct server_id self,
+ enum g_lock_type type)
{
- int i, num_locks;
+ TDB_DATA data;
+ unsigned i, num_locks;
+ struct g_lock_rec *locks, *tmp;
+ NTSTATUS status;
+ bool modified = false;
- num_locks = *pnum_locks;
+ data = dbwrap_record_get_value(rec);
- DEBUG(10, ("g_lock_cleanup: %d locks\n", num_locks));
+ if (!g_lock_parse(talloc_tos(), data, &num_locks, &locks)) {
+ return NT_STATUS_INTERNAL_ERROR;
+ }
for (i=0; i<num_locks; i++) {
- if (process_exists(locks[i].pid)) {
- continue;
+ if (serverid_equal(&self, &locks[i].pid)) {
+ status = NT_STATUS_INTERNAL_ERROR;
+ goto done;
}
- DEBUGADD(10, ("%s does not exist -- discarding\n",
- server_id_str(talloc_tos(), &locks[i].pid)));
+ if (g_lock_conflicts(type, locks[i].lock_type)) {
+ struct server_id pid = locks[i].pid;
+
+ /*
+ * As the serverid_exists might recurse into
+ * the g_lock code, we use
+ * SERVERID_UNIQUE_ID_NOT_TO_VERIFY to avoid the loop
+ */
+ pid.unique_id = SERVERID_UNIQUE_ID_NOT_TO_VERIFY;
+
+ if (serverid_exists(&pid)) {
+ status = NT_STATUS_LOCK_NOT_GRANTED;
+ goto done;
+ }
- if (i < (num_locks-1)) {
+ /*
+ * Delete stale conflicting entry
+ */
locks[i] = locks[num_locks-1];
+ num_locks -= 1;
+ modified = true;
}
- num_locks -= 1;
}
- *pnum_locks = num_locks;
- return;
-}
-static struct g_lock_rec *g_lock_addrec(TALLOC_CTX *mem_ctx,
- struct g_lock_rec *locks,
- int *pnum_locks,
- const struct server_id pid,
- enum g_lock_type lock_type)
-{
- struct g_lock_rec *result;
- int num_locks = *pnum_locks;
-
- result = talloc_realloc(mem_ctx, locks, struct g_lock_rec,
- num_locks+1);
- if (result == NULL) {
- return NULL;
+ tmp = talloc_realloc(talloc_tos(), locks, struct g_lock_rec,
+ num_locks+1);
+ if (tmp == NULL) {
+ status = NT_STATUS_NO_MEMORY;
+ goto done;
}
+ locks = tmp;
- result[num_locks].pid = pid;
- result[num_locks].lock_type = lock_type;
- *pnum_locks += 1;
- return result;
+ ZERO_STRUCT(locks[num_locks]);
+ locks[num_locks].pid = self;
+ locks[num_locks].lock_type = type;
+ num_locks += 1;
+ modified = true;
+
+ status = NT_STATUS_OK;
+done:
+ if (modified) {
+ NTSTATUS store_status;
+
+ data = make_tdb_data((uint8_t *)locks, num_locks * sizeof(*locks));
+ store_status = dbwrap_record_store(rec, data, 0);
+ if (!NT_STATUS_IS_OK(store_status)) {
+ DEBUG(1, ("rec->store failed: %s\n",
+ nt_errstr(store_status)));
+ status = store_status;
+ }
+ }
+ TALLOC_FREE(locks);
+ return status;
}
-static void g_lock_got_retry(struct messaging_context *msg,
- void *private_data,
- uint32_t msg_type,
- struct server_id server_id,
- DATA_BLOB *data);
+struct g_lock_lock_state {
+ struct tevent_context *ev;
+ struct g_lock_ctx *ctx;
+ const char *name;
+ enum g_lock_type type;
+};
+
+static void g_lock_lock_retry(struct tevent_req *subreq);
-static NTSTATUS g_lock_trylock(struct g_lock_ctx *ctx, const char *name,
- enum g_lock_type lock_type)
+struct tevent_req *g_lock_lock_send(TALLOC_CTX *mem_ctx,
+ struct tevent_context *ev,
+ struct g_lock_ctx *ctx,
+ const char *name,
+ enum g_lock_type type)
{
- struct db_record *rec = NULL;
- struct g_lock_rec *locks = NULL;
- int i, num_locks;
+ struct tevent_req *req, *subreq;
+ struct g_lock_lock_state *state;
+ struct db_record *rec;
struct server_id self;
- int our_index;
- TDB_DATA data;
- NTSTATUS status = NT_STATUS_OK;
- NTSTATUS store_status;
- TDB_DATA value;
+ NTSTATUS status;
+
+ req = tevent_req_create(mem_ctx, &state, struct g_lock_lock_state);
+ if (req == NULL) {
+ return NULL;
+ }
+ state->ev = ev;
+ state->ctx = ctx;
+ state->name = name;
+ state->type = type;
-again:
rec = dbwrap_fetch_locked(ctx->db, talloc_tos(),
- string_term_tdb_data(name));
+ string_term_tdb_data(state->name));
if (rec == NULL) {
DEBUG(10, ("fetch_locked(\"%s\") failed\n", name));
- status = NT_STATUS_LOCK_NOT_GRANTED;
- goto done;
- }
-
- value = dbwrap_record_get_value(rec);
- if (!g_lock_parse(talloc_tos(), value, &num_locks, &locks)) {
- DEBUG(10, ("g_lock_parse for %s failed\n", name));
- status = NT_STATUS_INTERNAL_ERROR;
- goto done;
- }
-
- self = messaging_server_id(ctx->msg);
- our_index = -1;
-
- for (i=0; i<num_locks; i++) {
- if (procid_equal(&self, &locks[i].pid)) {
- if (our_index != -1) {
- DEBUG(1, ("g_lock_trylock: Added ourself "
- "twice!\n"));
- status = NT_STATUS_INTERNAL_ERROR;
- goto done;
- }
- if ((locks[i].lock_type & G_LOCK_PENDING) == 0) {
- DEBUG(1, ("g_lock_trylock: Found ourself not "
- "pending!\n"));
- status = NT_STATUS_INTERNAL_ERROR;
- goto done;
- }
-
- our_index = i;
-
- /* never conflict with ourself */
- continue;
- }
- if (g_lock_conflicts(lock_type, &locks[i])) {
- struct server_id pid = locks[i].pid;
-
- if (!process_exists(pid)) {
- TALLOC_FREE(locks);
- TALLOC_FREE(rec);
- status = g_lock_force_unlock(ctx, name, pid);
- if (!NT_STATUS_IS_OK(status)) {
- DEBUG(1, ("Could not unlock dead lock "
- "holder!\n"));
- goto done;
- }
- goto again;
- }
- lock_type |= G_LOCK_PENDING;
- }
+ tevent_req_nterror(req, NT_STATUS_LOCK_NOT_GRANTED);
+ return tevent_req_post(req, ev);
}
- if (our_index == -1) {
- /* First round, add ourself */
+ self = messaging_server_id(state->ctx->msg);
- locks = g_lock_addrec(talloc_tos(), locks, &num_locks,
- self, lock_type);
- if (locks == NULL) {
- DEBUG(10, ("g_lock_addrec failed\n"));
- status = NT_STATUS_NO_MEMORY;
- goto done;
- }
- } else {
- /*
- * Retry. We were pending last time. Overwrite the
- * stored lock_type with what we calculated, we might
- * have acquired the lock this time.
- */
- locks[our_index].lock_type = lock_type;
- }
-
- if (NT_STATUS_IS_OK(status) && ((lock_type & G_LOCK_PENDING) == 0)) {
- /*
- * Walk through the list of locks, search for dead entries
- */
- g_lock_cleanup(&num_locks, locks);
+ status = g_lock_trylock(rec, self, state->type);
+ if (NT_STATUS_IS_OK(status)) {
+ TALLOC_FREE(rec);
+ tevent_req_done(req);
+ return tevent_req_post(req, ev);
}
-
- data = make_tdb_data((uint8_t *)locks, num_locks * sizeof(*locks));
- store_status = dbwrap_record_store(rec, data, 0);
- if (!NT_STATUS_IS_OK(store_status)) {
- DEBUG(1, ("rec->store failed: %s\n",
- nt_errstr(store_status)));
- status = store_status;
+ if (!NT_STATUS_EQUAL(status, NT_STATUS_LOCK_NOT_GRANTED)) {
+ TALLOC_FREE(rec);
+ tevent_req_nterror(req, status);
+ return tevent_req_post(req, ev);
}
-
-done:
- TALLOC_FREE(locks);
+ subreq = dbwrap_record_watch_send(state, state->ev, rec,
+ state->ctx->msg);
TALLOC_FREE(rec);
-
- if (NT_STATUS_IS_OK(status) && (lock_type & G_LOCK_PENDING) != 0) {
- return STATUS_PENDING;
+ if (tevent_req_nomem(subreq, req)) {
+ return tevent_req_post(req, ev);
}
-
- return NT_STATUS_OK;
+ if (!tevent_req_set_endtime(
+ subreq, state->ev,
+ timeval_current_ofs(5 + sys_random() % 5, 0))) {
+ tevent_req_oom(req);
+ return tevent_req_post(req, ev);
+ }
+ tevent_req_set_callback(subreq, g_lock_lock_retry, req);
+ return req;
}
-NTSTATUS g_lock_lock(struct g_lock_ctx *ctx, const char *name,
- enum g_lock_type lock_type, struct timeval timeout)
+static void g_lock_lock_retry(struct tevent_req *subreq)
{
- struct tevent_timer *te = NULL;
+ struct tevent_req *req = tevent_req_callback_data(
+ subreq, struct tevent_req);
+ struct g_lock_lock_state *state = tevent_req_data(
+ req, struct g_lock_lock_state);
+ struct server_id self = messaging_server_id(state->ctx->msg);
+ struct db_record *rec;
NTSTATUS status;
- bool retry = false;
- struct timeval timeout_end;
- struct timeval time_now;
-
- DEBUG(10, ("Trying to acquire lock %d for %s\n", (int)lock_type,
- name));
- if (lock_type & ~1) {
- DEBUG(1, ("Got invalid lock type %d for %s\n",
- (int)lock_type, name));
- return NT_STATUS_INVALID_PARAMETER;
- }
-
-#ifdef CLUSTER_SUPPORT
- if (lp_clustering()) {
- status = ctdb_watch_us(messaging_ctdbd_connection());
- if (!NT_STATUS_IS_OK(status)) {
- DEBUG(10, ("could not register retry with ctdb: %s\n",
- nt_errstr(status)));
- goto done;
+ status = dbwrap_record_watch_recv(subreq, talloc_tos(), &rec);
+ TALLOC_FREE(subreq);
+
+ if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
+ rec = dbwrap_fetch_locked(
+ state->ctx->db, talloc_tos(),
+ string_term_tdb_data(state->name));
+ if (rec == NULL) {
+ status = map_nt_error_from_unix(errno);
+ } else {
+ status = NT_STATUS_OK;
}
}
-#endif
- status = messaging_register(ctx->msg, &retry, MSG_DBWRAP_G_LOCK_RETRY,
- g_lock_got_retry);
- if (!NT_STATUS_IS_OK(status)) {
- DEBUG(10, ("messaging_register failed: %s\n",
- nt_errstr(status)));
- return status;
+ if (tevent_req_nterror(req, status)) {
+ return;
}
-
- time_now = timeval_current();
- timeout_end = timeval_sum(&time_now, &timeout);
-
- while (true) {
- struct pollfd *pollfds;
- int num_pollfds;
- int saved_errno;
- int ret;
- struct timeval timeout_remaining, select_timeout;
-
- status = g_lock_trylock(ctx, name, lock_type);
- if (NT_STATUS_IS_OK(status)) {
- DEBUG(10, ("Got lock %s\n", name));
- break;
- }
- if (!NT_STATUS_EQUAL(status, STATUS_PENDING)) {
- DEBUG(10, ("g_lock_trylock failed: %s\n",
- nt_errstr(status)));
- break;
- }
-
- DEBUG(10, ("g_lock_trylock: Did not get lock, waiting...\n"));
-
- /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- * !!! HACK ALERT --- FIX ME !!!
- * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- * What we really want to do here is to react to
- * MSG_DBWRAP_G_LOCK_RETRY messages that are either sent
- * by a client doing g_lock_unlock or by ourselves when
- * we receive a CTDB_SRVID_SAMBA_NOTIFY or
- * CTDB_SRVID_RECONFIGURE message from ctdbd, i.e. when
- * either a client holding a lock or a complete node
- * has died.
- *
- * Doing this properly involves calling tevent_loop_once(),
- * but doing this here with the main ctdbd messaging context
- * creates a nested event loop when g_lock_lock() is called
- * from the main event loop, e.g. in a tcon_and_X where the
- * share_info.tdb needs to be initialized and is locked by
- * another process, or when the remore registry is accessed
- * for writing and some other process already holds a lock
- * on the registry.tdb.
- *
- * So as a quick fix, we act a little coarsely here: we do
- * a select on the ctdb connection fd and when it is readable
- * or we get EINTR, then we retry without actually parsing
- * any ctdb packages or dispatching messages. This means that
- * we retry more often than intended by design, but this does
- * not harm and it is unobtrusive. When we have finished,
- * the main loop will pick up all the messages and ctdb
- * packets. The only extra twist is that we cannot use timed
- * events here but have to handcode a timeout.
- */
-
- /*
- * We allocate 2 entries here. One is needed anyway for
- * sys_poll and in the clustering case we might have to add
- * the ctdb fd. This avoids the realloc then.
- */
- pollfds = talloc_array(talloc_tos(), struct pollfd, 2);
- if (pollfds == NULL) {
- status = NT_STATUS_NO_MEMORY;
- break;
- }
- num_pollfds = 0;
-
-#ifdef CLUSTER_SUPPORT
- if (lp_clustering()) {
- struct ctdbd_connection *conn;
- conn = messaging_ctdbd_connection();
-
- pollfds[0].fd = ctdbd_conn_get_fd(conn);
- pollfds[0].events = POLLIN|POLLHUP;
-
- num_pollfds += 1;
- }
-#endif
-
- time_now = timeval_current();
- timeout_remaining = timeval_until(&time_now, &timeout_end);
- select_timeout = timeval_set(60, 0);
-
- select_timeout = timeval_min(&select_timeout,
- &timeout_remaining);
-
- ret = sys_poll(pollfds, num_pollfds,
- timeval_to_msec(select_timeout));
-
- /*
- * We're not *really interested in the actual flags. We just
- * need to retry this whole thing.
- */
- saved_errno = errno;
- TALLOC_FREE(pollfds);
- errno = saved_errno;
-
- if (ret == -1) {
- if (errno != EINTR) {
- DEBUG(1, ("error calling select: %s\n",
- strerror(errno)));
- status = NT_STATUS_INTERNAL_ERROR;
- break;
- }
- /*
- * errno == EINTR:
- * This means a signal was received.
- * It might have been a MSG_DBWRAP_G_LOCK_RETRY message.
- * ==> retry
- */
- } else if (ret == 0) {
- if (timeval_expired(&timeout_end)) {
- DEBUG(10, ("g_lock_lock timed out\n"));
- status = NT_STATUS_LOCK_NOT_GRANTED;
- break;
- } else {
- DEBUG(10, ("select returned 0 but timeout not "
- "not expired, retrying\n"));
- }
- } else if (ret != 1) {
- DEBUG(1, ("invalid return code of select: %d\n", ret));
- status = NT_STATUS_INTERNAL_ERROR;
- break;
- }
- /*
- * ret == 1:
- * This means ctdbd has sent us some data.
- * Might be a CTDB_SRVID_RECONFIGURE or a
- * CTDB_SRVID_SAMBA_NOTIFY message.
- * ==> retry
- */
+ status = g_lock_trylock(rec, self, state->type);
+ if (NT_STATUS_IS_OK(status)) {
+ TALLOC_FREE(rec);
+ tevent_req_done(req);
+ return;
}
-
-#ifdef CLUSTER_SUPPORT
-done:
-#endif
-
- if (!NT_STATUS_IS_OK(status)) {
- NTSTATUS unlock_status;
-
- unlock_status = g_lock_unlock(ctx, name);
-
- if (!NT_STATUS_IS_OK(unlock_status)) {
- DEBUG(1, ("Could not remove ourself from the locking "
- "db: %s\n", nt_errstr(status)));
- }
+ if (!NT_STATUS_EQUAL(status, NT_STATUS_LOCK_NOT_GRANTED)) {
+ TALLOC_FREE(rec);
+ tevent_req_nterror(req, status);
+ return;
}
+ subreq = dbwrap_record_watch_send(state, state->ev, rec,
+ state->ctx->msg);
+ TALLOC_FREE(rec);
+ if (tevent_req_nomem(subreq, req)) {
+ return;
+ }
+ if (!tevent_req_set_endtime(
+ subreq, state->ev,
+ timeval_current_ofs(5 + sys_random() % 5, 0))) {
+ tevent_req_oom(req);
+ return;
+ }
+ tevent_req_set_callback(subreq, g_lock_lock_retry, req);
+ return;
- messaging_deregister(ctx->msg, MSG_DBWRAP_G_LOCK_RETRY, &retry);
- TALLOC_FREE(te);
-
- return status;
}
-static void g_lock_got_retry(struct messaging_context *msg,
- void *private_data,
- uint32_t msg_type,
- struct server_id server_id,
- DATA_BLOB *data)
+NTSTATUS g_lock_lock_recv(struct tevent_req *req)
{
- bool *pretry = (bool *)private_data;
+ return tevent_req_simple_recv_ntstatus(req);
+}
- DEBUG(10, ("Got retry message from pid %s\n",
- server_id_str(talloc_tos(), &server_id)));
+NTSTATUS g_lock_lock(struct g_lock_ctx *ctx, const char *name,
+ enum g_lock_type type, struct timeval timeout)
+{
+ TALLOC_CTX *frame = talloc_stackframe();
+ struct tevent_context *ev;
+ struct tevent_req *req;
+ struct timeval end;
+ NTSTATUS status = NT_STATUS_NO_MEMORY;
- *pretry = true;
+ ev = tevent_context_init(frame);
+ if (ev == NULL) {
+ goto fail;
+ }
+ req = g_lock_lock_send(frame, ev, ctx, name, type);
+ if (req == NULL) {
+ goto fail;
+ }
+ end = timeval_current_ofs(timeout.tv_sec, timeout.tv_usec);
+ if (!tevent_req_set_endtime(req, ev, end)) {
+ goto fail;
+ }
+ if (!tevent_req_poll_ntstatus(req, ev, &status)) {
+ goto fail;
+ }
+ status = g_lock_lock_recv(req);
+ fail:
+ TALLOC_FREE(frame);
+ return status;
}
-static NTSTATUS g_lock_force_unlock(struct g_lock_ctx *ctx, const char *name,
- struct server_id pid)
+NTSTATUS g_lock_unlock(struct g_lock_ctx *ctx, const char *name)
{
+ struct server_id self = messaging_server_id(ctx->msg);
struct db_record *rec = NULL;
struct g_lock_rec *locks = NULL;
- int i, num_locks;
- enum g_lock_type lock_type;
+ unsigned i, num_locks;
NTSTATUS status;
TDB_DATA value;
status = NT_STATUS_FILE_INVALID;
goto done;
}
-
for (i=0; i<num_locks; i++) {
- if (procid_equal(&pid, &locks[i].pid)) {
+ if (serverid_equal(&self, &locks[i].pid)) {
break;
}
}
-
if (i == num_locks) {
DEBUG(10, ("g_lock_force_unlock: Lock not found\n"));
status = NT_STATUS_NOT_FOUND;
goto done;
}
- lock_type = locks[i].lock_type;
-
- if (i < (num_locks-1)) {
- locks[i] = locks[num_locks-1];
- }
+ locks[i] = locks[num_locks-1];
num_locks -= 1;
if (num_locks == 0) {
sizeof(struct g_lock_rec) * num_locks);
status = dbwrap_record_store(rec, data, 0);
}
-
if (!NT_STATUS_IS_OK(status)) {
DEBUG(1, ("g_lock_force_unlock: Could not store record: %s\n",
nt_errstr(status)));
goto done;
}
- TALLOC_FREE(rec);
-
- if ((lock_type & G_LOCK_PENDING) == 0) {
- int num_wakeups = 0;
-
- /*
- * We've been the lock holder. Others to retry. Don't
- * tell all others to avoid a thundering herd. In case
- * this leads to a complete stall because we miss some
- * processes, the loop in g_lock_lock tries at least
- * once a minute.
- */
-
- for (i=0; i<num_locks; i++) {
- if ((locks[i].lock_type & G_LOCK_PENDING) == 0) {
- continue;
- }
- if (!process_exists(locks[i].pid)) {
- continue;
- }
-
- /*
- * Ping all waiters to retry
- */
- status = messaging_send(ctx->msg, locks[i].pid,
- MSG_DBWRAP_G_LOCK_RETRY,
- &data_blob_null);
- if (!NT_STATUS_IS_OK(status)) {
- DEBUG(1, ("sending retry to %s failed: %s\n",
- server_id_str(talloc_tos(),
- &locks[i].pid),
- nt_errstr(status)));
- } else {
- num_wakeups += 1;
- }
- if (num_wakeups > 5) {
- break;
- }
- }
- }
+ status = NT_STATUS_OK;
done:
- /*
- * For the error path, TALLOC_FREE(rec) as well. In the good
- * path we have already freed it.
- */
TALLOC_FREE(rec);
-
TALLOC_FREE(locks);
return status;
}
-NTSTATUS g_lock_unlock(struct g_lock_ctx *ctx, const char *name)
-{
- NTSTATUS status;
-
- status = g_lock_force_unlock(ctx, name, messaging_server_id(ctx->msg));
-
-#ifdef CLUSTER_SUPPORT
- if (lp_clustering()) {
- ctdb_unwatch(messaging_ctdbd_connection());
- }
-#endif
- return status;
-}
-
struct g_lock_locks_state {
int (*fn)(const char *name, void *private_data);
void *private_data;
void *private_data)
{
TDB_DATA data;
- int i, num_locks;
+ unsigned i, num_locks;
struct g_lock_rec *locks = NULL;
bool ret;
NTSTATUS status;
void *priv)
{
struct g_lock_get_state *state = (struct g_lock_get_state *)priv;
-
- if ((lock_type & G_LOCK_PENDING) != 0) {
- return 0;
- }
-
state->found = true;
*state->pid = pid;
return 1;
git.samba.org / kai / samba.git / blobdiff