2 Unix SMB/CIFS implementation.
3 global locks based on dbwrap and messaging
4 Copyright (C) 2009 by Volker Lendecke
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>.
21 #include "system/filesys.h"
22 #include "dbwrap/dbwrap.h"
23 #include "dbwrap/dbwrap_open.h"
24 #include "dbwrap/dbwrap_watch.h"
27 #include "ctdbd_conn.h"
28 #include "../lib/util/select.h"
29 #include "../lib/util/tevent_ntstatus.h"
30 #include "system/select.h"
34 struct db_context *db;
35 struct messaging_context *msg;
39 * The "g_lock.tdb" file contains records, indexed by the 0-terminated
40 * lockname. The record contains an array of "struct g_lock_rec"
45 enum g_lock_type lock_type;
49 struct g_lock_ctx *g_lock_ctx_init(TALLOC_CTX *mem_ctx,
50 struct messaging_context *msg)
52 struct g_lock_ctx *result;
54 result = talloc(mem_ctx, struct g_lock_ctx);
60 result->db = db_open(result, lock_path("g_lock.tdb"), 0,
61 TDB_CLEAR_IF_FIRST|TDB_INCOMPATIBLE_HASH,
64 if (result->db == NULL) {
65 DEBUG(1, ("g_lock_init: Could not open g_lock.tdb\n"));
69 dbwrap_watch_db(result->db, msg);
73 static bool g_lock_conflicts(enum g_lock_type l1, enum g_lock_type l2)
76 * Only tested write locks so far. Very likely this routine
77 * needs to be fixed for read locks....
79 if ((l1 == G_LOCK_READ) && (l2 == G_LOCK_READ)) {
85 static bool g_lock_parse(TALLOC_CTX *mem_ctx, TDB_DATA data,
86 unsigned *pnum_locks, struct g_lock_rec **plocks)
89 struct g_lock_rec *locks;
91 if ((data.dsize % sizeof(struct g_lock_rec)) != 0) {
92 DEBUG(1, ("invalid lock record length %d\n", (int)data.dsize));
95 num_locks = data.dsize / sizeof(struct g_lock_rec);
96 locks = talloc_memdup(mem_ctx, data.dptr, data.dsize);
98 DEBUG(1, ("talloc_memdup failed\n"));
102 *pnum_locks = num_locks;
106 static NTSTATUS g_lock_trylock(struct db_record *rec, struct server_id self,
107 enum g_lock_type type)
110 unsigned i, num_locks;
111 struct g_lock_rec *locks, *tmp;
113 bool modified = false;
115 data = dbwrap_record_get_value(rec);
117 if (!g_lock_parse(talloc_tos(), data, &num_locks, &locks)) {
118 return NT_STATUS_INTERNAL_ERROR;
121 for (i=0; i<num_locks; i++) {
122 if (serverid_equal(&self, &locks[i].pid)) {
123 status = NT_STATUS_INTERNAL_ERROR;
126 if (g_lock_conflicts(type, locks[i].lock_type)) {
128 if (process_exists(locks[i].pid)) {
129 status = NT_STATUS_LOCK_NOT_GRANTED;
134 * Delete stale conflicting entry
136 locks[i] = locks[num_locks-1];
142 tmp = talloc_realloc(talloc_tos(), locks, struct g_lock_rec,
145 status = NT_STATUS_NO_MEMORY;
150 ZERO_STRUCT(locks[num_locks]);
151 locks[num_locks].pid = self;
152 locks[num_locks].lock_type = type;
156 status = NT_STATUS_OK;
159 NTSTATUS store_status;
161 data = make_tdb_data((uint8_t *)locks, num_locks * sizeof(*locks));
162 store_status = dbwrap_record_store(rec, data, 0);
163 if (!NT_STATUS_IS_OK(store_status)) {
164 DEBUG(1, ("rec->store failed: %s\n",
165 nt_errstr(store_status)));
166 status = store_status;
173 struct g_lock_lock_state {
174 struct tevent_context *ev;
175 struct g_lock_ctx *ctx;
177 enum g_lock_type type;
180 static void g_lock_lock_retry(struct tevent_req *subreq);
182 struct tevent_req *g_lock_lock_send(TALLOC_CTX *mem_ctx,
183 struct tevent_context *ev,
184 struct g_lock_ctx *ctx,
186 enum g_lock_type type)
188 struct tevent_req *req, *subreq;
189 struct g_lock_lock_state *state;
190 struct db_record *rec;
191 struct server_id self;
194 req = tevent_req_create(mem_ctx, &state, struct g_lock_lock_state);
203 rec = dbwrap_fetch_locked(ctx->db, talloc_tos(),
204 string_term_tdb_data(state->name));
206 DEBUG(10, ("fetch_locked(\"%s\") failed\n", name));
207 tevent_req_nterror(req, NT_STATUS_LOCK_NOT_GRANTED);
208 return tevent_req_post(req, ev);
211 self = messaging_server_id(state->ctx->msg);
213 status = g_lock_trylock(rec, self, state->type);
214 if (NT_STATUS_IS_OK(status)) {
216 tevent_req_done(req);
217 return tevent_req_post(req, ev);
219 if (!NT_STATUS_EQUAL(status, NT_STATUS_LOCK_NOT_GRANTED)) {
221 tevent_req_nterror(req, status);
222 return tevent_req_post(req, ev);
224 subreq = dbwrap_record_watch_send(state, state->ev, rec,
227 if (tevent_req_nomem(subreq, req)) {
228 return tevent_req_post(req, ev);
230 tevent_req_set_callback(subreq, g_lock_lock_retry, req);
234 static void g_lock_lock_retry(struct tevent_req *subreq)
236 struct tevent_req *req = tevent_req_callback_data(
237 subreq, struct tevent_req);
238 struct g_lock_lock_state *state = tevent_req_data(
239 req, struct g_lock_lock_state);
240 struct server_id self = messaging_server_id(state->ctx->msg);
241 struct db_record *rec;
244 status = dbwrap_record_watch_recv(subreq, talloc_tos(), &rec);
246 if (tevent_req_nterror(req, status)) {
249 status = g_lock_trylock(rec, self, state->type);
250 if (NT_STATUS_IS_OK(status)) {
252 tevent_req_done(req);
255 if (!NT_STATUS_EQUAL(status, NT_STATUS_LOCK_NOT_GRANTED)) {
257 tevent_req_nterror(req, status);
260 subreq = dbwrap_record_watch_send(state, state->ev, rec,
263 if (tevent_req_nomem(subreq, req)) {
266 tevent_req_set_callback(subreq, g_lock_lock_retry, req);
271 NTSTATUS g_lock_lock_recv(struct tevent_req *req)
273 return tevent_req_simple_recv_ntstatus(req);
276 NTSTATUS g_lock_lock(struct g_lock_ctx *ctx, const char *name,
277 enum g_lock_type type, struct timeval timeout)
279 TALLOC_CTX *frame = talloc_stackframe();
280 struct tevent_context *ev;
281 struct tevent_req *req;
283 NTSTATUS status = NT_STATUS_NO_MEMORY;
285 ev = tevent_context_init(frame);
289 req = g_lock_lock_send(frame, ev, ctx, name, type);
293 end = timeval_current_ofs(timeout.tv_sec, timeout.tv_usec);
294 if (!tevent_req_set_endtime(req, ev, end)) {
297 if (!tevent_req_poll_ntstatus(req, ev, &status)) {
300 status = g_lock_lock_recv(req);
306 NTSTATUS g_lock_unlock(struct g_lock_ctx *ctx, const char *name)
308 struct server_id self = messaging_server_id(ctx->msg);
309 struct db_record *rec = NULL;
310 struct g_lock_rec *locks = NULL;
311 unsigned i, num_locks;
315 rec = dbwrap_fetch_locked(ctx->db, talloc_tos(),
316 string_term_tdb_data(name));
318 DEBUG(10, ("fetch_locked(\"%s\") failed\n", name));
319 status = NT_STATUS_INTERNAL_ERROR;
323 value = dbwrap_record_get_value(rec);
325 if (!g_lock_parse(talloc_tos(), value, &num_locks, &locks)) {
326 DEBUG(10, ("g_lock_parse for %s failed\n", name));
327 status = NT_STATUS_FILE_INVALID;
330 for (i=0; i<num_locks; i++) {
331 if (serverid_equal(&self, &locks[i].pid)) {
335 if (i == num_locks) {
336 DEBUG(10, ("g_lock_force_unlock: Lock not found\n"));
337 status = NT_STATUS_NOT_FOUND;
341 locks[i] = locks[num_locks-1];
344 if (num_locks == 0) {
345 status = dbwrap_record_delete(rec);
348 data = make_tdb_data((uint8_t *)locks,
349 sizeof(struct g_lock_rec) * num_locks);
350 status = dbwrap_record_store(rec, data, 0);
352 if (!NT_STATUS_IS_OK(status)) {
353 DEBUG(1, ("g_lock_force_unlock: Could not store record: %s\n",
358 status = NT_STATUS_OK;
365 struct g_lock_locks_state {
366 int (*fn)(const char *name, void *private_data);
370 static int g_lock_locks_fn(struct db_record *rec, void *priv)
373 struct g_lock_locks_state *state = (struct g_lock_locks_state *)priv;
375 key = dbwrap_record_get_key(rec);
376 if ((key.dsize == 0) || (key.dptr[key.dsize-1] != 0)) {
377 DEBUG(1, ("invalid key in g_lock.tdb, ignoring\n"));
380 return state->fn((char *)key.dptr, state->private_data);
383 int g_lock_locks(struct g_lock_ctx *ctx,
384 int (*fn)(const char *name, void *private_data),
387 struct g_lock_locks_state state;
392 state.private_data = private_data;
394 status = dbwrap_traverse_read(ctx->db, g_lock_locks_fn, &state, &count);
395 if (!NT_STATUS_IS_OK(status)) {
402 NTSTATUS g_lock_dump(struct g_lock_ctx *ctx, const char *name,
403 int (*fn)(struct server_id pid,
404 enum g_lock_type lock_type,
409 unsigned i, num_locks;
410 struct g_lock_rec *locks = NULL;
414 status = dbwrap_fetch_bystring(ctx->db, talloc_tos(), name, &data);
415 if (!NT_STATUS_IS_OK(status)) {
419 if ((data.dsize == 0) || (data.dptr == NULL)) {
423 ret = g_lock_parse(talloc_tos(), data, &num_locks, &locks);
425 TALLOC_FREE(data.dptr);
428 DEBUG(10, ("g_lock_parse for %s failed\n", name));
429 return NT_STATUS_INTERNAL_ERROR;
432 for (i=0; i<num_locks; i++) {
433 if (fn(locks[i].pid, locks[i].lock_type, private_data) != 0) {
441 struct g_lock_get_state {
443 struct server_id *pid;
446 static int g_lock_get_fn(struct server_id pid, enum g_lock_type lock_type,
449 struct g_lock_get_state *state = (struct g_lock_get_state *)priv;
455 NTSTATUS g_lock_get(struct g_lock_ctx *ctx, const char *name,
456 struct server_id *pid)
458 struct g_lock_get_state state;
464 status = g_lock_dump(ctx, name, g_lock_get_fn, &state);
465 if (!NT_STATUS_IS_OK(status)) {
469 return NT_STATUS_NOT_FOUND;
474 static bool g_lock_init_all(TALLOC_CTX *mem_ctx,
475 struct tevent_context **pev,
476 struct messaging_context **pmsg,
477 struct g_lock_ctx **pg_ctx)
479 struct tevent_context *ev = NULL;
480 struct messaging_context *msg = NULL;
481 struct g_lock_ctx *g_ctx = NULL;
483 ev = tevent_context_init(mem_ctx);
485 d_fprintf(stderr, "ERROR: could not init event context\n");
488 msg = messaging_init(mem_ctx, ev);
490 d_fprintf(stderr, "ERROR: could not init messaging context\n");
493 g_ctx = g_lock_ctx_init(mem_ctx, msg);
495 d_fprintf(stderr, "ERROR: could not init g_lock context\n");
510 NTSTATUS g_lock_do(const char *name, enum g_lock_type lock_type,
511 struct timeval timeout,
512 void (*fn)(void *private_data), void *private_data)
514 struct tevent_context *ev = NULL;
515 struct messaging_context *msg = NULL;
516 struct g_lock_ctx *g_ctx = NULL;
519 if (!g_lock_init_all(talloc_tos(), &ev, &msg, &g_ctx)) {
520 status = NT_STATUS_ACCESS_DENIED;
524 status = g_lock_lock(g_ctx, name, lock_type, timeout);
525 if (!NT_STATUS_IS_OK(status)) {
529 g_lock_unlock(g_ctx, name);