2 Unix SMB/CIFS implementation.
4 Copyright (C) Andrew Tridgell 1992-2000
5 Copyright (C) Jeremy Allison 1992-2006
6 Copyright (C) Volker Lendecke 2005
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
23 12 aug 96: Erik.Devriendt@te6.siemens.be
24 added support for shared memory implementation of share mode locking
26 May 1997. Jeremy Allison (jallison@whistle.com). Modified share mode
27 locking to deal with multiple share modes per open file.
29 September 1997. Jeremy Allison (jallison@whistle.com). Added oplock
32 rewritten completely to use new tdb code. Tridge, Dec '99
34 Added POSIX locking support. Jeremy Allison (jeremy@valinux.com), Apr. 2000.
35 Added Unix Extensions POSIX locking support. Jeremy Allison Mar 2006.
39 #include "system/filesys.h"
40 #include "locking/proto.h"
41 #include "smbd/globals.h"
42 #include "dbwrap/dbwrap.h"
43 #include "dbwrap/dbwrap_open.h"
44 #include "../libcli/security/security.h"
48 #include "../librpc/gen_ndr/ndr_open_files.h"
49 #include "source3/lib/dbwrap/dbwrap_watch.h"
50 #include "locking/leases_db.h"
51 #include "../lib/util/memcache.h"
54 #define DBGC_CLASS DBGC_LOCKING
56 #define NO_LOCKING_COUNT (-1)
58 /* the locking database handle */
59 static struct db_context *lock_db;
61 static bool locking_init_internal(bool read_only)
63 struct db_context *backend;
71 db_path = lock_path("locking.tdb");
72 if (db_path == NULL) {
76 backend = db_open(NULL, db_path,
77 SMB_OPEN_DATABASE_TDB_HASH_SIZE,
78 TDB_DEFAULT|TDB_VOLATILE|TDB_CLEAR_IF_FIRST|TDB_INCOMPATIBLE_HASH,
79 read_only?O_RDONLY:O_RDWR|O_CREAT, 0644,
80 DBWRAP_LOCK_ORDER_1, DBWRAP_FLAG_NONE);
83 DEBUG(0,("ERROR: Failed to initialise locking database\n"));
87 lock_db = db_open_watched(NULL, backend, server_messaging_context());
88 if (lock_db == NULL) {
89 DBG_ERR("db_open_watched failed\n");
94 if (!posix_locking_init(read_only)) {
102 bool locking_init(void)
104 return locking_init_internal(false);
107 bool locking_init_readonly(void)
109 return locking_init_internal(true);
112 /*******************************************************************
113 Deinitialize the share_mode management.
114 ******************************************************************/
116 bool locking_end(void)
119 TALLOC_FREE(lock_db);
123 /*******************************************************************
124 Form a static locking key for a dev/inode pair.
125 ******************************************************************/
127 static TDB_DATA locking_key(const struct file_id *id)
129 return make_tdb_data((const uint8_t *)id, sizeof(*id));
132 /*******************************************************************
133 Share mode cache utility functions that store/delete/retrieve
134 entries from memcache.
136 For now share the statcache (global cache) memory space. If
137 a lock record gets orphaned (which shouldn't happen as we're
138 using the same locking_key data as lookup) it will eventually
139 fall out of the cache via the normal LRU trim mechanism. If
140 necessary we can always make this a separate (smaller) cache.
141 ******************************************************************/
143 static const DATA_BLOB memcache_key(const struct file_id *id)
145 return data_blob_const((const void *)id, sizeof(*id));
148 static void share_mode_memcache_delete(struct share_mode_data *d)
150 const DATA_BLOB key = memcache_key(&d->id);
152 DEBUG(10,("deleting entry for file %s seq 0x%llu key %s\n",
154 (unsigned long long) d->sequence_number,
155 file_id_string(talloc_tos(), &d->id)));
157 memcache_delete(NULL,
158 SHARE_MODE_LOCK_CACHE,
162 static void share_mode_memcache_store(struct share_mode_data *d)
164 const DATA_BLOB key = memcache_key(&d->id);
166 DEBUG(10,("stored entry for file %s seq 0x%llu key %s\n",
168 (unsigned long long) d->sequence_number,
169 file_id_string(talloc_tos(), &d->id)));
171 /* Ensure everything stored in the cache is pristine. */
176 * Ensure the memory going into the cache
177 * doesn't have a destructor so it can be
178 * cleanly freed by share_mode_memcache_delete().
180 talloc_set_destructor(d, NULL);
182 /* Cache will own d after this call. */
183 memcache_add_talloc(NULL,
184 SHARE_MODE_LOCK_CACHE,
190 * NB. We use ndr_pull_hyper on a stack-created
191 * struct ndr_pull with no talloc allowed, as we
192 * need this to be really fast as an ndr-peek into
193 * the first 8 bytes of the blob.
196 static enum ndr_err_code get_blob_sequence_number(DATA_BLOB *blob,
199 struct ndr_pull ndr = {.data = blob->data, .data_size = blob->length};
200 NDR_CHECK(ndr_pull_hyper(&ndr, NDR_SCALARS, pseq));
201 return NDR_ERR_SUCCESS;
204 static int share_mode_data_nofree_destructor(struct share_mode_data *d)
209 static struct share_mode_data *share_mode_memcache_fetch(TALLOC_CTX *mem_ctx,
210 const TDB_DATA id_key,
213 enum ndr_err_code ndr_err;
214 struct share_mode_data *d;
215 uint64_t sequence_number;
220 /* Ensure this is a locking_key record. */
221 if (id_key.dsize != sizeof(id)) {
225 memcpy(&id, id_key.dptr, id_key.dsize);
226 key = memcache_key(&id);
228 ptr = memcache_lookup_talloc(NULL,
229 SHARE_MODE_LOCK_CACHE,
232 DEBUG(10,("failed to find entry for key %s\n",
233 file_id_string(mem_ctx, &id)));
236 /* sequence number key is at start of blob. */
237 ndr_err = get_blob_sequence_number(blob, &sequence_number);
238 if (ndr_err != NDR_ERR_SUCCESS) {
239 /* Bad blob. Remove entry. */
240 DEBUG(10,("bad blob %u key %s\n",
241 (unsigned int)ndr_err,
242 file_id_string(mem_ctx, &id)));
243 memcache_delete(NULL,
244 SHARE_MODE_LOCK_CACHE,
249 d = (struct share_mode_data *)ptr;
250 if (d->sequence_number != sequence_number) {
251 DEBUG(10,("seq changed (cached 0x%llu) (new 0x%llu) "
253 (unsigned long long)d->sequence_number,
254 (unsigned long long)sequence_number,
255 file_id_string(mem_ctx, &id)));
256 /* Cache out of date. Remove entry. */
257 memcache_delete(NULL,
258 SHARE_MODE_LOCK_CACHE,
263 /* Move onto mem_ctx. */
264 d = talloc_move(mem_ctx, &ptr);
267 * Now we own d, prevent the cache from freeing it
268 * when we delete the entry.
270 talloc_set_destructor(d, share_mode_data_nofree_destructor);
272 /* Remove from the cache. We own it now. */
273 memcache_delete(NULL,
274 SHARE_MODE_LOCK_CACHE,
277 /* And reset the destructor to none. */
278 talloc_set_destructor(d, NULL);
280 DEBUG(10,("fetched entry for file %s seq 0x%llu key %s\n",
282 (unsigned long long)d->sequence_number,
283 file_id_string(mem_ctx, &id)));
288 /*******************************************************************
289 Get all share mode entries for a dev/inode pair.
290 ********************************************************************/
292 static struct share_mode_data *parse_share_modes(TALLOC_CTX *mem_ctx,
296 struct share_mode_data *d;
297 enum ndr_err_code ndr_err;
301 blob.data = dbuf.dptr;
302 blob.length = dbuf.dsize;
304 /* See if we already have a cached copy of this key. */
305 d = share_mode_memcache_fetch(mem_ctx, key, &blob);
310 d = talloc(mem_ctx, struct share_mode_data);
312 DEBUG(0, ("talloc failed\n"));
316 ndr_err = ndr_pull_struct_blob_all(
317 &blob, d, d, (ndr_pull_flags_fn_t)ndr_pull_share_mode_data);
318 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
319 DEBUG(1, ("ndr_pull_share_mode_lock failed: %s\n",
320 ndr_errstr(ndr_err)));
325 * Initialize the values that are [skip] in the idl. The NDR code does
326 * not initialize them.
329 for (i=0; i<d->num_share_modes; i++) {
330 struct share_mode_entry *e = &d->share_modes[i];
334 if (e->op_type != LEASE_OPLOCK) {
337 if (e->lease_idx >= d->num_leases) {
340 e->lease = &d->leases[e->lease_idx];
345 if (DEBUGLEVEL >= 10) {
346 DEBUG(10, ("parse_share_modes:\n"));
347 NDR_PRINT_DEBUG(share_mode_data, d);
356 /*******************************************************************
357 Create a storable data blob from a modified share_mode_data struct.
358 ********************************************************************/
360 static TDB_DATA unparse_share_modes(struct share_mode_data *d)
363 enum ndr_err_code ndr_err;
365 if (DEBUGLEVEL >= 10) {
366 DEBUG(10, ("unparse_share_modes:\n"));
367 NDR_PRINT_DEBUG(share_mode_data, d);
370 share_mode_memcache_delete(d);
372 /* Update the sequence number. */
373 d->sequence_number += 1;
375 remove_stale_share_mode_entries(d);
377 if (d->num_share_modes == 0) {
378 DEBUG(10, ("No used share mode found\n"));
379 return make_tdb_data(NULL, 0);
382 ndr_err = ndr_push_struct_blob(
383 &blob, d, d, (ndr_push_flags_fn_t)ndr_push_share_mode_data);
384 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
385 smb_panic("ndr_push_share_mode_lock failed");
388 return make_tdb_data(blob.data, blob.length);
391 /*******************************************************************
392 If modified, store the share_mode_data back into the database.
393 ********************************************************************/
395 static int share_mode_data_destructor(struct share_mode_data *d)
404 data = unparse_share_modes(d);
406 if (data.dptr == NULL) {
408 /* There has been an entry before, delete it */
410 status = dbwrap_record_delete(d->record);
411 if (!NT_STATUS_IS_OK(status)) {
414 DEBUG(0, ("delete_rec returned %s\n",
417 if (asprintf(&errmsg, "could not delete share "
419 nt_errstr(status)) == -1) {
420 smb_panic("could not delete share"
427 * Nothing to store in cache - allow the normal
428 * release of record lock and memory free.
433 status = dbwrap_record_store(d->record, data, TDB_REPLACE);
434 if (!NT_STATUS_IS_OK(status)) {
437 DEBUG(0, ("store returned %s\n", nt_errstr(status)));
439 if (asprintf(&errmsg, "could not store share mode entry: %s",
440 nt_errstr(status)) == -1) {
441 smb_panic("could not store share mode entry");
447 * Release the record lock before putting in the cache.
449 TALLOC_FREE(d->record);
452 * Release the dptr as well before reparenting to NULL
453 * (in-memory cache) context.
455 TALLOC_FREE(data.dptr);
457 * Reparent d into the in-memory cache so it can be reused if the
458 * sequence number matches. See parse_share_modes()
462 share_mode_memcache_store(d);
466 /*******************************************************************
467 Allocate a new share_mode_data struct, mark it unmodified.
468 fresh is set to note that currently there is no database entry.
469 ********************************************************************/
471 static struct share_mode_data *fresh_share_mode_lock(
472 TALLOC_CTX *mem_ctx, const char *servicepath,
473 const struct smb_filename *smb_fname,
474 const struct timespec *old_write_time)
476 struct share_mode_data *d;
478 if ((servicepath == NULL) || (smb_fname == NULL) ||
479 (old_write_time == NULL)) {
483 d = talloc_zero(mem_ctx, struct share_mode_data);
487 /* New record - new sequence number. */
488 generate_random_buffer((uint8_t *)&d->sequence_number, 8);
490 d->base_name = talloc_strdup(d, smb_fname->base_name);
491 if (d->base_name == NULL) {
494 if (smb_fname->stream_name != NULL) {
495 d->stream_name = talloc_strdup(d, smb_fname->stream_name);
496 if (d->stream_name == NULL) {
500 d->servicepath = talloc_strdup(d, servicepath);
501 if (d->servicepath == NULL) {
504 d->old_write_time = *old_write_time;
509 DEBUG(0, ("talloc failed\n"));
514 /*******************************************************************
515 Either fetch a share mode from the database, or allocate a fresh
516 one if the record doesn't exist.
517 ********************************************************************/
519 static struct share_mode_lock *get_share_mode_lock_internal(
520 TALLOC_CTX *mem_ctx, struct file_id id,
521 const char *servicepath, const struct smb_filename *smb_fname,
522 const struct timespec *old_write_time)
524 struct share_mode_lock *lck;
525 struct share_mode_data *d;
526 struct db_record *rec;
527 TDB_DATA key = locking_key(&id);
530 rec = dbwrap_fetch_locked(lock_db, mem_ctx, key);
532 DEBUG(3, ("Could not lock share entry\n"));
536 value = dbwrap_record_get_value(rec);
538 if (value.dptr == NULL) {
539 d = fresh_share_mode_lock(mem_ctx, servicepath, smb_fname,
542 d = parse_share_modes(mem_ctx, key, value);
546 DEBUG(5, ("get_share_mode_lock_internal: "
547 "Could not get share mode lock\n"));
552 d->record = talloc_move(d, &rec);
553 talloc_set_destructor(d, share_mode_data_destructor);
555 lck = talloc(mem_ctx, struct share_mode_lock);
557 DEBUG(1, ("talloc failed\n"));
561 lck->data = talloc_move(lck, &d);
566 * We can only ever have one share mode locked. Users of
567 * get_share_mode_lock never see this, it will be refcounted by
570 static struct share_mode_lock *the_lock;
571 static struct file_id the_lock_id;
573 static int the_lock_destructor(struct share_mode_lock *l)
576 ZERO_STRUCT(the_lock_id);
580 /*******************************************************************
581 Get a share_mode_lock, Reference counted to allow nested calls.
582 ********************************************************************/
584 struct share_mode_lock *get_share_mode_lock(
587 const char *servicepath,
588 const struct smb_filename *smb_fname,
589 const struct timespec *old_write_time)
591 struct share_mode_lock *lck;
593 lck = talloc(mem_ctx, struct share_mode_lock);
595 DEBUG(1, ("talloc failed\n"));
599 if (the_lock == NULL) {
600 the_lock = get_share_mode_lock_internal(
601 lck, id, servicepath, smb_fname, old_write_time);
602 if (the_lock == NULL) {
605 talloc_set_destructor(the_lock, the_lock_destructor);
608 if (!file_id_equal(&the_lock_id, &id)) {
609 DEBUG(1, ("Can not lock two share modes "
610 "simultaneously\n"));
613 if (talloc_reference(lck, the_lock) == NULL) {
614 DEBUG(1, ("talloc_reference failed\n"));
618 lck->data = the_lock->data;
625 static void fetch_share_mode_unlocked_parser(
626 TDB_DATA key, TDB_DATA data, void *private_data)
628 struct share_mode_lock *lck = talloc_get_type_abort(
629 private_data, struct share_mode_lock);
631 lck->data = parse_share_modes(lck, key, data);
634 /*******************************************************************
635 Get a share_mode_lock without locking the database or reference
636 counting. Used by smbstatus to display existing share modes.
637 ********************************************************************/
639 struct share_mode_lock *fetch_share_mode_unlocked(TALLOC_CTX *mem_ctx,
642 struct share_mode_lock *lck;
643 TDB_DATA key = locking_key(&id);
646 lck = talloc(mem_ctx, struct share_mode_lock);
648 DEBUG(0, ("talloc failed\n"));
651 status = dbwrap_parse_record(
652 lock_db, key, fetch_share_mode_unlocked_parser, lck);
653 if (!NT_STATUS_IS_OK(status) ||
654 (lck->data == NULL)) {
661 struct share_mode_forall_state {
662 int (*fn)(struct file_id fid, const struct share_mode_data *data,
667 static int share_mode_traverse_fn(struct db_record *rec, void *_state)
669 struct share_mode_forall_state *state =
670 (struct share_mode_forall_state *)_state;
675 enum ndr_err_code ndr_err;
676 struct share_mode_data *d;
680 key = dbwrap_record_get_key(rec);
681 value = dbwrap_record_get_value(rec);
683 /* Ensure this is a locking_key record. */
684 if (key.dsize != sizeof(fid)) {
687 memcpy(&fid, key.dptr, sizeof(fid));
689 d = talloc(talloc_tos(), struct share_mode_data);
694 blob.data = value.dptr;
695 blob.length = value.dsize;
697 ndr_err = ndr_pull_struct_blob_all(
698 &blob, d, d, (ndr_pull_flags_fn_t)ndr_pull_share_mode_data);
699 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
700 DEBUG(1, ("ndr_pull_share_mode_lock failed\n"));
704 for (i=0; i<d->num_share_modes; i++) {
705 struct share_mode_entry *entry = &d->share_modes[i];
706 entry->stale = false; /* [skip] in idl */
707 entry->lease = &d->leases[entry->lease_idx];
710 if (DEBUGLEVEL > 10) {
711 DEBUG(11, ("parse_share_modes:\n"));
712 NDR_PRINT_DEBUG(share_mode_data, d);
715 ret = state->fn(fid, d, state->private_data);
721 int share_mode_forall(int (*fn)(struct file_id fid,
722 const struct share_mode_data *data,
726 struct share_mode_forall_state state = {
728 .private_data = private_data
733 if (lock_db == NULL) {
737 status = dbwrap_traverse_read(lock_db, share_mode_traverse_fn,
739 if (!NT_STATUS_IS_OK(status)) {
746 struct share_entry_forall_state {
747 int (*fn)(const struct share_mode_entry *e,
748 const char *service_path,
749 const char *base_name,
750 const char *stream_name,
755 static int share_entry_traverse_fn(struct file_id fid,
756 const struct share_mode_data *data,
759 struct share_entry_forall_state *state = private_data;
762 for (i=0; i<data->num_share_modes; i++) {
765 ret = state->fn(&data->share_modes[i],
769 state->private_data);
778 /*******************************************************************
779 Call the specified function on each entry under management by the
781 ********************************************************************/
783 int share_entry_forall(int (*fn)(const struct share_mode_entry *,
784 const char *, const char *,
785 const char *, void *),
788 struct share_entry_forall_state state = {
789 .fn = fn, .private_data = private_data };
791 return share_mode_forall(share_entry_traverse_fn, &state);
794 bool share_mode_cleanup_disconnected(struct file_id fid,
795 uint64_t open_persistent_id)
798 TALLOC_CTX *frame = talloc_stackframe();
800 struct share_mode_data *data;
801 struct share_mode_lock *lck;
804 lck = get_existing_share_mode_lock(frame, fid);
806 DEBUG(5, ("share_mode_cleanup_disconnected: "
807 "Could not fetch share mode entry for %s\n",
808 file_id_string(frame, &fid)));
813 for (n=0; n < data->num_share_modes; n++) {
814 struct share_mode_entry *entry = &data->share_modes[n];
816 if (!server_id_is_disconnected(&entry->pid)) {
817 struct server_id_buf tmp;
818 DEBUG(5, ("share_mode_cleanup_disconnected: "
819 "file (file-id='%s', servicepath='%s', "
820 "base_name='%s%s%s') "
821 "is used by server %s ==> do not cleanup\n",
822 file_id_string(frame, &fid),
825 (data->stream_name == NULL)
826 ? "" : "', stream_name='",
827 (data->stream_name == NULL)
828 ? "" : data->stream_name,
829 server_id_str_buf(entry->pid, &tmp)));
832 if (open_persistent_id != entry->share_file_id) {
833 DEBUG(5, ("share_mode_cleanup_disconnected: "
835 "(file-id='%s', servicepath='%s', "
836 "base_name='%s%s%s') "
837 "has share_file_id %llu but expected %llu"
838 "==> do not cleanup\n",
839 file_id_string(frame, &fid),
842 (data->stream_name == NULL)
843 ? "" : "', stream_name='",
844 (data->stream_name == NULL)
845 ? "" : data->stream_name,
846 (unsigned long long)entry->share_file_id,
847 (unsigned long long)open_persistent_id));
852 for (n=0; n < data->num_leases; n++) {
853 struct share_mode_lease *l = &data->leases[n];
856 status = leases_db_del(&l->client_guid, &l->lease_key, &fid);
858 DEBUG(10, ("%s: leases_db_del returned %s\n", __func__,
862 ok = brl_cleanup_disconnected(fid, open_persistent_id);
864 DEBUG(10, ("share_mode_cleanup_disconnected: "
865 "failed to clean up byte range locks associated "
866 "with file (file-id='%s', servicepath='%s', "
867 "base_name='%s%s%s') and open_persistent_id %llu "
868 "==> do not cleanup\n",
869 file_id_string(frame, &fid),
872 (data->stream_name == NULL)
873 ? "" : "', stream_name='",
874 (data->stream_name == NULL)
875 ? "" : data->stream_name,
876 (unsigned long long)open_persistent_id));
880 DEBUG(10, ("share_mode_cleanup_disconnected: "
881 "cleaning up %u entries for file "
882 "(file-id='%s', servicepath='%s', "
883 "base_name='%s%s%s') "
884 "from open_persistent_id %llu\n",
885 data->num_share_modes,
886 file_id_string(frame, &fid),
889 (data->stream_name == NULL)
890 ? "" : "', stream_name='",
891 (data->stream_name == NULL)
892 ? "" : data->stream_name,
893 (unsigned long long)open_persistent_id));
895 data->num_share_modes = 0;
896 data->num_leases = 0;
897 data->modified = true;