2 Unix SMB/CIFS implementation.
4 Copyright (C) Andrew Tridgell 1992-2000
5 Copyright (C) Jeremy Allison 1992-2000
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 2 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, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 12 aug 96: Erik.Devriendt@te6.siemens.be
25 added support for shared memory implementation of share mode locking
27 May 1997. Jeremy Allison (jallison@whistle.com). Modified share mode
28 locking to deal with multiple share modes per open file.
30 September 1997. Jeremy Allison (jallison@whistle.com). Added oplock
33 rewrtten completely to use new tdb code. Tridge, Dec '99
35 Added POSIX locking support. Jeremy Allison (jeremy@valinux.com), Apr. 2000.
42 #define DBGC_CLASS DBGC_LOCKING
44 /* the locking database handle */
45 static TDB_CONTEXT *tdb;
50 int num_share_mode_entries;
53 struct share_mode_entry dummy; /* Needed for alignment. */
55 /* the following two entries are implicit
56 struct share_mode_entry modes[num_share_mode_entries];
61 /****************************************************************************
63 ****************************************************************************/
65 static const char *lock_type_name(enum brl_type lock_type)
67 return (lock_type == READ_LOCK) ? "READ" : "WRITE";
70 /****************************************************************************
71 Utility function called to see if a file region is locked.
72 ****************************************************************************/
74 BOOL is_locked(files_struct *fsp,connection_struct *conn,
75 SMB_BIG_UINT count,SMB_BIG_UINT offset,
76 enum brl_type lock_type)
78 int snum = SNUM(conn);
79 int strict_locking = lp_strict_locking(snum);
85 if (!lp_locking(snum) || !strict_locking)
88 if (strict_locking == Auto) {
89 if (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type) && (lock_type == READ_LOCK || lock_type == WRITE_LOCK)) {
90 DEBUG(10,("is_locked: optimisation - exclusive oplock on file %s\n", fsp->fsp_name ));
92 } else if ((fsp->oplock_type == LEVEL_II_OPLOCK) &&
93 (lock_type == READ_LOCK)) {
94 DEBUG(10,("is_locked: optimisation - level II oplock on file %s\n", fsp->fsp_name ));
97 ret = !brl_locktest(fsp->dev, fsp->inode, fsp->fnum,
98 global_smbpid, procid_self(), conn->cnum,
99 offset, count, lock_type);
102 ret = !brl_locktest(fsp->dev, fsp->inode, fsp->fnum,
103 global_smbpid, procid_self(), conn->cnum,
104 offset, count, lock_type);
107 DEBUG(10,("is_locked: brl start=%.0f len=%.0f %s for file %s\n",
108 (double)offset, (double)count, ret ? "locked" : "unlocked",
112 * There is no lock held by an SMB daemon, check to
113 * see if there is a POSIX lock from a UNIX or NFS process.
116 if(!ret && lp_posix_locking(snum)) {
117 ret = is_posix_locked(fsp, offset, count, lock_type);
119 DEBUG(10,("is_locked: posix start=%.0f len=%.0f %s for file %s\n",
120 (double)offset, (double)count, ret ? "locked" : "unlocked",
127 /****************************************************************************
128 Utility function called by locking requests.
129 ****************************************************************************/
131 static NTSTATUS do_lock(files_struct *fsp,connection_struct *conn, uint16 lock_pid,
132 SMB_BIG_UINT count,SMB_BIG_UINT offset,enum brl_type lock_type, BOOL *my_lock_ctx)
134 NTSTATUS status = NT_STATUS_LOCK_NOT_GRANTED;
136 if (!lp_locking(SNUM(conn)))
139 /* NOTE! 0 byte long ranges ARE allowed and should be stored */
141 DEBUG(10,("do_lock: lock type %s start=%.0f len=%.0f requested for file %s\n",
142 lock_type_name(lock_type), (double)offset, (double)count, fsp->fsp_name ));
144 if (OPEN_FSP(fsp) && fsp->can_lock && (fsp->conn == conn)) {
145 status = brl_lock(fsp->dev, fsp->inode, fsp->fnum,
146 lock_pid, procid_self(), conn->cnum,
148 lock_type, my_lock_ctx);
150 if (NT_STATUS_IS_OK(status) && lp_posix_locking(SNUM(conn))) {
153 * Try and get a POSIX lock on this range.
154 * Note that this is ok if it is a read lock
155 * overlapping on a different fd. JRA.
158 if (!set_posix_lock(fsp, offset, count, lock_type)) {
159 if (errno == EACCES || errno == EAGAIN)
160 status = NT_STATUS_FILE_LOCK_CONFLICT;
162 status = map_nt_error_from_unix(errno);
165 * We failed to map - we must now remove the brl
168 (void)brl_unlock(fsp->dev, fsp->inode, fsp->fnum,
169 lock_pid, procid_self(), conn->cnum,
170 offset, count, False,
179 /****************************************************************************
180 Utility function called by locking requests. This is *DISGUSTING*. It also
181 appears to be "What Windows Does" (tm). Andrew, ever wonder why Windows 2000
182 is so slow on the locking tests...... ? This is the reason. Much though I hate
183 it, we need this. JRA.
184 ****************************************************************************/
186 NTSTATUS do_lock_spin(files_struct *fsp,connection_struct *conn, uint16 lock_pid,
187 SMB_BIG_UINT count,SMB_BIG_UINT offset,enum brl_type lock_type, BOOL *my_lock_ctx)
189 int j, maxj = lp_lock_spin_count();
190 int sleeptime = lp_lock_sleep_time();
191 NTSTATUS status, ret;
196 ret = NT_STATUS_OK; /* to keep dumb compilers happy */
198 for (j = 0; j < maxj; j++) {
199 status = do_lock(fsp, conn, lock_pid, count, offset, lock_type, my_lock_ctx);
200 if (!NT_STATUS_EQUAL(status, NT_STATUS_LOCK_NOT_GRANTED) &&
201 !NT_STATUS_EQUAL(status, NT_STATUS_FILE_LOCK_CONFLICT)) {
204 /* if we do fail then return the first error code we got */
207 /* Don't spin if we blocked ourselves. */
212 sys_usleep(sleeptime);
217 /* Struct passed to brl_unlock. */
218 struct posix_unlock_data_struct {
224 /****************************************************************************
225 Function passed to brl_unlock to allow POSIX unlock to be done first.
226 ****************************************************************************/
228 static void posix_unlock(void *pre_data)
230 struct posix_unlock_data_struct *pdata = (struct posix_unlock_data_struct *)pre_data;
232 if (lp_posix_locking(SNUM(pdata->fsp->conn)))
233 release_posix_lock(pdata->fsp, pdata->offset, pdata->count);
236 /****************************************************************************
237 Utility function called by unlocking requests.
238 ****************************************************************************/
240 NTSTATUS do_unlock(files_struct *fsp,connection_struct *conn, uint16 lock_pid,
241 SMB_BIG_UINT count,SMB_BIG_UINT offset)
244 struct posix_unlock_data_struct posix_data;
246 if (!lp_locking(SNUM(conn)))
249 if (!OPEN_FSP(fsp) || !fsp->can_lock || (fsp->conn != conn)) {
250 return NT_STATUS_INVALID_HANDLE;
253 DEBUG(10,("do_unlock: unlock start=%.0f len=%.0f requested for file %s\n",
254 (double)offset, (double)count, fsp->fsp_name ));
257 * Remove the existing lock record from the tdb lockdb
258 * before looking at POSIX locks. If this record doesn't
259 * match then don't bother looking to remove POSIX locks.
262 posix_data.fsp = fsp;
263 posix_data.offset = offset;
264 posix_data.count = count;
266 ok = brl_unlock(fsp->dev, fsp->inode, fsp->fnum,
267 lock_pid, procid_self(), conn->cnum, offset, count,
268 False, posix_unlock, (void *)&posix_data);
271 DEBUG(10,("do_unlock: returning ERRlock.\n" ));
272 return NT_STATUS_RANGE_NOT_LOCKED;
277 /****************************************************************************
278 Remove any locks on this fd. Called from file_close().
279 ****************************************************************************/
281 void locking_close_file(files_struct *fsp)
283 struct process_id pid = procid_self();
285 if (!lp_locking(SNUM(fsp->conn)))
289 * Just release all the brl locks, no need to release individually.
292 brl_close(fsp->dev, fsp->inode, pid, fsp->conn->cnum, fsp->fnum);
294 if(lp_posix_locking(SNUM(fsp->conn))) {
297 * Release all the POSIX locks.
299 posix_locking_close_file(fsp);
304 /****************************************************************************
305 Initialise the locking functions.
306 ****************************************************************************/
308 static int open_read_only;
310 BOOL locking_init(int read_only)
317 tdb = tdb_open_log(lock_path("locking.tdb"),
318 SMB_OPEN_DATABASE_TDB_HASH_SIZE, TDB_DEFAULT|(read_only?0x0:TDB_CLEAR_IF_FIRST),
319 read_only?O_RDONLY:O_RDWR|O_CREAT,
323 DEBUG(0,("ERROR: Failed to initialise locking database\n"));
327 if (!posix_locking_init(read_only))
330 open_read_only = read_only;
335 /*******************************************************************
336 Deinitialize the share_mode management.
337 ******************************************************************/
339 BOOL locking_end(void)
343 brl_shutdown(open_read_only);
345 if (tdb_close(tdb) != 0)
352 /*******************************************************************
353 Form a static locking key for a dev/inode pair.
354 ******************************************************************/
356 /* key and data records in the tdb locking database */
362 /*******************************************************************
363 Form a static locking key for a dev/inode pair.
364 ******************************************************************/
366 static TDB_DATA locking_key(SMB_DEV_T dev, SMB_INO_T inode)
368 static struct locking_key key;
371 memset(&key, '\0', sizeof(key));
374 kbuf.dptr = (char *)&key;
375 kbuf.dsize = sizeof(key);
379 /*******************************************************************
380 Print out a share mode.
381 ********************************************************************/
383 char *share_mode_str(int num, struct share_mode_entry *e)
385 static pstring share_str;
387 slprintf(share_str, sizeof(share_str)-1, "share_mode_entry[%d]: "
388 "pid = %s, share_access = 0x%x, private_options = 0x%x, "
389 "access_mask = 0x%x, mid = 0x%x, type= 0x%x, file_id = %lu, "
390 "dev = 0x%x, inode = %.0f",
391 num, procid_str_static(&e->pid),
392 e->share_access, e->private_options,
393 e->access_mask, e->op_mid, e->op_type, e->share_file_id,
394 (unsigned int)e->dev, (double)e->inode );
399 /*******************************************************************
400 Print out a share mode table.
401 ********************************************************************/
403 static void print_share_mode_table(struct locking_data *data)
405 int num_share_modes = data->u.s.num_share_mode_entries;
406 struct share_mode_entry *shares =
407 (struct share_mode_entry *)(data + 1);
410 for (i = 0; i < num_share_modes; i++) {
411 struct share_mode_entry *entry_p = &shares[i];
412 DEBUG(10,("print_share_mode_table: %s\n",
413 share_mode_str(i, entry_p)));
417 /*******************************************************************
418 Get all share mode entries for a dev/inode pair.
419 ********************************************************************/
421 static BOOL parse_share_modes(TDB_DATA dbuf, struct share_mode_lock *lck)
423 struct locking_data *data;
426 if (dbuf.dsize < sizeof(struct locking_data)) {
427 DEBUG(0, ("parse_share_modes: buffer too short\n"));
431 data = (struct locking_data *)dbuf.dptr;
433 lck->delete_on_close = data->u.s.delete_on_close;
434 lck->num_share_modes = data->u.s.num_share_mode_entries;
436 DEBUG(10, ("parse_share_modes: delete_on_close: %d, "
437 "num_share_modes: %d\n", lck->delete_on_close,
438 lck->num_share_modes));
440 if ((lck->num_share_modes < 0) || (lck->num_share_modes > 1000000)) {
441 DEBUG(0, ("invalid number of share modes: %d\n",
442 lck->num_share_modes));
446 lck->share_modes = NULL;
448 if (lck->num_share_modes != 0) {
450 if (dbuf.dsize < (sizeof(struct locking_data) +
451 (lck->num_share_modes *
452 sizeof(struct share_mode_entry)))) {
453 DEBUG(0, ("parse_share_modes: buffer too short\n"));
457 lck->share_modes = talloc_memdup(lck, dbuf.dptr+sizeof(*data),
458 lck->num_share_modes *
459 sizeof(struct share_mode_entry));
461 if (lck->share_modes == NULL) {
462 DEBUG(0, ("talloc failed\n"));
467 /* Save off the associated service path and filename. */
468 lck->servicepath = talloc_strdup(lck, dbuf.dptr + sizeof(*data) +
469 (lck->num_share_modes *
470 sizeof(struct share_mode_entry)));
472 lck->filename = talloc_strdup(lck, dbuf.dptr + sizeof(*data) +
473 (lck->num_share_modes *
474 sizeof(struct share_mode_entry)) +
475 strlen(lck->servicepath) + 1 );
478 * Ensure that each entry has a real process attached.
481 for (i = 0; i < lck->num_share_modes; i++) {
482 struct share_mode_entry *entry_p = &lck->share_modes[i];
483 DEBUG(10,("parse_share_modes: %s\n",
484 share_mode_str(i, entry_p) ));
485 if (!process_exists(entry_p->pid)) {
486 DEBUG(10,("parse_share_modes: deleted %s\n",
487 share_mode_str(i, entry_p) ));
488 entry_p->op_type = UNUSED_SHARE_MODE_ENTRY;
489 lck->modified = True;
496 static TDB_DATA unparse_share_modes(struct share_mode_lock *lck)
501 struct locking_data *data;
508 for (i=0; i<lck->num_share_modes; i++) {
509 if (!is_unused_share_mode_entry(&lck->share_modes[i])) {
514 if (num_valid == 0) {
518 sp_len = strlen(lck->servicepath);
520 result.dsize = sizeof(*data) +
521 lck->num_share_modes * sizeof(struct share_mode_entry) +
523 strlen(lck->filename) + 1;
524 result.dptr = talloc_size(lck, result.dsize);
526 if (result.dptr == NULL) {
527 smb_panic("talloc failed\n");
530 data = (struct locking_data *)result.dptr;
532 data->u.s.num_share_mode_entries = lck->num_share_modes;
533 data->u.s.delete_on_close = lck->delete_on_close;
534 DEBUG(10, ("unparse_share_modes: del: %d, num: %d\n",
535 data->u.s.delete_on_close,
536 data->u.s.num_share_mode_entries));
537 memcpy(result.dptr + sizeof(*data), lck->share_modes,
538 sizeof(struct share_mode_entry)*lck->num_share_modes);
539 offset = sizeof(*data) +
540 sizeof(struct share_mode_entry)*lck->num_share_modes;
541 safe_strcpy(result.dptr + offset, lck->servicepath,
542 result.dsize - offset - 1);
543 offset += sp_len + 1;
544 safe_strcpy(result.dptr + offset, lck->filename,
545 result.dsize - offset - 1);
546 print_share_mode_table(data);
550 static int share_mode_lock_destructor(void *p)
552 struct share_mode_lock *lck =
553 talloc_get_type_abort(p, struct share_mode_lock);
554 TDB_DATA key = locking_key(lck->dev, lck->ino);
557 if (!lck->modified) {
561 data = unparse_share_modes(lck);
563 if (data.dptr == NULL) {
565 /* There has been an entry before, delete it */
566 if (tdb_delete(tdb, key) == -1) {
567 smb_panic("Could not delete share entry\n");
573 if (tdb_store(tdb, key, data, TDB_REPLACE) == -1) {
574 smb_panic("Could not store share mode entry\n");
578 tdb_chainunlock(tdb, key);
583 struct share_mode_lock *get_share_mode_lock(TALLOC_CTX *mem_ctx,
584 SMB_DEV_T dev, SMB_INO_T ino,
585 const char *servicepath,
588 struct share_mode_lock *lck;
589 TDB_DATA key = locking_key(dev, ino);
592 lck = TALLOC_P(mem_ctx, struct share_mode_lock);
594 DEBUG(0, ("talloc failed\n"));
598 /* Ensure we set every field here as the destructor must be
599 valid even if parse_share_modes fails. */
601 lck->servicepath = NULL;
602 lck->filename = NULL;
605 lck->num_share_modes = 0;
606 lck->share_modes = NULL;
607 lck->delete_on_close = False;
608 lck->modified = False;
611 if (tdb_chainlock(tdb, key) != 0) {
612 DEBUG(3, ("Could not lock share entry\n"));
617 /* We must set the destructor immediately after the chainlock
618 ensure the lock is cleaned up on any of the error return
621 talloc_set_destructor(lck, share_mode_lock_destructor);
623 data = tdb_fetch(tdb, key);
624 lck->fresh = (data.dptr == NULL);
628 if (fname == NULL || servicepath == NULL) {
629 DEBUG(0, ("New file, but no filename or servicepath supplied\n"));
633 lck->filename = talloc_strdup(lck, fname);
634 lck->servicepath = talloc_strdup(lck, servicepath);
635 if (lck->filename == NULL || lck->servicepath == NULL) {
636 DEBUG(0, ("talloc failed\n"));
641 if (!parse_share_modes(data, lck)) {
642 DEBUG(0, ("Could not parse share modes\n"));
644 SAFE_FREE(data.dptr);
649 SAFE_FREE(data.dptr);
654 /*******************************************************************
655 Sets the service name and filename for rename.
656 At this point we emit "file renamed" messages to all
657 process id's that have this file open.
658 Based on an initial code idea from SATOH Fumiyasu <fumiya@samba.gr.jp>
659 ********************************************************************/
661 BOOL rename_share_filename(struct share_mode_lock *lck,
662 const char *servicepath,
665 struct file_renamed_message *frm = NULL;
671 DEBUG(10, ("rename_share_filename: servicepath %s newname %s\n",
672 servicepath, newname));
675 * rename_internal_fsp() and rename_internals() add './' to
676 * head of newname if newname does not contain a '/'.
678 while (newname[0] && newname[1] && newname[0] == '.' && newname[1] == '/') {
682 lck->servicepath = talloc_strdup(lck, servicepath);
683 lck->filename = talloc_strdup(lck, newname);
684 if (lck->filename == NULL || lck->servicepath == NULL) {
685 DEBUG(0, ("rename_share_filename: talloc failed\n"));
688 lck->modified = True;
690 sp_len = strlen(lck->servicepath);
691 fn_len = strlen(lck->filename);
693 msg_len = sizeof(*frm) + sp_len + 1 + fn_len + 1;
695 /* Set up the name changed message. */
696 frm = TALLOC(lck, msg_len);
701 frm->inode = lck->ino;
703 DEBUG(10,("rename_share_filename: msg_len = %d\n", msg_len ));
705 safe_strcpy(&frm->names[0], lck->servicepath, sp_len);
706 safe_strcpy(&frm->names[sp_len + 1], lck->filename, fn_len);
708 /* Send the messages. */
709 for (i=0; i<lck->num_share_modes; i++) {
710 struct share_mode_entry *se = &lck->share_modes[i];
711 if (!is_valid_share_mode_entry(se)) {
714 /* But not to ourselves... */
715 if (procid_is_me(&se->pid)) {
719 DEBUG(10,("rename_share_filename: sending rename message to pid %u "
720 "dev %x, inode %.0f sharepath %s newname %s\n",
721 (unsigned int)procid_to_pid(&se->pid),
722 (unsigned int)frm->dev, (double)frm->inode,
723 lck->servicepath, lck->filename ));
725 message_send_pid(se->pid, MSG_SMB_FILE_RENAME,
732 BOOL get_delete_on_close_flag(SMB_DEV_T dev, SMB_INO_T inode)
735 struct share_mode_lock *lck = get_share_mode_lock(NULL, dev, inode, NULL, NULL);
739 result = lck->delete_on_close;
744 BOOL is_valid_share_mode_entry(const struct share_mode_entry *e)
748 num_props += ((e->op_type == NO_OPLOCK) ? 1 : 0);
749 num_props += (EXCLUSIVE_OPLOCK_TYPE(e->op_type) ? 1 : 0);
750 num_props += (LEVEL_II_OPLOCK_TYPE(e->op_type) ? 1 : 0);
752 SMB_ASSERT(num_props <= 1);
753 return (num_props != 0);
756 BOOL is_deferred_open_entry(const struct share_mode_entry *e)
758 return (e->op_type == DEFERRED_OPEN_ENTRY);
761 BOOL is_unused_share_mode_entry(const struct share_mode_entry *e)
763 return (e->op_type == UNUSED_SHARE_MODE_ENTRY);
766 /*******************************************************************
767 Fill a share mode entry.
768 ********************************************************************/
770 static void fill_share_mode_entry(struct share_mode_entry *e,
772 uint16 mid, uint16 op_type)
775 e->pid = procid_self();
776 e->share_access = fsp->share_access;
777 e->private_options = fsp->fh->private_options;
778 e->access_mask = fsp->access_mask;
780 e->op_type = op_type;
781 e->time.tv_sec = fsp->open_time.tv_sec;
782 e->time.tv_usec = fsp->open_time.tv_usec;
783 e->share_file_id = fsp->file_id;
785 e->inode = fsp->inode;
788 static void fill_deferred_open_entry(struct share_mode_entry *e,
789 const struct timeval request_time,
790 SMB_DEV_T dev, SMB_INO_T ino, uint16 mid)
793 e->pid = procid_self();
795 e->op_type = DEFERRED_OPEN_ENTRY;
796 e->time.tv_sec = request_time.tv_sec;
797 e->time.tv_usec = request_time.tv_usec;
802 static void add_share_mode_entry(struct share_mode_lock *lck,
803 const struct share_mode_entry *entry)
807 for (i=0; i<lck->num_share_modes; i++) {
808 struct share_mode_entry *e = &lck->share_modes[i];
809 if (is_unused_share_mode_entry(e)) {
815 if (i == lck->num_share_modes) {
816 /* No unused entry found */
817 ADD_TO_ARRAY(lck, struct share_mode_entry, *entry,
818 &lck->share_modes, &lck->num_share_modes);
820 lck->modified = True;
823 void set_share_mode(struct share_mode_lock *lck, files_struct *fsp,
824 uint16 mid, uint16 op_type)
826 struct share_mode_entry entry;
827 fill_share_mode_entry(&entry, fsp, mid, op_type);
828 add_share_mode_entry(lck, &entry);
831 void add_deferred_open(struct share_mode_lock *lck, uint16 mid,
832 struct timeval request_time,
833 SMB_DEV_T dev, SMB_INO_T ino)
835 struct share_mode_entry entry;
836 fill_deferred_open_entry(&entry, request_time, dev, ino, mid);
837 add_share_mode_entry(lck, &entry);
840 /*******************************************************************
841 Check if two share mode entries are identical, ignoring oplock
842 and mid info and desired_access.
843 ********************************************************************/
845 static BOOL share_modes_identical(struct share_mode_entry *e1,
846 struct share_mode_entry *e2)
848 #if 1 /* JRA PARANOIA TEST - REMOVE LATER */
849 if (procid_equal(&e1->pid, &e2->pid) &&
850 e1->share_file_id == e2->share_file_id &&
851 e1->dev == e2->dev &&
852 e1->inode == e2->inode &&
853 (e1->share_access) != (e2->share_access)) {
854 DEBUG(0,("PANIC: share_modes_identical: share_mode "
855 "mismatch (e1 = 0x%x, e2 = 0x%x). Logic error.\n",
856 (unsigned int)e1->share_access,
857 (unsigned int)e2->share_access ));
858 smb_panic("PANIC: share_modes_identical logic error.\n");
862 return (procid_equal(&e1->pid, &e2->pid) &&
863 (e1->share_access) == (e2->share_access) &&
864 e1->dev == e2->dev &&
865 e1->inode == e2->inode &&
866 e1->share_file_id == e2->share_file_id );
869 static BOOL deferred_open_identical(struct share_mode_entry *e1,
870 struct share_mode_entry *e2)
872 return (procid_equal(&e1->pid, &e2->pid) &&
873 (e1->op_mid == e2->op_mid) &&
874 (e1->dev == e2->dev) &&
875 (e1->inode == e2->inode));
878 static struct share_mode_entry *find_share_mode_entry(struct share_mode_lock *lck,
879 struct share_mode_entry *entry)
883 for (i=0; i<lck->num_share_modes; i++) {
884 struct share_mode_entry *e = &lck->share_modes[i];
885 if (is_valid_share_mode_entry(entry) &&
886 is_valid_share_mode_entry(e) &&
887 share_modes_identical(e, entry)) {
890 if (is_deferred_open_entry(entry) &&
891 is_deferred_open_entry(e) &&
892 deferred_open_identical(e, entry)) {
899 /*******************************************************************
900 Del the share mode of a file for this process. Return the number of
902 ********************************************************************/
904 BOOL del_share_mode(struct share_mode_lock *lck, files_struct *fsp)
906 struct share_mode_entry entry, *e;
908 fill_share_mode_entry(&entry, fsp, 0, 0);
910 e = find_share_mode_entry(lck, &entry);
915 e->op_type = UNUSED_SHARE_MODE_ENTRY;
916 lck->modified = True;
920 void del_deferred_open_entry(struct share_mode_lock *lck, uint16 mid)
922 struct share_mode_entry entry, *e;
924 fill_deferred_open_entry(&entry, timeval_zero(),
925 lck->dev, lck->ino, mid);
927 e = find_share_mode_entry(lck, &entry);
932 e->op_type = UNUSED_SHARE_MODE_ENTRY;
933 lck->modified = True;
936 /*******************************************************************
937 Remove an oplock mid and mode entry from a share mode.
938 ********************************************************************/
940 BOOL remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
942 struct share_mode_entry entry, *e;
944 fill_share_mode_entry(&entry, fsp, 0, 0);
946 e = find_share_mode_entry(lck, &entry);
952 e->op_type = NO_OPLOCK;
953 lck->modified = True;
957 /*******************************************************************
958 Downgrade a oplock type from exclusive to level II.
959 ********************************************************************/
961 BOOL downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
963 struct share_mode_entry entry, *e;
965 fill_share_mode_entry(&entry, fsp, 0, 0);
967 e = find_share_mode_entry(lck, &entry);
972 e->op_type = LEVEL_II_OPLOCK;
973 lck->modified = True;
978 /*******************************************************************
979 We've just told all the smbd's that our level2 or fake level2 has been
981 ********************************************************************/
982 BOOL remove_all_share_oplocks(struct share_mode_lock *lck, files_struct *fsp)
985 for (i=0; i<lck->num_share_modes; i++) {
986 struct share_mode_entry *e = &lck->share_modes[i];
987 if (!is_valid_share_mode_entry(e)) {
990 if (e->op_type == NO_OPLOCK) {
993 e->op_type = NO_OPLOCK;
994 lck->modified = True;
999 /****************************************************************************
1000 Deal with the internal needs of setting the delete on close flag. Note that
1001 as the tdb locking is recursive, it is safe to call this from within
1002 open_file_shared. JRA.
1003 ****************************************************************************/
1005 NTSTATUS can_set_delete_on_close(files_struct *fsp, BOOL delete_on_close,
1008 if (!delete_on_close) {
1009 return NT_STATUS_OK;
1013 * Only allow delete on close for writable files.
1016 if ((dosmode & aRONLY) &&
1017 !lp_delete_readonly(SNUM(fsp->conn))) {
1018 DEBUG(10,("can_set_delete_on_close: file %s delete on close "
1019 "flag set but file attribute is readonly.\n",
1021 return NT_STATUS_CANNOT_DELETE;
1025 * Only allow delete on close for writable shares.
1028 if (!CAN_WRITE(fsp->conn)) {
1029 DEBUG(10,("can_set_delete_on_close: file %s delete on "
1030 "close flag set but write access denied on share.\n",
1032 return NT_STATUS_ACCESS_DENIED;
1036 * Only allow delete on close for files/directories opened with delete
1040 if (!(fsp->access_mask & DELETE_ACCESS)) {
1041 DEBUG(10,("can_set_delete_on_close: file %s delete on "
1042 "close flag set but delete access denied.\n",
1044 return NT_STATUS_ACCESS_DENIED;
1047 return NT_STATUS_OK;
1050 /****************************************************************************
1051 Sets the delete on close flag over all share modes on this file.
1052 Modify the share mode entry for all files open
1053 on this device and inode to tell other smbds we have
1054 changed the delete on close flag. This will be noticed
1055 in the close code, the last closer will delete the file
1057 ****************************************************************************/
1059 BOOL set_delete_on_close(files_struct *fsp, BOOL delete_on_close)
1061 struct share_mode_lock *lck;
1063 DEBUG(10,("set_delete_on_close: %s delete on close flag for "
1064 "fnum = %d, file %s\n",
1065 delete_on_close ? "Adding" : "Removing", fsp->fnum,
1072 lck = get_share_mode_lock(NULL, fsp->dev, fsp->inode, NULL, NULL);
1076 if (lck->delete_on_close != delete_on_close) {
1077 lck->delete_on_close = delete_on_close;
1078 lck->modified = True;
1085 static int traverse_fn(TDB_CONTEXT *the_tdb, TDB_DATA kbuf, TDB_DATA dbuf,
1088 struct locking_data *data;
1089 struct share_mode_entry *shares;
1090 const char *sharepath;
1093 void (*traverse_callback)(struct share_mode_entry *, const char *, const char *) = state;
1095 /* Ensure this is a locking_key record. */
1096 if (kbuf.dsize != sizeof(struct locking_key))
1099 data = (struct locking_data *)dbuf.dptr;
1100 shares = (struct share_mode_entry *)(dbuf.dptr + sizeof(*data));
1101 sharepath = dbuf.dptr + sizeof(*data) +
1102 data->u.s.num_share_mode_entries*sizeof(*shares);
1103 fname = dbuf.dptr + sizeof(*data) +
1104 data->u.s.num_share_mode_entries*sizeof(*shares) +
1105 strlen(sharepath) + 1;
1107 for (i=0;i<data->u.s.num_share_mode_entries;i++) {
1108 traverse_callback(&shares[i], sharepath, fname);
1113 /*******************************************************************
1114 Call the specified function on each entry under management by the
1116 ********************************************************************/
1118 int share_mode_forall(void (*fn)(const struct share_mode_entry *, const char *, const char *))
1122 return tdb_traverse(tdb, traverse_fn, fn);