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]: %s "
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",
392 e->op_type == UNUSED_SHARE_MODE_ENTRY ? "UNUSED" : "",
393 procid_str_static(&e->pid),
394 e->share_access, e->private_options,
395 e->access_mask, e->op_mid, e->op_type, e->share_file_id,
396 (unsigned int)e->dev, (double)e->inode );
401 /*******************************************************************
402 Print out a share mode table.
403 ********************************************************************/
405 static void print_share_mode_table(struct locking_data *data)
407 int num_share_modes = data->u.s.num_share_mode_entries;
408 struct share_mode_entry *shares =
409 (struct share_mode_entry *)(data + 1);
412 for (i = 0; i < num_share_modes; i++) {
413 struct share_mode_entry entry;
415 memcpy(&entry, &shares[i], sizeof(struct share_mode_entry));
416 DEBUG(10,("print_share_mode_table: %s\n",
417 share_mode_str(i, &entry)));
421 /*******************************************************************
422 Get all share mode entries for a dev/inode pair.
423 ********************************************************************/
425 static BOOL parse_share_modes(TDB_DATA dbuf, struct share_mode_lock *lck)
427 struct locking_data *data;
430 if (dbuf.dsize < sizeof(struct locking_data)) {
431 DEBUG(0, ("parse_share_modes: buffer too short\n"));
435 data = (struct locking_data *)dbuf.dptr;
437 lck->delete_on_close = data->u.s.delete_on_close;
438 lck->num_share_modes = data->u.s.num_share_mode_entries;
440 DEBUG(10, ("parse_share_modes: delete_on_close: %d, "
441 "num_share_modes: %d\n", lck->delete_on_close,
442 lck->num_share_modes));
444 if ((lck->num_share_modes < 0) || (lck->num_share_modes > 1000000)) {
445 DEBUG(0, ("invalid number of share modes: %d\n",
446 lck->num_share_modes));
450 lck->share_modes = NULL;
452 if (lck->num_share_modes != 0) {
454 if (dbuf.dsize < (sizeof(struct locking_data) +
455 (lck->num_share_modes *
456 sizeof(struct share_mode_entry)))) {
457 DEBUG(0, ("parse_share_modes: buffer too short\n"));
461 lck->share_modes = talloc_memdup(lck, dbuf.dptr+sizeof(*data),
462 lck->num_share_modes *
463 sizeof(struct share_mode_entry));
465 if (lck->share_modes == NULL) {
466 DEBUG(0, ("talloc failed\n"));
471 /* Save off the associated service path and filename. */
472 lck->servicepath = talloc_strdup(lck, dbuf.dptr + sizeof(*data) +
473 (lck->num_share_modes *
474 sizeof(struct share_mode_entry)));
476 lck->filename = talloc_strdup(lck, dbuf.dptr + sizeof(*data) +
477 (lck->num_share_modes *
478 sizeof(struct share_mode_entry)) +
479 strlen(lck->servicepath) + 1 );
482 * Ensure that each entry has a real process attached.
485 for (i = 0; i < lck->num_share_modes; i++) {
486 struct share_mode_entry *entry_p = &lck->share_modes[i];
487 DEBUG(10,("parse_share_modes: %s\n",
488 share_mode_str(i, entry_p) ));
489 if (!process_exists(entry_p->pid)) {
490 DEBUG(10,("parse_share_modes: deleted %s\n",
491 share_mode_str(i, entry_p) ));
492 entry_p->op_type = UNUSED_SHARE_MODE_ENTRY;
493 lck->modified = True;
500 static TDB_DATA unparse_share_modes(struct share_mode_lock *lck)
505 struct locking_data *data;
512 for (i=0; i<lck->num_share_modes; i++) {
513 if (!is_unused_share_mode_entry(&lck->share_modes[i])) {
518 if (num_valid == 0) {
522 sp_len = strlen(lck->servicepath);
524 result.dsize = sizeof(*data) +
525 lck->num_share_modes * sizeof(struct share_mode_entry) +
527 strlen(lck->filename) + 1;
528 result.dptr = talloc_size(lck, result.dsize);
530 if (result.dptr == NULL) {
531 smb_panic("talloc failed\n");
534 data = (struct locking_data *)result.dptr;
536 data->u.s.num_share_mode_entries = lck->num_share_modes;
537 data->u.s.delete_on_close = lck->delete_on_close;
538 DEBUG(10, ("unparse_share_modes: del: %d, num: %d\n",
539 data->u.s.delete_on_close,
540 data->u.s.num_share_mode_entries));
541 memcpy(result.dptr + sizeof(*data), lck->share_modes,
542 sizeof(struct share_mode_entry)*lck->num_share_modes);
543 offset = sizeof(*data) +
544 sizeof(struct share_mode_entry)*lck->num_share_modes;
545 safe_strcpy(result.dptr + offset, lck->servicepath,
546 result.dsize - offset - 1);
547 offset += sp_len + 1;
548 safe_strcpy(result.dptr + offset, lck->filename,
549 result.dsize - offset - 1);
550 print_share_mode_table(data);
554 static int share_mode_lock_destructor(void *p)
556 struct share_mode_lock *lck =
557 talloc_get_type_abort(p, struct share_mode_lock);
558 TDB_DATA key = locking_key(lck->dev, lck->ino);
561 if (!lck->modified) {
565 data = unparse_share_modes(lck);
567 if (data.dptr == NULL) {
569 /* There has been an entry before, delete it */
570 if (tdb_delete(tdb, key) == -1) {
571 smb_panic("Could not delete share entry\n");
577 if (tdb_store(tdb, key, data, TDB_REPLACE) == -1) {
578 smb_panic("Could not store share mode entry\n");
582 tdb_chainunlock(tdb, key);
587 struct share_mode_lock *get_share_mode_lock(TALLOC_CTX *mem_ctx,
588 SMB_DEV_T dev, SMB_INO_T ino,
589 const char *servicepath,
592 struct share_mode_lock *lck;
593 TDB_DATA key = locking_key(dev, ino);
596 lck = TALLOC_P(mem_ctx, struct share_mode_lock);
598 DEBUG(0, ("talloc failed\n"));
602 /* Ensure we set every field here as the destructor must be
603 valid even if parse_share_modes fails. */
605 lck->servicepath = NULL;
606 lck->filename = NULL;
609 lck->num_share_modes = 0;
610 lck->share_modes = NULL;
611 lck->delete_on_close = False;
613 lck->modified = False;
615 if (tdb_chainlock(tdb, key) != 0) {
616 DEBUG(3, ("Could not lock share entry\n"));
621 /* We must set the destructor immediately after the chainlock
622 ensure the lock is cleaned up on any of the error return
625 talloc_set_destructor(lck, share_mode_lock_destructor);
627 data = tdb_fetch(tdb, key);
628 lck->fresh = (data.dptr == NULL);
632 if (fname == NULL || servicepath == NULL) {
636 lck->filename = talloc_strdup(lck, fname);
637 lck->servicepath = talloc_strdup(lck, servicepath);
638 if (lck->filename == NULL || lck->servicepath == NULL) {
639 DEBUG(0, ("talloc failed\n"));
644 if (!parse_share_modes(data, lck)) {
645 DEBUG(0, ("Could not parse share modes\n"));
647 SAFE_FREE(data.dptr);
652 SAFE_FREE(data.dptr);
657 /*******************************************************************
658 Sets the service name and filename for rename.
659 At this point we emit "file renamed" messages to all
660 process id's that have this file open.
661 Based on an initial code idea from SATOH Fumiyasu <fumiya@samba.gr.jp>
662 ********************************************************************/
664 BOOL rename_share_filename(struct share_mode_lock *lck,
665 const char *servicepath,
678 DEBUG(10, ("rename_share_filename: servicepath %s newname %s\n",
679 servicepath, newname));
682 * rename_internal_fsp() and rename_internals() add './' to
683 * head of newname if newname does not contain a '/'.
685 while (newname[0] && newname[1] && newname[0] == '.' && newname[1] == '/') {
689 lck->servicepath = talloc_strdup(lck, servicepath);
690 lck->filename = talloc_strdup(lck, newname);
691 if (lck->filename == NULL || lck->servicepath == NULL) {
692 DEBUG(0, ("rename_share_filename: talloc failed\n"));
695 lck->modified = True;
697 sp_len = strlen(lck->servicepath);
698 fn_len = strlen(lck->filename);
700 msg_len = MSG_FILE_RENAMED_MIN_SIZE + sp_len + 1 + fn_len + 1;
702 /* Set up the name changed message. */
703 frm = TALLOC(lck, msg_len);
708 SDEV_T_VAL(frm,0,lck->dev);
709 SINO_T_VAL(frm,8,lck->ino);
711 DEBUG(10,("rename_share_filename: msg_len = %d\n", msg_len ));
713 safe_strcpy(&frm[16], lck->servicepath, sp_len);
714 safe_strcpy(&frm[16 + sp_len + 1], lck->filename, fn_len);
716 /* Send the messages. */
717 for (i=0; i<lck->num_share_modes; i++) {
718 struct share_mode_entry *se = &lck->share_modes[i];
719 if (!is_valid_share_mode_entry(se)) {
722 /* But not to ourselves... */
723 if (procid_is_me(&se->pid)) {
727 DEBUG(10,("rename_share_filename: sending rename message to pid %u "
728 "dev %x, inode %.0f sharepath %s newname %s\n",
729 (unsigned int)procid_to_pid(&se->pid),
730 (unsigned int)lck->dev, (double)lck->ino,
731 lck->servicepath, lck->filename ));
734 message_send_pid(se->pid, MSG_SMB_FILE_RENAME,
742 BOOL get_delete_on_close_flag(SMB_DEV_T dev, SMB_INO_T inode)
745 struct share_mode_lock *lck = get_share_mode_lock(NULL, dev, inode, NULL, NULL);
749 result = lck->delete_on_close;
754 BOOL is_valid_share_mode_entry(const struct share_mode_entry *e)
758 num_props += ((e->op_type == NO_OPLOCK) ? 1 : 0);
759 num_props += (EXCLUSIVE_OPLOCK_TYPE(e->op_type) ? 1 : 0);
760 num_props += (LEVEL_II_OPLOCK_TYPE(e->op_type) ? 1 : 0);
762 SMB_ASSERT(num_props <= 1);
763 return (num_props != 0);
766 BOOL is_deferred_open_entry(const struct share_mode_entry *e)
768 return (e->op_type == DEFERRED_OPEN_ENTRY);
771 BOOL is_unused_share_mode_entry(const struct share_mode_entry *e)
773 return (e->op_type == UNUSED_SHARE_MODE_ENTRY);
776 /*******************************************************************
777 Fill a share mode entry.
778 ********************************************************************/
780 static void fill_share_mode_entry(struct share_mode_entry *e,
782 uint16 mid, uint16 op_type)
785 e->pid = procid_self();
786 e->share_access = fsp->share_access;
787 e->private_options = fsp->fh->private_options;
788 e->access_mask = fsp->access_mask;
790 e->op_type = op_type;
791 e->time.tv_sec = fsp->open_time.tv_sec;
792 e->time.tv_usec = fsp->open_time.tv_usec;
793 e->share_file_id = fsp->file_id;
795 e->inode = fsp->inode;
798 static void fill_deferred_open_entry(struct share_mode_entry *e,
799 const struct timeval request_time,
800 SMB_DEV_T dev, SMB_INO_T ino, uint16 mid)
803 e->pid = procid_self();
805 e->op_type = DEFERRED_OPEN_ENTRY;
806 e->time.tv_sec = request_time.tv_sec;
807 e->time.tv_usec = request_time.tv_usec;
812 static void add_share_mode_entry(struct share_mode_lock *lck,
813 const struct share_mode_entry *entry)
817 for (i=0; i<lck->num_share_modes; i++) {
818 struct share_mode_entry *e = &lck->share_modes[i];
819 if (is_unused_share_mode_entry(e)) {
825 if (i == lck->num_share_modes) {
826 /* No unused entry found */
827 ADD_TO_ARRAY(lck, struct share_mode_entry, *entry,
828 &lck->share_modes, &lck->num_share_modes);
830 lck->modified = True;
833 void set_share_mode(struct share_mode_lock *lck, files_struct *fsp,
834 uint16 mid, uint16 op_type)
836 struct share_mode_entry entry;
837 fill_share_mode_entry(&entry, fsp, mid, op_type);
838 add_share_mode_entry(lck, &entry);
841 void add_deferred_open(struct share_mode_lock *lck, uint16 mid,
842 struct timeval request_time,
843 SMB_DEV_T dev, SMB_INO_T ino)
845 struct share_mode_entry entry;
846 fill_deferred_open_entry(&entry, request_time, dev, ino, mid);
847 add_share_mode_entry(lck, &entry);
850 /*******************************************************************
851 Check if two share mode entries are identical, ignoring oplock
852 and mid info and desired_access.
853 ********************************************************************/
855 static BOOL share_modes_identical(struct share_mode_entry *e1,
856 struct share_mode_entry *e2)
858 #if 1 /* JRA PARANOIA TEST - REMOVE LATER */
859 if (procid_equal(&e1->pid, &e2->pid) &&
860 e1->share_file_id == e2->share_file_id &&
861 e1->dev == e2->dev &&
862 e1->inode == e2->inode &&
863 (e1->share_access) != (e2->share_access)) {
864 DEBUG(0,("PANIC: share_modes_identical: share_mode "
865 "mismatch (e1 = 0x%x, e2 = 0x%x). Logic error.\n",
866 (unsigned int)e1->share_access,
867 (unsigned int)e2->share_access ));
868 smb_panic("PANIC: share_modes_identical logic error.\n");
872 return (procid_equal(&e1->pid, &e2->pid) &&
873 (e1->share_access) == (e2->share_access) &&
874 e1->dev == e2->dev &&
875 e1->inode == e2->inode &&
876 e1->share_file_id == e2->share_file_id );
879 static BOOL deferred_open_identical(struct share_mode_entry *e1,
880 struct share_mode_entry *e2)
882 return (procid_equal(&e1->pid, &e2->pid) &&
883 (e1->op_mid == e2->op_mid) &&
884 (e1->dev == e2->dev) &&
885 (e1->inode == e2->inode));
888 static struct share_mode_entry *find_share_mode_entry(struct share_mode_lock *lck,
889 struct share_mode_entry *entry)
893 for (i=0; i<lck->num_share_modes; i++) {
894 struct share_mode_entry *e = &lck->share_modes[i];
895 if (is_valid_share_mode_entry(entry) &&
896 is_valid_share_mode_entry(e) &&
897 share_modes_identical(e, entry)) {
900 if (is_deferred_open_entry(entry) &&
901 is_deferred_open_entry(e) &&
902 deferred_open_identical(e, entry)) {
909 /*******************************************************************
910 Del the share mode of a file for this process. Return the number of
912 ********************************************************************/
914 BOOL del_share_mode(struct share_mode_lock *lck, files_struct *fsp)
916 struct share_mode_entry entry, *e;
918 fill_share_mode_entry(&entry, fsp, 0, 0);
920 e = find_share_mode_entry(lck, &entry);
925 e->op_type = UNUSED_SHARE_MODE_ENTRY;
926 lck->modified = True;
930 void del_deferred_open_entry(struct share_mode_lock *lck, uint16 mid)
932 struct share_mode_entry entry, *e;
934 fill_deferred_open_entry(&entry, timeval_zero(),
935 lck->dev, lck->ino, mid);
937 e = find_share_mode_entry(lck, &entry);
942 e->op_type = UNUSED_SHARE_MODE_ENTRY;
943 lck->modified = True;
946 /*******************************************************************
947 Remove an oplock mid and mode entry from a share mode.
948 ********************************************************************/
950 BOOL remove_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);
962 e->op_type = NO_OPLOCK;
963 lck->modified = True;
967 /*******************************************************************
968 Downgrade a oplock type from exclusive to level II.
969 ********************************************************************/
971 BOOL downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
973 struct share_mode_entry entry, *e;
975 fill_share_mode_entry(&entry, fsp, 0, 0);
977 e = find_share_mode_entry(lck, &entry);
982 e->op_type = LEVEL_II_OPLOCK;
983 lck->modified = True;
988 /*******************************************************************
989 We've just told all the smbd's that our level2 or fake level2 has been
991 ********************************************************************/
992 BOOL remove_all_share_oplocks(struct share_mode_lock *lck, files_struct *fsp)
995 for (i=0; i<lck->num_share_modes; i++) {
996 struct share_mode_entry *e = &lck->share_modes[i];
997 if (!is_valid_share_mode_entry(e)) {
1000 if (e->op_type == NO_OPLOCK) {
1003 e->op_type = NO_OPLOCK;
1004 lck->modified = True;
1009 /****************************************************************************
1010 Deal with the internal needs of setting the delete on close flag. Note that
1011 as the tdb locking is recursive, it is safe to call this from within
1012 open_file_shared. JRA.
1013 ****************************************************************************/
1015 NTSTATUS can_set_delete_on_close(files_struct *fsp, BOOL delete_on_close,
1018 if (!delete_on_close) {
1019 return NT_STATUS_OK;
1023 * Only allow delete on close for writable files.
1026 if ((dosmode & aRONLY) &&
1027 !lp_delete_readonly(SNUM(fsp->conn))) {
1028 DEBUG(10,("can_set_delete_on_close: file %s delete on close "
1029 "flag set but file attribute is readonly.\n",
1031 return NT_STATUS_CANNOT_DELETE;
1035 * Only allow delete on close for writable shares.
1038 if (!CAN_WRITE(fsp->conn)) {
1039 DEBUG(10,("can_set_delete_on_close: file %s delete on "
1040 "close flag set but write access denied on share.\n",
1042 return NT_STATUS_ACCESS_DENIED;
1046 * Only allow delete on close for files/directories opened with delete
1050 if (!(fsp->access_mask & DELETE_ACCESS)) {
1051 DEBUG(10,("can_set_delete_on_close: file %s delete on "
1052 "close flag set but delete access denied.\n",
1054 return NT_STATUS_ACCESS_DENIED;
1057 return NT_STATUS_OK;
1060 /****************************************************************************
1061 Sets the delete on close flag over all share modes on this file.
1062 Modify the share mode entry for all files open
1063 on this device and inode to tell other smbds we have
1064 changed the delete on close flag. This will be noticed
1065 in the close code, the last closer will delete the file
1067 ****************************************************************************/
1069 BOOL set_delete_on_close(files_struct *fsp, BOOL delete_on_close)
1071 struct share_mode_lock *lck;
1073 DEBUG(10,("set_delete_on_close: %s delete on close flag for "
1074 "fnum = %d, file %s\n",
1075 delete_on_close ? "Adding" : "Removing", fsp->fnum,
1082 lck = get_share_mode_lock(NULL, fsp->dev, fsp->inode, NULL, NULL);
1086 if (lck->delete_on_close != delete_on_close) {
1087 lck->delete_on_close = delete_on_close;
1088 lck->modified = True;
1095 static int traverse_fn(TDB_CONTEXT *the_tdb, TDB_DATA kbuf, TDB_DATA dbuf,
1098 struct locking_data *data;
1099 struct share_mode_entry *shares;
1100 const char *sharepath;
1103 void (*traverse_callback)(struct share_mode_entry *, const char *, const char *) = state;
1105 /* Ensure this is a locking_key record. */
1106 if (kbuf.dsize != sizeof(struct locking_key))
1109 data = (struct locking_data *)dbuf.dptr;
1110 shares = (struct share_mode_entry *)(dbuf.dptr + sizeof(*data));
1111 sharepath = dbuf.dptr + sizeof(*data) +
1112 data->u.s.num_share_mode_entries*sizeof(*shares);
1113 fname = dbuf.dptr + sizeof(*data) +
1114 data->u.s.num_share_mode_entries*sizeof(*shares) +
1115 strlen(sharepath) + 1;
1117 for (i=0;i<data->u.s.num_share_mode_entries;i++) {
1118 traverse_callback(&shares[i], sharepath, fname);
1123 /*******************************************************************
1124 Call the specified function on each entry under management by the
1126 ********************************************************************/
1128 int share_mode_forall(void (*fn)(const struct share_mode_entry *, const char *, const char *))
1132 return tdb_traverse(tdb, traverse_fn, fn);