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
,
262 if (tevent_req_nomem(subreq
, req
)) {
265 tevent_req_set_callback(subreq
, g_lock_lock_retry
, req
);
270 NTSTATUS
g_lock_lock_recv(struct tevent_req
*req
)
272 return tevent_req_simple_recv_ntstatus(req
);
275 NTSTATUS
g_lock_lock(struct g_lock_ctx
*ctx
, const char *name
,
276 enum g_lock_type type
, struct timeval timeout
)
278 TALLOC_CTX
*frame
= talloc_stackframe();
279 struct tevent_context
*ev
;
280 struct tevent_req
*req
;
282 NTSTATUS status
= NT_STATUS_NO_MEMORY
;
284 ev
= tevent_context_init(frame
);
288 req
= g_lock_lock_send(frame
, ev
, ctx
, name
, type
);
292 end
= timeval_current_ofs(timeout
.tv_sec
, timeout
.tv_usec
);
293 if (!tevent_req_set_endtime(req
, ev
, end
)) {
296 if (!tevent_req_poll_ntstatus(req
, ev
, &status
)) {
299 status
= g_lock_lock_recv(req
);
305 NTSTATUS
g_lock_unlock(struct g_lock_ctx
*ctx
, const char *name
)
307 struct server_id self
= messaging_server_id(ctx
->msg
);
308 struct db_record
*rec
= NULL
;
309 struct g_lock_rec
*locks
= NULL
;
310 unsigned i
, num_locks
;
314 rec
= dbwrap_fetch_locked(ctx
->db
, talloc_tos(),
315 string_term_tdb_data(name
));
317 DEBUG(10, ("fetch_locked(\"%s\") failed\n", name
));
318 status
= NT_STATUS_INTERNAL_ERROR
;
322 value
= dbwrap_record_get_value(rec
);
324 if (!g_lock_parse(talloc_tos(), value
, &num_locks
, &locks
)) {
325 DEBUG(10, ("g_lock_parse for %s failed\n", name
));
326 status
= NT_STATUS_FILE_INVALID
;
329 for (i
=0; i
<num_locks
; i
++) {
330 if (serverid_equal(&self
, &locks
[i
].pid
)) {
334 if (i
== num_locks
) {
335 DEBUG(10, ("g_lock_force_unlock: Lock not found\n"));
336 status
= NT_STATUS_NOT_FOUND
;
340 locks
[i
] = locks
[num_locks
-1];
343 if (num_locks
== 0) {
344 status
= dbwrap_record_delete(rec
);
347 data
= make_tdb_data((uint8_t *)locks
,
348 sizeof(struct g_lock_rec
) * num_locks
);
349 status
= dbwrap_record_store(rec
, data
, 0);
351 if (!NT_STATUS_IS_OK(status
)) {
352 DEBUG(1, ("g_lock_force_unlock: Could not store record: %s\n",
357 status
= NT_STATUS_OK
;
364 struct g_lock_locks_state
{
365 int (*fn
)(const char *name
, void *private_data
);
369 static int g_lock_locks_fn(struct db_record
*rec
, void *priv
)
372 struct g_lock_locks_state
*state
= (struct g_lock_locks_state
*)priv
;
374 key
= dbwrap_record_get_key(rec
);
375 if ((key
.dsize
== 0) || (key
.dptr
[key
.dsize
-1] != 0)) {
376 DEBUG(1, ("invalid key in g_lock.tdb, ignoring\n"));
379 return state
->fn((char *)key
.dptr
, state
->private_data
);
382 int g_lock_locks(struct g_lock_ctx
*ctx
,
383 int (*fn
)(const char *name
, void *private_data
),
386 struct g_lock_locks_state state
;
391 state
.private_data
= private_data
;
393 status
= dbwrap_traverse_read(ctx
->db
, g_lock_locks_fn
, &state
, &count
);
394 if (!NT_STATUS_IS_OK(status
)) {
401 NTSTATUS
g_lock_dump(struct g_lock_ctx
*ctx
, const char *name
,
402 int (*fn
)(struct server_id pid
,
403 enum g_lock_type lock_type
,
408 unsigned i
, num_locks
;
409 struct g_lock_rec
*locks
= NULL
;
413 status
= dbwrap_fetch_bystring(ctx
->db
, talloc_tos(), name
, &data
);
414 if (!NT_STATUS_IS_OK(status
)) {
418 if ((data
.dsize
== 0) || (data
.dptr
== NULL
)) {
422 ret
= g_lock_parse(talloc_tos(), data
, &num_locks
, &locks
);
424 TALLOC_FREE(data
.dptr
);
427 DEBUG(10, ("g_lock_parse for %s failed\n", name
));
428 return NT_STATUS_INTERNAL_ERROR
;
431 for (i
=0; i
<num_locks
; i
++) {
432 if (fn(locks
[i
].pid
, locks
[i
].lock_type
, private_data
) != 0) {
440 struct g_lock_get_state
{
442 struct server_id
*pid
;
445 static int g_lock_get_fn(struct server_id pid
, enum g_lock_type lock_type
,
448 struct g_lock_get_state
*state
= (struct g_lock_get_state
*)priv
;
454 NTSTATUS
g_lock_get(struct g_lock_ctx
*ctx
, const char *name
,
455 struct server_id
*pid
)
457 struct g_lock_get_state state
;
463 status
= g_lock_dump(ctx
, name
, g_lock_get_fn
, &state
);
464 if (!NT_STATUS_IS_OK(status
)) {
468 return NT_STATUS_NOT_FOUND
;
473 static bool g_lock_init_all(TALLOC_CTX
*mem_ctx
,
474 struct tevent_context
**pev
,
475 struct messaging_context
**pmsg
,
476 struct g_lock_ctx
**pg_ctx
)
478 struct tevent_context
*ev
= NULL
;
479 struct messaging_context
*msg
= NULL
;
480 struct g_lock_ctx
*g_ctx
= NULL
;
482 ev
= tevent_context_init(mem_ctx
);
484 d_fprintf(stderr
, "ERROR: could not init event context\n");
487 msg
= messaging_init(mem_ctx
, ev
);
489 d_fprintf(stderr
, "ERROR: could not init messaging context\n");
492 g_ctx
= g_lock_ctx_init(mem_ctx
, msg
);
494 d_fprintf(stderr
, "ERROR: could not init g_lock context\n");
509 NTSTATUS
g_lock_do(const char *name
, enum g_lock_type lock_type
,
510 struct timeval timeout
,
511 void (*fn
)(void *private_data
), void *private_data
)
513 struct tevent_context
*ev
= NULL
;
514 struct messaging_context
*msg
= NULL
;
515 struct g_lock_ctx
*g_ctx
= NULL
;
518 if (!g_lock_init_all(talloc_tos(), &ev
, &msg
, &g_ctx
)) {
519 status
= NT_STATUS_ACCESS_DENIED
;
523 status
= g_lock_lock(g_ctx
, name
, lock_type
, timeout
);
524 if (!NT_STATUS_IS_OK(status
)) {
528 g_lock_unlock(g_ctx
, name
);