2 Unix SMB/CIFS implementation.
4 Copyright (C) Ronnie Sahlberg 2007
5 Copyright (C) Andrew Tridgell 2007
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/>.
22 this is the open files database, ctdb backend. It implements shared
23 storage of what files are open between server instances, and
24 implements the rules of shared access to files.
26 The caller needs to provide a file_key, which specifies what file
27 they are talking about. This needs to be a unique key across all
28 filesystems, and is usually implemented in terms of a device/inode
31 Before any operations can be performed the caller needs to establish
32 a lock on the record associated with file_key. That is done by
33 calling odb_lock(). The caller releases this lock by calling
34 talloc_free() on the returned handle.
36 All other operations on a record are done by passing the odb_lock()
37 handle back to this module. The handle contains internal
38 information about what file_key is being operated on.
42 #include "system/filesys.h"
43 #include "lib/tdb/include/tdb.h"
44 #include "messaging/messaging.h"
46 #include "lib/messaging/irpc.h"
47 #include "librpc/gen_ndr/ndr_opendb.h"
48 #include "ntvfs/ntvfs.h"
49 #include "ntvfs/common/ntvfs_common.h"
50 #include "cluster/cluster.h"
51 #include "include/ctdb.h"
52 #include "param/param.h"
55 struct ctdb_context *ctdb;
56 struct ctdb_db_context *ctdb_db;
57 struct ntvfs_context *ntvfs_ctx;
62 an odb lock handle. You must obtain one of these using odb_lock() before doing
66 struct odb_context *odb;
67 struct ctdb_record_handle *rec;
73 Open up the openfiles.tdb database. Close it down using
74 talloc_free(). We need the messaging_ctx to allow for pending open
77 static struct odb_context *odb_ctdb_init(TALLOC_CTX *mem_ctx,
78 struct ntvfs_context *ntvfs_ctx)
80 struct odb_context *odb;
81 struct ctdb_context *ctdb = talloc_get_type(cluster_backend_handle(),
84 odb = talloc(mem_ctx, struct odb_context);
90 odb->ctdb_db = ctdb_attach(ctdb, "opendb");
92 DEBUG(0,("Failed to get attached ctdb db handle for opendb\n"));
97 odb->ntvfs_ctx = ntvfs_ctx;
99 /* leave oplocks disabled by default until the code is working */
100 odb->oplocks = lp_parm_bool(ntvfs_ctx->lp_ctx, NULL, "opendb", "oplocks", false);
106 get a lock on a entry in the odb. This call returns a lock handle,
107 which the caller should unlock using talloc_free().
109 static struct odb_lock *odb_ctdb_lock(TALLOC_CTX *mem_ctx,
110 struct odb_context *odb, DATA_BLOB *file_key)
112 struct odb_lock *lck;
114 lck = talloc(mem_ctx, struct odb_lock);
119 lck->odb = talloc_reference(lck, odb);
120 lck->key.dptr = talloc_memdup(lck, file_key->data, file_key->length);
121 lck->key.dsize = file_key->length;
122 if (lck->key.dptr == NULL) {
127 lck->rec = ctdb_fetch_lock(odb->ctdb_db, (TALLOC_CTX *)lck, lck->key, &lck->data);
136 static DATA_BLOB odb_ctdb_get_key(TALLOC_CTX *mem_ctx, struct odb_lock *lck)
139 * as this file will went away and isn't used yet,
140 * copy the implementation from the tdb backend
143 return data_blob_const(NULL, 0);
147 determine if two odb_entry structures conflict
149 return NT_STATUS_OK on no conflict
151 static NTSTATUS share_conflict(struct opendb_entry *e1, struct opendb_entry *e2)
153 /* if either open involves no read.write or delete access then
155 if (!(e1->access_mask & (SEC_FILE_WRITE_DATA |
156 SEC_FILE_APPEND_DATA |
162 if (!(e2->access_mask & (SEC_FILE_WRITE_DATA |
163 SEC_FILE_APPEND_DATA |
170 /* data IO access masks. This is skipped if the two open handles
171 are on different streams (as in that case the masks don't
173 if (e1->stream_id != e2->stream_id) {
177 #define CHECK_MASK(am, right, sa, share) \
178 if (((am) & (right)) && !((sa) & (share))) return NT_STATUS_SHARING_VIOLATION
180 CHECK_MASK(e1->access_mask, SEC_FILE_WRITE_DATA | SEC_FILE_APPEND_DATA,
181 e2->share_access, NTCREATEX_SHARE_ACCESS_WRITE);
182 CHECK_MASK(e2->access_mask, SEC_FILE_WRITE_DATA | SEC_FILE_APPEND_DATA,
183 e1->share_access, NTCREATEX_SHARE_ACCESS_WRITE);
185 CHECK_MASK(e1->access_mask, SEC_FILE_READ_DATA | SEC_FILE_EXECUTE,
186 e2->share_access, NTCREATEX_SHARE_ACCESS_READ);
187 CHECK_MASK(e2->access_mask, SEC_FILE_READ_DATA | SEC_FILE_EXECUTE,
188 e1->share_access, NTCREATEX_SHARE_ACCESS_READ);
190 CHECK_MASK(e1->access_mask, SEC_STD_DELETE,
191 e2->share_access, NTCREATEX_SHARE_ACCESS_DELETE);
192 CHECK_MASK(e2->access_mask, SEC_STD_DELETE,
193 e1->share_access, NTCREATEX_SHARE_ACCESS_DELETE);
199 pull a record, translating from the db format to the opendb_file structure defined
202 static NTSTATUS odb_pull_record(struct odb_lock *lck, struct opendb_file *file)
206 enum ndr_err_code ndr_err;
210 if (dbuf.dsize == 0) {
211 /* empty record in ctdb means the record isn't there */
212 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
215 blob.data = dbuf.dptr;
216 blob.length = dbuf.dsize;
218 ndr_err = ndr_pull_struct_blob(&blob, lck, lp_iconv_convenience(lck->odb->ntvfs_ctx->lp_ctx), file, (ndr_pull_flags_fn_t)ndr_pull_opendb_file);
219 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
220 return ndr_map_error2ntstatus(ndr_err);
227 push a record, translating from the opendb_file structure defined in opendb.idl
229 static NTSTATUS odb_push_record(struct odb_lock *lck, struct opendb_file *file)
233 enum ndr_err_code ndr_err;
236 if (!file->num_entries) {
239 ctdb_record_store(lck->rec, dbuf);
240 talloc_free(lck->rec);
244 ndr_err = ndr_push_struct_blob(&blob, lck,
245 lp_iconv_convenience(lck->odb->ntvfs_ctx->lp_ctx),
246 file, (ndr_push_flags_fn_t)ndr_push_opendb_file);
247 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
248 return ndr_map_error2ntstatus(ndr_err);
251 dbuf.dptr = blob.data;
252 dbuf.dsize = blob.length;
254 ret = ctdb_record_store(lck->rec, dbuf);
255 talloc_free(lck->rec);
256 data_blob_free(&blob);
258 return NT_STATUS_INTERNAL_DB_CORRUPTION;
265 send an oplock break to a client
267 static NTSTATUS odb_oplock_break_send(struct odb_context *odb, struct opendb_entry *e)
269 /* tell the server handling this open file about the need to send the client
271 return messaging_send_ptr(odb->ntvfs_ctx->msg_ctx, e->server,
272 MSG_NTVFS_OPLOCK_BREAK, e->file_handle);
276 register an open file in the open files database. This implements the share_access
279 Note that the path is only used by the delete on close logic, not
280 for comparing with other filenames
282 static NTSTATUS odb_ctdb_open_file(struct odb_lock *lck,
283 void *file_handle, const char *path,
284 uint32_t stream_id, uint32_t share_access,
285 uint32_t access_mask, bool delete_on_close,
286 uint32_t open_disposition, bool break_to_none,
287 bool allow_level_II_oplock,
288 uint32_t oplock_level, uint32_t *oplock_granted)
291 struct odb_context *odb = lck->odb;
292 struct opendb_entry e;
294 struct opendb_file file;
297 if (odb->oplocks == false) {
298 oplock_level = OPLOCK_NONE;
301 status = odb_pull_record(lck, &file);
302 if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
303 /* initialise a blank structure */
307 NT_STATUS_NOT_OK_RETURN(status);
310 /* see if it conflicts */
311 e.server = odb->ntvfs_ctx->server_id;
312 e.file_handle = file_handle;
313 e.stream_id = stream_id;
314 e.share_access = share_access;
315 e.access_mask = access_mask;
316 e.delete_on_close = delete_on_close;
317 e.oplock_level = OPLOCK_NONE;
319 /* see if anyone has an oplock, which we need to break */
320 for (i=0;i<file.num_entries;i++) {
321 if (file.entries[i].oplock_level == OPLOCK_BATCH) {
322 /* a batch oplock caches close calls, which
323 means the client application might have
324 already closed the file. We have to allow
325 this close to propogate by sending a oplock
326 break request and suspending this call
327 until the break is acknowledged or the file
329 odb_oplock_break_send(odb, &file.entries[i]);
330 return NT_STATUS_OPLOCK_NOT_GRANTED;
334 if (file.delete_on_close ||
335 (file.num_entries != 0 && delete_on_close)) {
336 /* while delete on close is set, no new opens are allowed */
337 return NT_STATUS_DELETE_PENDING;
340 /* check for sharing violations */
341 for (i=0;i<file.num_entries;i++) {
342 status = share_conflict(&file.entries[i], &e);
343 NT_STATUS_NOT_OK_RETURN(status);
346 /* we now know the open could succeed, but we need to check
347 for any exclusive oplocks. We can't grant a second open
348 till these are broken. Note that we check for batch oplocks
349 before checking for sharing violations, and check for
350 exclusive oplocks afterwards. */
351 for (i=0;i<file.num_entries;i++) {
352 if (file.entries[i].oplock_level == OPLOCK_EXCLUSIVE) {
353 odb_oplock_break_send(odb, &file.entries[i]);
354 return NT_STATUS_OPLOCK_NOT_GRANTED;
359 possibly grant an exclusive or batch oplock if this is the only client
360 with the file open. We don't yet grant levelII oplocks.
362 if (oplock_granted != NULL) {
363 if ((oplock_level == OPLOCK_BATCH ||
364 oplock_level == OPLOCK_EXCLUSIVE) &&
365 file.num_entries == 0) {
366 (*oplock_granted) = oplock_level;
368 (*oplock_granted) = OPLOCK_NONE;
370 e.oplock_level = (*oplock_granted);
373 /* it doesn't conflict, so add it to the end */
374 file.entries = talloc_realloc(lck, file.entries, struct opendb_entry,
376 NT_STATUS_HAVE_NO_MEMORY(file.entries);
378 file.entries[file.num_entries] = e;
381 return odb_push_record(lck, &file);
386 register a pending open file in the open files database
388 static NTSTATUS odb_ctdb_open_file_pending(struct odb_lock *lck, void *private)
390 struct odb_context *odb = lck->odb;
391 struct opendb_file file;
394 status = odb_pull_record(lck, &file);
395 NT_STATUS_NOT_OK_RETURN(status);
397 file.pending = talloc_realloc(lck, file.pending, struct opendb_pending,
399 NT_STATUS_HAVE_NO_MEMORY(file.pending);
401 file.pending[file.num_pending].server = odb->ntvfs_ctx->server_id;
402 file.pending[file.num_pending].notify_ptr = private;
406 return odb_push_record(lck, &file);
411 remove a opendb entry
413 static NTSTATUS odb_ctdb_close_file(struct odb_lock *lck, void *file_handle,
414 const char **_delete_path)
416 struct odb_context *odb = lck->odb;
417 struct opendb_file file;
418 const char *delete_path = NULL;
422 status = odb_pull_record(lck, &file);
423 NT_STATUS_NOT_OK_RETURN(status);
425 /* find the entry, and delete it */
426 for (i=0;i<file.num_entries;i++) {
427 if (file_handle == file.entries[i].file_handle &&
428 cluster_id_equal(&odb->ntvfs_ctx->server_id, &file.entries[i].server)) {
429 if (file.entries[i].delete_on_close) {
430 file.delete_on_close = true;
432 if (i < file.num_entries-1) {
433 memmove(file.entries+i, file.entries+i+1,
434 (file.num_entries - (i+1)) *
435 sizeof(struct opendb_entry));
441 if (i == file.num_entries) {
442 return NT_STATUS_UNSUCCESSFUL;
445 /* send any pending notifications, removing them once sent */
446 for (i=0;i<file.num_pending;i++) {
447 messaging_send_ptr(odb->ntvfs_ctx->msg_ctx, file.pending[i].server,
449 file.pending[i].notify_ptr);
451 file.num_pending = 0;
455 if (file.num_entries == 0 && file.delete_on_close) {
456 delete_path = talloc_strdup(lck, file.path);
457 NT_STATUS_HAVE_NO_MEMORY(delete_path);
461 *_delete_path = delete_path;
464 return odb_push_record(lck, &file);
468 update the oplock level of the client
470 static NTSTATUS odb_ctdb_update_oplock(struct odb_lock *lck, void *file_handle,
471 uint32_t oplock_level)
474 * as this file will went away and isn't used yet,
475 * copy the implementation from the tdb backend
478 return NT_STATUS_FOOBAR;
481 static NTSTATUS odb_ctdb_break_oplocks(struct odb_lock *lck)
484 * as this file will went away and isn't used yet,
485 * copy the implementation from the tdb backend
488 return NT_STATUS_FOOBAR;
492 remove a pending opendb entry
494 static NTSTATUS odb_ctdb_remove_pending(struct odb_lock *lck, void *private)
496 struct odb_context *odb = lck->odb;
499 struct opendb_file file;
501 status = odb_pull_record(lck, &file);
502 NT_STATUS_NOT_OK_RETURN(status);
504 /* find the entry, and delete it */
505 for (i=0;i<file.num_pending;i++) {
506 if (private == file.pending[i].notify_ptr &&
507 cluster_id_equal(&odb->ntvfs_ctx->server_id, &file.pending[i].server)) {
508 if (i < file.num_pending-1) {
509 memmove(file.pending+i, file.pending+i+1,
510 (file.num_pending - (i+1)) *
511 sizeof(struct opendb_pending));
517 if (i == file.num_pending) {
518 return NT_STATUS_UNSUCCESSFUL;
523 return odb_push_record(lck, &file);
528 rename the path in a open file
530 static NTSTATUS odb_ctdb_rename(struct odb_lock *lck, const char *path)
532 struct opendb_file file;
535 status = odb_pull_record(lck, &file);
536 if (NT_STATUS_EQUAL(NT_STATUS_OBJECT_NAME_NOT_FOUND, status)) {
537 /* not having the record at all is OK */
540 NT_STATUS_NOT_OK_RETURN(status);
543 return odb_push_record(lck, &file);
547 get the path of an open file
549 static NTSTATUS odb_ctdb_get_path(struct odb_lock *lck, const char **path)
551 struct opendb_file file;
556 status = odb_pull_record(lck, &file);
557 /* we don't ignore NT_STATUS_OBJECT_NAME_NOT_FOUND here */
558 NT_STATUS_NOT_OK_RETURN(status);
566 update delete on close flag on an open file
568 static NTSTATUS odb_ctdb_set_delete_on_close(struct odb_lock *lck, bool del_on_close)
571 struct opendb_file file;
573 status = odb_pull_record(lck, &file);
574 NT_STATUS_NOT_OK_RETURN(status);
576 file.delete_on_close = del_on_close;
578 return odb_push_record(lck, &file);
582 return the current value of the delete_on_close bit, and how many
583 people still have the file open
585 static NTSTATUS odb_ctdb_get_delete_on_close(struct odb_context *odb,
586 DATA_BLOB *key, bool *del_on_close)
589 struct opendb_file file;
590 struct odb_lock *lck;
592 (*del_on_close) = false;
594 lck = odb_lock(odb, odb, key);
595 NT_STATUS_HAVE_NO_MEMORY(lck);
597 status = odb_pull_record(lck, &file);
598 if (NT_STATUS_EQUAL(NT_STATUS_OBJECT_NAME_NOT_FOUND, status)) {
602 if (!NT_STATUS_IS_OK(status)) {
607 (*del_on_close) = file.delete_on_close;
616 determine if a file can be opened with the given share_access,
617 create_options and access_mask
619 static NTSTATUS odb_ctdb_can_open(struct odb_lock *lck,
620 uint32_t stream_id, uint32_t share_access,
621 uint32_t access_mask, bool delete_on_close,
622 uint32_t open_disposition, bool break_to_none)
624 struct odb_context *odb = lck->odb;
626 struct opendb_file file;
627 struct opendb_entry e;
630 status = odb_pull_record(lck, &file);
631 if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
634 NT_STATUS_NOT_OK_RETURN(status);
636 if (delete_on_close &&
637 file.num_entries != 0) {
638 return NT_STATUS_SHARING_VIOLATION;
641 if (file.delete_on_close) {
642 return NT_STATUS_DELETE_PENDING;
645 e.server = odb->ntvfs_ctx->server_id;
646 e.file_handle = NULL;
648 e.share_access = share_access;
649 e.access_mask = access_mask;
651 for (i=0;i<file.num_entries;i++) {
652 status = share_conflict(&file.entries[i], &e);
653 if (!NT_STATUS_IS_OK(status)) {
654 /* note that we discard the error code
655 here. We do this as unless we are actually
656 doing an open (which comes via a different
657 function), we need to return a sharing
659 return NT_STATUS_SHARING_VIOLATION;
667 static const struct opendb_ops opendb_ctdb_ops = {
668 .odb_init = odb_ctdb_init,
669 .odb_lock = odb_ctdb_lock,
670 .odb_get_key = odb_ctdb_get_key,
671 .odb_open_file = odb_ctdb_open_file,
672 .odb_open_file_pending = odb_ctdb_open_file_pending,
673 .odb_close_file = odb_ctdb_close_file,
674 .odb_remove_pending = odb_ctdb_remove_pending,
675 .odb_rename = odb_ctdb_rename,
676 .odb_get_path = odb_ctdb_get_path,
677 .odb_set_delete_on_close = odb_ctdb_set_delete_on_close,
678 .odb_get_delete_on_close = odb_ctdb_get_delete_on_close,
679 .odb_can_open = odb_ctdb_can_open,
680 .odb_update_oplock = odb_ctdb_update_oplock,
681 .odb_break_oplocks = odb_ctdb_break_oplocks
685 void odb_ctdb_init_ops(void)
687 odb_set_ops(&opendb_ctdb_ops);