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"));
600 lck->delete_on_close = False;
601 lck->num_share_modes = 0;
602 lck->share_modes = NULL;
603 lck->modified = False;
605 if (tdb_chainlock(tdb, key) != 0) {
606 DEBUG(3, ("Could not lock share entry\n"));
611 data = tdb_fetch(tdb, key);
612 lck->fresh = (data.dptr == NULL);
616 if (fname == NULL || servicepath == NULL) {
617 DEBUG(0, ("New file, but no filename or servicepath supplied\n"));
621 lck->filename = talloc_strdup(lck, fname);
622 lck->servicepath = talloc_strdup(lck, servicepath);
623 if (lck->filename == NULL || lck->servicepath == NULL) {
624 DEBUG(0, ("talloc failed\n"));
629 if (!parse_share_modes(data, lck)) {
630 DEBUG(0, ("Could not parse share modes\n"));
632 SAFE_FREE(data.dptr);
637 talloc_set_destructor(lck, share_mode_lock_destructor);
638 SAFE_FREE(data.dptr);
643 /*******************************************************************
644 Sets the service name and filename for rename.
645 At this point we emit "file renamed" messages to all
646 process id's that have this file open.
647 Based on an initial code idea from SATOH Fumiyasu <fumiya@samba.gr.jp>
648 ********************************************************************/
650 BOOL rename_share_filename(struct share_mode_lock *lck,
651 const char *servicepath,
654 struct file_renamed_message *frm = NULL;
660 DEBUG(10, ("rename_share_filename: servicepath %s newname %s\n",
661 servicepath, newname));
664 * rename_internal_fsp() and rename_internals() add './' to
665 * head of newname if newname does not contain a '/'.
667 while (newname[0] && newname[1] && newname[0] == '.' && newname[1] == '/') {
671 lck->servicepath = talloc_strdup(lck, servicepath);
672 lck->filename = talloc_strdup(lck, newname);
673 if (lck->filename == NULL || lck->servicepath == NULL) {
674 DEBUG(0, ("rename_share_filename: talloc failed\n"));
677 lck->modified = True;
679 sp_len = strlen(lck->servicepath);
680 fn_len = strlen(lck->filename);
682 msg_len = sizeof(*frm) + sp_len + 1 + fn_len + 1;
684 /* Set up the name changed message. */
685 frm = TALLOC(lck, msg_len);
690 frm->inode = lck->ino;
692 DEBUG(10,("rename_share_filename: msg_len = %d\n", msg_len ));
694 safe_strcpy(&frm->names[0], lck->servicepath, sp_len);
695 safe_strcpy(&frm->names[sp_len + 1], lck->filename, fn_len);
697 /* Send the messages. */
698 for (i=0; i<lck->num_share_modes; i++) {
699 struct share_mode_entry *se = &lck->share_modes[i];
700 if (!is_valid_share_mode_entry(se)) {
703 /* But not to ourselves... */
704 if (procid_is_me(&se->pid)) {
708 DEBUG(10,("rename_share_filename: sending rename message to pid %u "
709 "dev %x, inode %.0f sharepath %s newname %s\n",
710 (unsigned int)procid_to_pid(&se->pid),
711 (unsigned int)frm->dev, (double)frm->inode,
712 lck->servicepath, lck->filename ));
714 message_send_pid(se->pid, MSG_SMB_FILE_RENAME,
721 BOOL get_delete_on_close_flag(SMB_DEV_T dev, SMB_INO_T inode)
724 struct share_mode_lock *lck = get_share_mode_lock(NULL, dev, inode, NULL, NULL);
728 result = lck->delete_on_close;
733 BOOL is_valid_share_mode_entry(const struct share_mode_entry *e)
737 num_props += ((e->op_type == NO_OPLOCK) ? 1 : 0);
738 num_props += (EXCLUSIVE_OPLOCK_TYPE(e->op_type) ? 1 : 0);
739 num_props += (LEVEL_II_OPLOCK_TYPE(e->op_type) ? 1 : 0);
741 SMB_ASSERT(num_props <= 1);
742 return (num_props != 0);
745 BOOL is_deferred_open_entry(const struct share_mode_entry *e)
747 return (e->op_type == DEFERRED_OPEN_ENTRY);
750 BOOL is_unused_share_mode_entry(const struct share_mode_entry *e)
752 return (e->op_type == UNUSED_SHARE_MODE_ENTRY);
755 /*******************************************************************
756 Fill a share mode entry.
757 ********************************************************************/
759 static void fill_share_mode_entry(struct share_mode_entry *e,
761 uint16 mid, uint16 op_type)
764 e->pid = procid_self();
765 e->share_access = fsp->share_access;
766 e->private_options = fsp->fh->private_options;
767 e->access_mask = fsp->access_mask;
769 e->op_type = op_type;
770 e->time.tv_sec = fsp->open_time.tv_sec;
771 e->time.tv_usec = fsp->open_time.tv_usec;
772 e->share_file_id = fsp->file_id;
774 e->inode = fsp->inode;
777 static void fill_deferred_open_entry(struct share_mode_entry *e,
778 const struct timeval request_time,
779 SMB_DEV_T dev, SMB_INO_T ino, uint16 mid)
782 e->pid = procid_self();
784 e->op_type = DEFERRED_OPEN_ENTRY;
785 e->time.tv_sec = request_time.tv_sec;
786 e->time.tv_usec = request_time.tv_usec;
791 static void add_share_mode_entry(struct share_mode_lock *lck,
792 const struct share_mode_entry *entry)
796 for (i=0; i<lck->num_share_modes; i++) {
797 struct share_mode_entry *e = &lck->share_modes[i];
798 if (is_unused_share_mode_entry(e)) {
804 if (i == lck->num_share_modes) {
805 /* No unused entry found */
806 ADD_TO_ARRAY(lck, struct share_mode_entry, *entry,
807 &lck->share_modes, &lck->num_share_modes);
809 lck->modified = True;
812 void set_share_mode(struct share_mode_lock *lck, files_struct *fsp,
813 uint16 mid, uint16 op_type)
815 struct share_mode_entry entry;
816 fill_share_mode_entry(&entry, fsp, mid, op_type);
817 add_share_mode_entry(lck, &entry);
820 void add_deferred_open(struct share_mode_lock *lck, uint16 mid,
821 struct timeval request_time,
822 SMB_DEV_T dev, SMB_INO_T ino)
824 struct share_mode_entry entry;
825 fill_deferred_open_entry(&entry, request_time, dev, ino, mid);
826 add_share_mode_entry(lck, &entry);
829 /*******************************************************************
830 Check if two share mode entries are identical, ignoring oplock
831 and mid info and desired_access.
832 ********************************************************************/
834 static BOOL share_modes_identical(struct share_mode_entry *e1,
835 struct share_mode_entry *e2)
837 #if 1 /* JRA PARANOIA TEST - REMOVE LATER */
838 if (procid_equal(&e1->pid, &e2->pid) &&
839 e1->share_file_id == e2->share_file_id &&
840 e1->dev == e2->dev &&
841 e1->inode == e2->inode &&
842 (e1->share_access) != (e2->share_access)) {
843 DEBUG(0,("PANIC: share_modes_identical: share_mode "
844 "mismatch (e1 = 0x%x, e2 = 0x%x). Logic error.\n",
845 (unsigned int)e1->share_access,
846 (unsigned int)e2->share_access ));
847 smb_panic("PANIC: share_modes_identical logic error.\n");
851 return (procid_equal(&e1->pid, &e2->pid) &&
852 (e1->share_access) == (e2->share_access) &&
853 e1->dev == e2->dev &&
854 e1->inode == e2->inode &&
855 e1->share_file_id == e2->share_file_id );
858 static BOOL deferred_open_identical(struct share_mode_entry *e1,
859 struct share_mode_entry *e2)
861 return (procid_equal(&e1->pid, &e2->pid) &&
862 (e1->op_mid == e2->op_mid) &&
863 (e1->dev == e2->dev) &&
864 (e1->inode == e2->inode));
867 static struct share_mode_entry *find_share_mode_entry(struct share_mode_lock *lck,
868 struct share_mode_entry *entry)
872 for (i=0; i<lck->num_share_modes; i++) {
873 struct share_mode_entry *e = &lck->share_modes[i];
874 if (is_valid_share_mode_entry(entry) &&
875 is_valid_share_mode_entry(e) &&
876 share_modes_identical(e, entry)) {
879 if (is_deferred_open_entry(entry) &&
880 is_deferred_open_entry(e) &&
881 deferred_open_identical(e, entry)) {
888 /*******************************************************************
889 Del the share mode of a file for this process. Return the number of
891 ********************************************************************/
893 BOOL del_share_mode(struct share_mode_lock *lck, files_struct *fsp)
895 struct share_mode_entry entry, *e;
897 fill_share_mode_entry(&entry, fsp, 0, 0);
899 e = find_share_mode_entry(lck, &entry);
904 e->op_type = UNUSED_SHARE_MODE_ENTRY;
905 lck->modified = True;
909 void del_deferred_open_entry(struct share_mode_lock *lck, uint16 mid)
911 struct share_mode_entry entry, *e;
913 fill_deferred_open_entry(&entry, timeval_zero(),
914 lck->dev, lck->ino, mid);
916 e = find_share_mode_entry(lck, &entry);
921 e->op_type = UNUSED_SHARE_MODE_ENTRY;
922 lck->modified = True;
925 /*******************************************************************
926 Remove an oplock mid and mode entry from a share mode.
927 ********************************************************************/
929 BOOL remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
931 struct share_mode_entry entry, *e;
933 fill_share_mode_entry(&entry, fsp, 0, 0);
935 e = find_share_mode_entry(lck, &entry);
941 e->op_type = NO_OPLOCK;
942 lck->modified = True;
946 /*******************************************************************
947 Downgrade a oplock type from exclusive to level II.
948 ********************************************************************/
950 BOOL downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
952 struct share_mode_entry entry, *e;
954 fill_share_mode_entry(&entry, fsp, 0, 0);
956 e = find_share_mode_entry(lck, &entry);
961 e->op_type = LEVEL_II_OPLOCK;
962 lck->modified = True;
967 /*******************************************************************
968 We've just told all the smbd's that our level2 or fake level2 has been
970 ********************************************************************/
971 BOOL remove_all_share_oplocks(struct share_mode_lock *lck, files_struct *fsp)
974 for (i=0; i<lck->num_share_modes; i++) {
975 struct share_mode_entry *e = &lck->share_modes[i];
976 if (!is_valid_share_mode_entry(e)) {
979 if (e->op_type == NO_OPLOCK) {
982 e->op_type = NO_OPLOCK;
983 lck->modified = True;
988 /****************************************************************************
989 Deal with the internal needs of setting the delete on close flag. Note that
990 as the tdb locking is recursive, it is safe to call this from within
991 open_file_shared. JRA.
992 ****************************************************************************/
994 NTSTATUS can_set_delete_on_close(files_struct *fsp, BOOL delete_on_close,
997 if (!delete_on_close) {
1002 * Only allow delete on close for writable files.
1005 if ((dosmode & aRONLY) &&
1006 !lp_delete_readonly(SNUM(fsp->conn))) {
1007 DEBUG(10,("can_set_delete_on_close: file %s delete on close "
1008 "flag set but file attribute is readonly.\n",
1010 return NT_STATUS_CANNOT_DELETE;
1014 * Only allow delete on close for writable shares.
1017 if (!CAN_WRITE(fsp->conn)) {
1018 DEBUG(10,("can_set_delete_on_close: file %s delete on "
1019 "close flag set but write access denied on share.\n",
1021 return NT_STATUS_ACCESS_DENIED;
1025 * Only allow delete on close for files/directories opened with delete
1029 if (!(fsp->access_mask & DELETE_ACCESS)) {
1030 DEBUG(10,("can_set_delete_on_close: file %s delete on "
1031 "close flag set but delete access denied.\n",
1033 return NT_STATUS_ACCESS_DENIED;
1036 return NT_STATUS_OK;
1039 /****************************************************************************
1040 Sets the delete on close flag over all share modes on this file.
1041 Modify the share mode entry for all files open
1042 on this device and inode to tell other smbds we have
1043 changed the delete on close flag. This will be noticed
1044 in the close code, the last closer will delete the file
1046 ****************************************************************************/
1048 BOOL set_delete_on_close(files_struct *fsp, BOOL delete_on_close)
1050 struct share_mode_lock *lck;
1052 DEBUG(10,("set_delete_on_close: %s delete on close flag for "
1053 "fnum = %d, file %s\n",
1054 delete_on_close ? "Adding" : "Removing", fsp->fnum,
1061 lck = get_share_mode_lock(NULL, fsp->dev, fsp->inode, NULL, NULL);
1065 if (lck->delete_on_close != delete_on_close) {
1066 lck->delete_on_close = delete_on_close;
1067 lck->modified = True;
1074 static int traverse_fn(TDB_CONTEXT *the_tdb, TDB_DATA kbuf, TDB_DATA dbuf,
1077 struct locking_data *data;
1078 struct share_mode_entry *shares;
1079 const char *sharepath;
1082 void (*traverse_callback)(struct share_mode_entry *, const char *, const char *) = state;
1084 /* Ensure this is a locking_key record. */
1085 if (kbuf.dsize != sizeof(struct locking_key))
1088 data = (struct locking_data *)dbuf.dptr;
1089 shares = (struct share_mode_entry *)(dbuf.dptr + sizeof(*data));
1090 sharepath = dbuf.dptr + sizeof(*data) +
1091 data->u.s.num_share_mode_entries*sizeof(*shares);
1092 fname = dbuf.dptr + sizeof(*data) +
1093 data->u.s.num_share_mode_entries*sizeof(*shares) +
1094 strlen(sharepath) + 1;
1096 for (i=0;i<data->u.s.num_share_mode_entries;i++) {
1097 traverse_callback(&shares[i], sharepath, fname);
1102 /*******************************************************************
1103 Call the specified function on each entry under management by the
1105 ********************************************************************/
1107 int share_mode_forall(void (*fn)(const struct share_mode_entry *, const char *, const char *))
1111 return tdb_traverse(tdb, traverse_fn, fn);