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;
609 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,
675 DEBUG(10, ("rename_share_filename: servicepath %s newname %s\n",
676 servicepath, newname));
679 * rename_internal_fsp() and rename_internals() add './' to
680 * head of newname if newname does not contain a '/'.
682 while (newname[0] && newname[1] && newname[0] == '.' && newname[1] == '/') {
686 lck->servicepath = talloc_strdup(lck, servicepath);
687 lck->filename = talloc_strdup(lck, newname);
688 if (lck->filename == NULL || lck->servicepath == NULL) {
689 DEBUG(0, ("rename_share_filename: talloc failed\n"));
692 lck->modified = True;
694 sp_len = strlen(lck->servicepath);
695 fn_len = strlen(lck->filename);
697 msg_len = MSG_FILE_RENAMED_MIN_SIZE + sp_len + 1 + fn_len + 1;
699 /* Set up the name changed message. */
700 frm = TALLOC(lck, msg_len);
705 SDEV_T_VAL(frm,0,lck->dev);
706 SINO_T_VAL(frm,8,lck->ino);
708 DEBUG(10,("rename_share_filename: msg_len = %d\n", msg_len ));
710 safe_strcpy(&frm[16], lck->servicepath, sp_len);
711 safe_strcpy(&frm[16 + sp_len + 1], lck->filename, fn_len);
713 /* Send the messages. */
714 for (i=0; i<lck->num_share_modes; i++) {
715 struct share_mode_entry *se = &lck->share_modes[i];
716 if (!is_valid_share_mode_entry(se)) {
719 /* But not to ourselves... */
720 if (procid_is_me(&se->pid)) {
724 DEBUG(10,("rename_share_filename: sending rename message to pid %u "
725 "dev %x, inode %.0f sharepath %s newname %s\n",
726 (unsigned int)procid_to_pid(&se->pid),
727 (unsigned int)lck->dev, (double)lck->ino,
728 lck->servicepath, lck->filename ));
731 message_send_pid(se->pid, MSG_SMB_FILE_RENAME,
739 BOOL get_delete_on_close_flag(SMB_DEV_T dev, SMB_INO_T inode)
742 struct share_mode_lock *lck = get_share_mode_lock(NULL, dev, inode, NULL, NULL);
746 result = lck->delete_on_close;
751 BOOL is_valid_share_mode_entry(const struct share_mode_entry *e)
755 num_props += ((e->op_type == NO_OPLOCK) ? 1 : 0);
756 num_props += (EXCLUSIVE_OPLOCK_TYPE(e->op_type) ? 1 : 0);
757 num_props += (LEVEL_II_OPLOCK_TYPE(e->op_type) ? 1 : 0);
759 SMB_ASSERT(num_props <= 1);
760 return (num_props != 0);
763 BOOL is_deferred_open_entry(const struct share_mode_entry *e)
765 return (e->op_type == DEFERRED_OPEN_ENTRY);
768 BOOL is_unused_share_mode_entry(const struct share_mode_entry *e)
770 return (e->op_type == UNUSED_SHARE_MODE_ENTRY);
773 /*******************************************************************
774 Fill a share mode entry.
775 ********************************************************************/
777 static void fill_share_mode_entry(struct share_mode_entry *e,
779 uint16 mid, uint16 op_type)
782 e->pid = procid_self();
783 e->share_access = fsp->share_access;
784 e->private_options = fsp->fh->private_options;
785 e->access_mask = fsp->access_mask;
787 e->op_type = op_type;
788 e->time.tv_sec = fsp->open_time.tv_sec;
789 e->time.tv_usec = fsp->open_time.tv_usec;
790 e->share_file_id = fsp->file_id;
792 e->inode = fsp->inode;
795 static void fill_deferred_open_entry(struct share_mode_entry *e,
796 const struct timeval request_time,
797 SMB_DEV_T dev, SMB_INO_T ino, uint16 mid)
800 e->pid = procid_self();
802 e->op_type = DEFERRED_OPEN_ENTRY;
803 e->time.tv_sec = request_time.tv_sec;
804 e->time.tv_usec = request_time.tv_usec;
809 static void add_share_mode_entry(struct share_mode_lock *lck,
810 const struct share_mode_entry *entry)
814 for (i=0; i<lck->num_share_modes; i++) {
815 struct share_mode_entry *e = &lck->share_modes[i];
816 if (is_unused_share_mode_entry(e)) {
822 if (i == lck->num_share_modes) {
823 /* No unused entry found */
824 ADD_TO_ARRAY(lck, struct share_mode_entry, *entry,
825 &lck->share_modes, &lck->num_share_modes);
827 lck->modified = True;
830 void set_share_mode(struct share_mode_lock *lck, files_struct *fsp,
831 uint16 mid, uint16 op_type)
833 struct share_mode_entry entry;
834 fill_share_mode_entry(&entry, fsp, mid, op_type);
835 add_share_mode_entry(lck, &entry);
838 void add_deferred_open(struct share_mode_lock *lck, uint16 mid,
839 struct timeval request_time,
840 SMB_DEV_T dev, SMB_INO_T ino)
842 struct share_mode_entry entry;
843 fill_deferred_open_entry(&entry, request_time, dev, ino, mid);
844 add_share_mode_entry(lck, &entry);
847 /*******************************************************************
848 Check if two share mode entries are identical, ignoring oplock
849 and mid info and desired_access.
850 ********************************************************************/
852 static BOOL share_modes_identical(struct share_mode_entry *e1,
853 struct share_mode_entry *e2)
855 #if 1 /* JRA PARANOIA TEST - REMOVE LATER */
856 if (procid_equal(&e1->pid, &e2->pid) &&
857 e1->share_file_id == e2->share_file_id &&
858 e1->dev == e2->dev &&
859 e1->inode == e2->inode &&
860 (e1->share_access) != (e2->share_access)) {
861 DEBUG(0,("PANIC: share_modes_identical: share_mode "
862 "mismatch (e1 = 0x%x, e2 = 0x%x). Logic error.\n",
863 (unsigned int)e1->share_access,
864 (unsigned int)e2->share_access ));
865 smb_panic("PANIC: share_modes_identical logic error.\n");
869 return (procid_equal(&e1->pid, &e2->pid) &&
870 (e1->share_access) == (e2->share_access) &&
871 e1->dev == e2->dev &&
872 e1->inode == e2->inode &&
873 e1->share_file_id == e2->share_file_id );
876 static BOOL deferred_open_identical(struct share_mode_entry *e1,
877 struct share_mode_entry *e2)
879 return (procid_equal(&e1->pid, &e2->pid) &&
880 (e1->op_mid == e2->op_mid) &&
881 (e1->dev == e2->dev) &&
882 (e1->inode == e2->inode));
885 static struct share_mode_entry *find_share_mode_entry(struct share_mode_lock *lck,
886 struct share_mode_entry *entry)
890 for (i=0; i<lck->num_share_modes; i++) {
891 struct share_mode_entry *e = &lck->share_modes[i];
892 if (is_valid_share_mode_entry(entry) &&
893 is_valid_share_mode_entry(e) &&
894 share_modes_identical(e, entry)) {
897 if (is_deferred_open_entry(entry) &&
898 is_deferred_open_entry(e) &&
899 deferred_open_identical(e, entry)) {
906 /*******************************************************************
907 Del the share mode of a file for this process. Return the number of
909 ********************************************************************/
911 BOOL del_share_mode(struct share_mode_lock *lck, files_struct *fsp)
913 struct share_mode_entry entry, *e;
915 fill_share_mode_entry(&entry, fsp, 0, 0);
917 e = find_share_mode_entry(lck, &entry);
922 e->op_type = UNUSED_SHARE_MODE_ENTRY;
923 lck->modified = True;
927 void del_deferred_open_entry(struct share_mode_lock *lck, uint16 mid)
929 struct share_mode_entry entry, *e;
931 fill_deferred_open_entry(&entry, timeval_zero(),
932 lck->dev, lck->ino, mid);
934 e = find_share_mode_entry(lck, &entry);
939 e->op_type = UNUSED_SHARE_MODE_ENTRY;
940 lck->modified = True;
943 /*******************************************************************
944 Remove an oplock mid and mode entry from a share mode.
945 ********************************************************************/
947 BOOL remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
949 struct share_mode_entry entry, *e;
951 fill_share_mode_entry(&entry, fsp, 0, 0);
953 e = find_share_mode_entry(lck, &entry);
959 e->op_type = NO_OPLOCK;
960 lck->modified = True;
964 /*******************************************************************
965 Downgrade a oplock type from exclusive to level II.
966 ********************************************************************/
968 BOOL downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
970 struct share_mode_entry entry, *e;
972 fill_share_mode_entry(&entry, fsp, 0, 0);
974 e = find_share_mode_entry(lck, &entry);
979 e->op_type = LEVEL_II_OPLOCK;
980 lck->modified = True;
985 /*******************************************************************
986 We've just told all the smbd's that our level2 or fake level2 has been
988 ********************************************************************/
989 BOOL remove_all_share_oplocks(struct share_mode_lock *lck, files_struct *fsp)
992 for (i=0; i<lck->num_share_modes; i++) {
993 struct share_mode_entry *e = &lck->share_modes[i];
994 if (!is_valid_share_mode_entry(e)) {
997 if (e->op_type == NO_OPLOCK) {
1000 e->op_type = NO_OPLOCK;
1001 lck->modified = True;
1006 /****************************************************************************
1007 Deal with the internal needs of setting the delete on close flag. Note that
1008 as the tdb locking is recursive, it is safe to call this from within
1009 open_file_shared. JRA.
1010 ****************************************************************************/
1012 NTSTATUS can_set_delete_on_close(files_struct *fsp, BOOL delete_on_close,
1015 if (!delete_on_close) {
1016 return NT_STATUS_OK;
1020 * Only allow delete on close for writable files.
1023 if ((dosmode & aRONLY) &&
1024 !lp_delete_readonly(SNUM(fsp->conn))) {
1025 DEBUG(10,("can_set_delete_on_close: file %s delete on close "
1026 "flag set but file attribute is readonly.\n",
1028 return NT_STATUS_CANNOT_DELETE;
1032 * Only allow delete on close for writable shares.
1035 if (!CAN_WRITE(fsp->conn)) {
1036 DEBUG(10,("can_set_delete_on_close: file %s delete on "
1037 "close flag set but write access denied on share.\n",
1039 return NT_STATUS_ACCESS_DENIED;
1043 * Only allow delete on close for files/directories opened with delete
1047 if (!(fsp->access_mask & DELETE_ACCESS)) {
1048 DEBUG(10,("can_set_delete_on_close: file %s delete on "
1049 "close flag set but delete access denied.\n",
1051 return NT_STATUS_ACCESS_DENIED;
1054 return NT_STATUS_OK;
1057 /****************************************************************************
1058 Sets the delete on close flag over all share modes on this file.
1059 Modify the share mode entry for all files open
1060 on this device and inode to tell other smbds we have
1061 changed the delete on close flag. This will be noticed
1062 in the close code, the last closer will delete the file
1064 ****************************************************************************/
1066 BOOL set_delete_on_close(files_struct *fsp, BOOL delete_on_close)
1068 struct share_mode_lock *lck;
1070 DEBUG(10,("set_delete_on_close: %s delete on close flag for "
1071 "fnum = %d, file %s\n",
1072 delete_on_close ? "Adding" : "Removing", fsp->fnum,
1079 lck = get_share_mode_lock(NULL, fsp->dev, fsp->inode, NULL, NULL);
1083 if (lck->delete_on_close != delete_on_close) {
1084 lck->delete_on_close = delete_on_close;
1085 lck->modified = True;
1092 static int traverse_fn(TDB_CONTEXT *the_tdb, TDB_DATA kbuf, TDB_DATA dbuf,
1095 struct locking_data *data;
1096 struct share_mode_entry *shares;
1097 const char *sharepath;
1100 void (*traverse_callback)(struct share_mode_entry *, const char *, const char *) = state;
1102 /* Ensure this is a locking_key record. */
1103 if (kbuf.dsize != sizeof(struct locking_key))
1106 data = (struct locking_data *)dbuf.dptr;
1107 shares = (struct share_mode_entry *)(dbuf.dptr + sizeof(*data));
1108 sharepath = dbuf.dptr + sizeof(*data) +
1109 data->u.s.num_share_mode_entries*sizeof(*shares);
1110 fname = dbuf.dptr + sizeof(*data) +
1111 data->u.s.num_share_mode_entries*sizeof(*shares) +
1112 strlen(sharepath) + 1;
1114 for (i=0;i<data->u.s.num_share_mode_entries;i++) {
1115 traverse_callback(&shares[i], sharepath, fname);
1120 /*******************************************************************
1121 Call the specified function on each entry under management by the
1123 ********************************************************************/
1125 int share_mode_forall(void (*fn)(const struct share_mode_entry *, const char *, const char *))
1129 return tdb_traverse(tdb, traverse_fn, fn);