2 Unix SMB/CIFS implementation.
4 Copyright (C) Andrew Tridgell 2004
5 Copyright (C) Stefan Metzmacher 2008
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, tdb 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 "param/param.h"
55 struct ntvfs_context *ntvfs_ctx;
60 an odb lock handle. You must obtain one of these using odb_lock() before doing
64 struct odb_context *odb;
69 Open up the openfiles.tdb database. Close it down using
70 talloc_free(). We need the messaging_ctx to allow for pending open
73 static struct odb_context *odb_tdb_init(TALLOC_CTX *mem_ctx,
74 struct ntvfs_context *ntvfs_ctx)
76 struct odb_context *odb;
78 odb = talloc(mem_ctx, struct odb_context);
83 odb->w = cluster_tdb_tmp_open(odb, ntvfs_ctx->lp_ctx, "openfiles.tdb", TDB_DEFAULT);
89 odb->ntvfs_ctx = ntvfs_ctx;
91 /* leave oplocks disabled by default until the code is working */
92 odb->oplocks = lp_parm_bool(ntvfs_ctx->lp_ctx, NULL, "opendb", "oplocks", false);
98 destroy a lock on the database
100 static int odb_lock_destructor(struct odb_lock *lck)
102 tdb_chainunlock(lck->odb->w->tdb, lck->key);
107 get a lock on a entry in the odb. This call returns a lock handle,
108 which the caller should unlock using talloc_free().
110 static struct odb_lock *odb_tdb_lock(TALLOC_CTX *mem_ctx,
111 struct odb_context *odb, DATA_BLOB *file_key)
113 struct odb_lock *lck;
115 lck = talloc(mem_ctx, struct odb_lock);
120 lck->odb = talloc_reference(lck, odb);
121 lck->key.dptr = talloc_memdup(lck, file_key->data, file_key->length);
122 lck->key.dsize = file_key->length;
123 if (lck->key.dptr == NULL) {
128 if (tdb_chainlock(odb->w->tdb, lck->key) != 0) {
133 talloc_set_destructor(lck, odb_lock_destructor);
138 static DATA_BLOB odb_tdb_get_key(TALLOC_CTX *mem_ctx, struct odb_lock *lck)
140 return data_blob_talloc(mem_ctx, lck->key.dptr, lck->key.dsize);
145 determine if two odb_entry structures conflict
147 return NT_STATUS_OK on no conflict
149 static NTSTATUS share_conflict(struct opendb_entry *e1,
151 uint32_t share_access,
152 uint32_t access_mask)
154 /* if either open involves no read.write or delete access then
156 if (!(e1->access_mask & (SEC_FILE_WRITE_DATA |
157 SEC_FILE_APPEND_DATA |
163 if (!(access_mask & (SEC_FILE_WRITE_DATA |
164 SEC_FILE_APPEND_DATA |
171 /* data IO access masks. This is skipped if the two open handles
172 are on different streams (as in that case the masks don't
174 if (e1->stream_id != stream_id) {
178 #define CHECK_MASK(am, right, sa, share) \
179 if (((am) & (right)) && !((sa) & (share))) return NT_STATUS_SHARING_VIOLATION
181 CHECK_MASK(e1->access_mask, SEC_FILE_WRITE_DATA | SEC_FILE_APPEND_DATA,
182 share_access, NTCREATEX_SHARE_ACCESS_WRITE);
183 CHECK_MASK(access_mask, SEC_FILE_WRITE_DATA | SEC_FILE_APPEND_DATA,
184 e1->share_access, NTCREATEX_SHARE_ACCESS_WRITE);
186 CHECK_MASK(e1->access_mask, SEC_FILE_READ_DATA | SEC_FILE_EXECUTE,
187 share_access, NTCREATEX_SHARE_ACCESS_READ);
188 CHECK_MASK(access_mask, SEC_FILE_READ_DATA | SEC_FILE_EXECUTE,
189 e1->share_access, NTCREATEX_SHARE_ACCESS_READ);
191 CHECK_MASK(e1->access_mask, SEC_STD_DELETE,
192 share_access, NTCREATEX_SHARE_ACCESS_DELETE);
193 CHECK_MASK(access_mask, SEC_STD_DELETE,
194 e1->share_access, NTCREATEX_SHARE_ACCESS_DELETE);
200 pull a record, translating from the db format to the opendb_file structure defined
203 static NTSTATUS odb_pull_record(struct odb_lock *lck, struct opendb_file *file)
205 struct odb_context *odb = lck->odb;
208 enum ndr_err_code ndr_err;
210 dbuf = tdb_fetch(odb->w->tdb, lck->key);
211 if (dbuf.dptr == NULL) {
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);
220 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
221 return ndr_map_error2ntstatus(ndr_err);
228 push a record, translating from the opendb_file structure defined in opendb.idl
230 static NTSTATUS odb_push_record(struct odb_lock *lck, struct opendb_file *file)
232 struct odb_context *odb = lck->odb;
235 enum ndr_err_code ndr_err;
238 if (file->num_entries == 0) {
239 ret = tdb_delete(odb->w->tdb, lck->key);
241 return NT_STATUS_INTERNAL_DB_CORRUPTION;
246 ndr_err = ndr_push_struct_blob(&blob, lck, lp_iconv_convenience(lck->odb->ntvfs_ctx->lp_ctx), 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 = tdb_store(odb->w->tdb, lck->key, dbuf, TDB_REPLACE);
255 data_blob_free(&blob);
257 return NT_STATUS_INTERNAL_DB_CORRUPTION;
264 send an oplock break to a client
266 static NTSTATUS odb_oplock_break_send(struct odb_context *odb,
267 struct opendb_entry *e,
271 struct opendb_oplock_break op_break;
274 ZERO_STRUCT(op_break);
276 /* tell the server handling this open file about the need to send the client
278 op_break.file_handle = e->file_handle;
279 op_break.level = level;
281 blob = data_blob_const(&op_break, sizeof(op_break));
283 status = messaging_send(odb->ntvfs_ctx->msg_ctx, e->server,
284 MSG_NTVFS_OPLOCK_BREAK, &blob);
285 NT_STATUS_NOT_OK_RETURN(status);
290 static bool access_attributes_only(uint32_t access_mask,
291 uint32_t open_disposition,
294 switch (open_disposition) {
295 case NTCREATEX_DISP_SUPERSEDE:
296 case NTCREATEX_DISP_OVERWRITE_IF:
297 case NTCREATEX_DISP_OVERWRITE:
307 #define CHECK_MASK(m,g) ((m) && (((m) & ~(g))==0) && (((m) & (g)) != 0))
308 return CHECK_MASK(access_mask,
309 SEC_STD_SYNCHRONIZE |
310 SEC_FILE_READ_ATTRIBUTE |
311 SEC_FILE_WRITE_ATTRIBUTE);
315 static NTSTATUS odb_tdb_open_can_internal(struct odb_context *odb,
316 const struct opendb_file *file,
317 uint32_t stream_id, uint32_t share_access,
318 uint32_t access_mask, bool delete_on_close,
319 uint32_t open_disposition, bool break_to_none,
324 bool attrs_only = false;
326 /* see if anyone has an oplock, which we need to break */
327 for (i=0;i<file->num_entries;i++) {
328 if (file->entries[i].oplock_level == OPLOCK_BATCH) {
329 bool oplock_return = OPLOCK_BREAK_TO_LEVEL_II;
330 /* if this is an attribute only access
331 * it doesn't conflict with a BACTCH oplock
332 * but we'll not grant the oplock below
334 attrs_only = access_attributes_only(access_mask,
340 /* a batch oplock caches close calls, which
341 means the client application might have
342 already closed the file. We have to allow
343 this close to propogate by sending a oplock
344 break request and suspending this call
345 until the break is acknowledged or the file
348 oplock_return = OPLOCK_BREAK_TO_NONE;
350 odb_oplock_break_send(odb, &file->entries[i],
352 return NT_STATUS_OPLOCK_NOT_GRANTED;
356 if (file->delete_on_close) {
357 /* while delete on close is set, no new opens are allowed */
358 return NT_STATUS_DELETE_PENDING;
361 if (file->num_entries != 0 && delete_on_close) {
362 return NT_STATUS_SHARING_VIOLATION;
365 /* check for sharing violations */
366 for (i=0;i<file->num_entries;i++) {
367 status = share_conflict(&file->entries[i], stream_id,
368 share_access, access_mask);
369 NT_STATUS_NOT_OK_RETURN(status);
372 /* we now know the open could succeed, but we need to check
373 for any exclusive oplocks. We can't grant a second open
374 till these are broken. Note that we check for batch oplocks
375 before checking for sharing violations, and check for
376 exclusive oplocks afterwards. */
377 for (i=0;i<file->num_entries;i++) {
378 if (file->entries[i].oplock_level == OPLOCK_EXCLUSIVE) {
379 odb_oplock_break_send(odb, &file->entries[i],
380 OPLOCK_BREAK_TO_NONE);
381 return NT_STATUS_OPLOCK_NOT_GRANTED;
386 *_attrs_only = attrs_only;
392 register an open file in the open files database. This implements the share_access
395 Note that the path is only used by the delete on close logic, not
396 for comparing with other filenames
398 static NTSTATUS odb_tdb_open_file(struct odb_lock *lck,
399 void *file_handle, const char *path,
400 uint32_t stream_id, uint32_t share_access,
401 uint32_t access_mask, bool delete_on_close,
402 uint32_t open_disposition, bool break_to_none,
403 uint32_t oplock_level, uint32_t *oplock_granted)
405 struct odb_context *odb = lck->odb;
406 struct opendb_entry e;
407 struct opendb_file file;
409 bool attrs_only = false;
411 if (odb->oplocks == false) {
412 oplock_level = OPLOCK_NONE;
415 status = odb_pull_record(lck, &file);
416 if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
417 /* initialise a blank structure */
421 NT_STATUS_NOT_OK_RETURN(status);
424 /* see if it conflicts */
425 status = odb_tdb_open_can_internal(odb, &file, stream_id,
426 share_access, access_mask,
427 delete_on_close, open_disposition,
428 break_to_none, &attrs_only);
429 NT_STATUS_NOT_OK_RETURN(status);
431 /* see if it conflicts */
432 e.server = odb->ntvfs_ctx->server_id;
433 e.file_handle = file_handle;
434 e.stream_id = stream_id;
435 e.share_access = share_access;
436 e.access_mask = access_mask;
437 e.delete_on_close = delete_on_close;
438 e.oplock_level = OPLOCK_NONE;
441 possibly grant an exclusive, batch or level2 oplock
443 if (oplock_granted) {
445 e.oplock_level = OPLOCK_NONE;
446 *oplock_granted = NO_OPLOCK_RETURN;
447 } else if (oplock_level == OPLOCK_EXCLUSIVE) {
448 if (file.num_entries == 0) {
449 e.oplock_level = OPLOCK_EXCLUSIVE;
450 *oplock_granted = EXCLUSIVE_OPLOCK_RETURN;
452 e.oplock_level = OPLOCK_NONE;
453 *oplock_granted = NO_OPLOCK_RETURN;
455 } else if (oplock_level == OPLOCK_BATCH) {
456 if (file.num_entries == 0) {
457 e.oplock_level = OPLOCK_BATCH;
458 *oplock_granted = BATCH_OPLOCK_RETURN;
460 e.oplock_level = OPLOCK_LEVEL_II;
461 *oplock_granted = LEVEL_II_OPLOCK_RETURN;
463 } else if (oplock_level == OPLOCK_LEVEL_II) {
464 e.oplock_level = OPLOCK_LEVEL_II;
465 *oplock_granted = LEVEL_II_OPLOCK_RETURN;
467 e.oplock_level = OPLOCK_NONE;
468 *oplock_granted = NO_OPLOCK_RETURN;
472 /* it doesn't conflict, so add it to the end */
473 file.entries = talloc_realloc(lck, file.entries, struct opendb_entry,
475 NT_STATUS_HAVE_NO_MEMORY(file.entries);
477 file.entries[file.num_entries] = e;
480 return odb_push_record(lck, &file);
485 register a pending open file in the open files database
487 static NTSTATUS odb_tdb_open_file_pending(struct odb_lock *lck, void *private)
489 struct odb_context *odb = lck->odb;
490 struct opendb_file file;
493 status = odb_pull_record(lck, &file);
494 NT_STATUS_NOT_OK_RETURN(status);
496 file.pending = talloc_realloc(lck, file.pending, struct opendb_pending,
498 NT_STATUS_HAVE_NO_MEMORY(file.pending);
500 file.pending[file.num_pending].server = odb->ntvfs_ctx->server_id;
501 file.pending[file.num_pending].notify_ptr = private;
505 return odb_push_record(lck, &file);
510 remove a opendb entry
512 static NTSTATUS odb_tdb_close_file(struct odb_lock *lck, void *file_handle)
514 struct odb_context *odb = lck->odb;
515 struct opendb_file file;
519 status = odb_pull_record(lck, &file);
520 NT_STATUS_NOT_OK_RETURN(status);
522 /* find the entry, and delete it */
523 for (i=0;i<file.num_entries;i++) {
524 if (file_handle == file.entries[i].file_handle &&
525 cluster_id_equal(&odb->ntvfs_ctx->server_id, &file.entries[i].server)) {
526 if (file.entries[i].delete_on_close) {
527 file.delete_on_close = true;
529 if (i < file.num_entries-1) {
530 memmove(file.entries+i, file.entries+i+1,
531 (file.num_entries - (i+1)) *
532 sizeof(struct opendb_entry));
538 if (i == file.num_entries) {
539 return NT_STATUS_UNSUCCESSFUL;
542 /* send any pending notifications, removing them once sent */
543 for (i=0;i<file.num_pending;i++) {
544 messaging_send_ptr(odb->ntvfs_ctx->msg_ctx, file.pending[i].server,
546 file.pending[i].notify_ptr);
548 file.num_pending = 0;
552 return odb_push_record(lck, &file);
556 update the oplock level of the client
558 static NTSTATUS odb_tdb_update_oplock(struct odb_lock *lck, void *file_handle,
559 uint32_t oplock_level)
561 struct odb_context *odb = lck->odb;
562 struct opendb_file file;
566 status = odb_pull_record(lck, &file);
567 NT_STATUS_NOT_OK_RETURN(status);
569 /* find the entry, and update it */
570 for (i=0;i<file.num_entries;i++) {
571 if (file_handle == file.entries[i].file_handle &&
572 cluster_id_equal(&odb->ntvfs_ctx->server_id, &file.entries[i].server)) {
573 file.entries[i].oplock_level = oplock_level;
578 if (i == file.num_entries) {
579 return NT_STATUS_UNSUCCESSFUL;
582 /* send any pending notifications, removing them once sent */
583 for (i=0;i<file.num_pending;i++) {
584 messaging_send_ptr(odb->ntvfs_ctx->msg_ctx,
585 file.pending[i].server,
587 file.pending[i].notify_ptr);
589 file.num_pending = 0;
591 return odb_push_record(lck, &file);
595 send oplocks breaks to none to all level2 holders
597 static NTSTATUS odb_tdb_break_oplocks(struct odb_lock *lck)
599 struct odb_context *odb = lck->odb;
601 struct opendb_file file;
603 bool modified = true;
605 status = odb_pull_record(lck, &file);
606 if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
609 NT_STATUS_NOT_OK_RETURN(status);
611 /* see if anyone has an oplock, which we need to break */
612 for (i=0;i<file.num_entries;i++) {
613 if (file.entries[i].oplock_level == OPLOCK_LEVEL_II) {
615 * there could be multiple level2 oplocks
616 * and we just send a break to none to all of them
617 * without waiting for a release
619 odb_oplock_break_send(odb, &file.entries[i],
620 OPLOCK_BREAK_TO_NONE);
621 file.entries[i].oplock_level = OPLOCK_NONE;
627 return odb_push_record(lck, &file);
633 remove a pending opendb entry
635 static NTSTATUS odb_tdb_remove_pending(struct odb_lock *lck, void *private)
637 struct odb_context *odb = lck->odb;
640 struct opendb_file file;
642 status = odb_pull_record(lck, &file);
643 NT_STATUS_NOT_OK_RETURN(status);
645 /* find the entry, and delete it */
646 for (i=0;i<file.num_pending;i++) {
647 if (private == file.pending[i].notify_ptr &&
648 cluster_id_equal(&odb->ntvfs_ctx->server_id, &file.pending[i].server)) {
649 if (i < file.num_pending-1) {
650 memmove(file.pending+i, file.pending+i+1,
651 (file.num_pending - (i+1)) *
652 sizeof(struct opendb_pending));
658 if (i == file.num_pending) {
659 return NT_STATUS_UNSUCCESSFUL;
664 return odb_push_record(lck, &file);
669 rename the path in a open file
671 static NTSTATUS odb_tdb_rename(struct odb_lock *lck, const char *path)
673 struct opendb_file file;
676 status = odb_pull_record(lck, &file);
677 if (NT_STATUS_EQUAL(NT_STATUS_OBJECT_NAME_NOT_FOUND, status)) {
678 /* not having the record at all is OK */
681 NT_STATUS_NOT_OK_RETURN(status);
684 return odb_push_record(lck, &file);
688 update delete on close flag on an open file
690 static NTSTATUS odb_tdb_set_delete_on_close(struct odb_lock *lck, bool del_on_close)
693 struct opendb_file file;
695 status = odb_pull_record(lck, &file);
696 NT_STATUS_NOT_OK_RETURN(status);
698 file.delete_on_close = del_on_close;
700 return odb_push_record(lck, &file);
704 return the current value of the delete_on_close bit, and how many
705 people still have the file open
707 static NTSTATUS odb_tdb_get_delete_on_close(struct odb_context *odb,
708 DATA_BLOB *key, bool *del_on_close,
709 int *open_count, char **path)
712 struct opendb_file file;
713 struct odb_lock *lck;
715 lck = odb_lock(odb, odb, key);
716 NT_STATUS_HAVE_NO_MEMORY(lck);
718 status = odb_pull_record(lck, &file);
719 if (NT_STATUS_EQUAL(NT_STATUS_OBJECT_NAME_NOT_FOUND, status)) {
721 (*del_on_close) = false;
724 if (!NT_STATUS_IS_OK(status)) {
729 (*del_on_close) = file.delete_on_close;
730 if (open_count != NULL) {
731 (*open_count) = file.num_entries;
734 *path = talloc_strdup(odb, file.path);
735 NT_STATUS_HAVE_NO_MEMORY(*path);
736 if (file.num_entries == 1 && file.entries[0].delete_on_close) {
737 (*del_on_close) = true;
748 determine if a file can be opened with the given share_access,
749 create_options and access_mask
751 static NTSTATUS odb_tdb_can_open(struct odb_lock *lck,
752 uint32_t stream_id, uint32_t share_access,
753 uint32_t access_mask, bool delete_on_close,
754 uint32_t open_disposition, bool break_to_none)
756 struct odb_context *odb = lck->odb;
758 struct opendb_file file;
759 bool attrs_only = false;
761 status = odb_pull_record(lck, &file);
762 if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
765 NT_STATUS_NOT_OK_RETURN(status);
767 status = odb_tdb_open_can_internal(odb, &file, stream_id,
768 share_access, access_mask,
769 delete_on_close, open_disposition,
770 break_to_none, &attrs_only);
771 NT_STATUS_NOT_OK_RETURN(status);
777 static const struct opendb_ops opendb_tdb_ops = {
778 .odb_init = odb_tdb_init,
779 .odb_lock = odb_tdb_lock,
780 .odb_get_key = odb_tdb_get_key,
781 .odb_open_file = odb_tdb_open_file,
782 .odb_open_file_pending = odb_tdb_open_file_pending,
783 .odb_close_file = odb_tdb_close_file,
784 .odb_remove_pending = odb_tdb_remove_pending,
785 .odb_rename = odb_tdb_rename,
786 .odb_set_delete_on_close = odb_tdb_set_delete_on_close,
787 .odb_get_delete_on_close = odb_tdb_get_delete_on_close,
788 .odb_can_open = odb_tdb_can_open,
789 .odb_update_oplock = odb_tdb_update_oplock,
790 .odb_break_oplocks = odb_tdb_break_oplocks
794 void odb_tdb_init_ops(void)
796 odb_set_ops(&opendb_tdb_ops);