diff options
Diffstat (limited to 'source4/locking/locking.c')
| -rw-r--r-- | source4/locking/locking.c | 849 |
1 files changed, 0 insertions, 849 deletions
diff --git a/source4/locking/locking.c b/source4/locking/locking.c deleted file mode 100644 index 63e1f3a164..0000000000 --- a/source4/locking/locking.c +++ /dev/null @@ -1,849 +0,0 @@ -/* - Unix SMB/CIFS implementation. - Locking functions - Copyright (C) Andrew Tridgell 1992-2000 - Copyright (C) Jeremy Allison 1992-2000 - - This program is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - - Revision History: - - 12 aug 96: Erik.Devriendt@te6.siemens.be - added support for shared memory implementation of share mode locking - - May 1997. Jeremy Allison (jallison@whistle.com). Modified share mode - locking to deal with multiple share modes per open file. - - September 1997. Jeremy Allison (jallison@whistle.com). Added oplock - support. - - rewrtten completely to use new tdb code. Tridge, Dec '99 - - Added POSIX locking support. Jeremy Allison (jeremy@valinux.com), Apr. 2000. -*/ - -#include "includes.h" - -/* the locking database handle */ -static TDB_CONTEXT *tdb; - -/**************************************************************************** - Debugging aid :-). -****************************************************************************/ - -static const char *lock_type_name(enum brl_type lock_type) -{ - return (lock_type == READ_LOCK) ? "READ" : "WRITE"; -} - -/**************************************************************************** - Utility function called to see if a file region is locked. - If check_self is True, then checks on our own fd with the same locking context - are still made. If check_self is False, then checks are not made on our own fd - with the same locking context are not made. -****************************************************************************/ - -BOOL is_locked(files_struct *fsp,struct tcon_context *conn, - SMB_BIG_UINT count,SMB_BIG_UINT offset, - enum brl_type lock_type, BOOL check_self) -{ - int snum = SNUM(conn); - BOOL ret; - - if (count == 0) - return(False); - - if (!lp_locking(snum) || !lp_strict_locking(snum)) - return(False); - - ret = !brl_locktest(fsp->dev, fsp->inode, fsp->fnum, - global_smbpid, sys_getpid(), conn->cnum, - offset, count, lock_type, check_self); - - DEBUG(10,("is_locked: brl start=%.0f len=%.0f %s for file %s\n", - (double)offset, (double)count, ret ? "locked" : "unlocked", - fsp->fsp_name )); - - /* - * There is no lock held by an SMB daemon, check to - * see if there is a POSIX lock from a UNIX or NFS process. - */ - - if(!ret && lp_posix_locking(snum)) { - ret = is_posix_locked(fsp, offset, count, lock_type); - - DEBUG(10,("is_locked: posix start=%.0f len=%.0f %s for file %s\n", - (double)offset, (double)count, ret ? "locked" : "unlocked", - fsp->fsp_name )); - } - - return ret; -} - -/**************************************************************************** - Utility function called by locking requests. -****************************************************************************/ - -static NTSTATUS do_lock(files_struct *fsp,struct tcon_context *conn, uint16 lock_pid, - SMB_BIG_UINT count,SMB_BIG_UINT offset,enum brl_type lock_type) -{ - NTSTATUS status = NT_STATUS_LOCK_NOT_GRANTED; - - if (!lp_locking(SNUM(conn))) - return NT_STATUS_OK; - - /* NOTE! 0 byte long ranges ARE allowed and should be stored */ - - DEBUG(10,("do_lock: lock type %s start=%.0f len=%.0f requested for file %s\n", - lock_type_name(lock_type), (double)offset, (double)count, fsp->fsp_name )); - - if (OPEN_FSP(fsp) && fsp->can_lock && (fsp->conn == conn)) { - status = brl_lock(fsp->dev, fsp->inode, fsp->fnum, - lock_pid, sys_getpid(), conn->cnum, - offset, count, - lock_type); - - if (NT_STATUS_IS_OK(status) && lp_posix_locking(SNUM(conn))) { - - /* - * Try and get a POSIX lock on this range. - * Note that this is ok if it is a read lock - * overlapping on a different fd. JRA. - */ - - if (!set_posix_lock(fsp, offset, count, lock_type)) { - status = NT_STATUS_LOCK_NOT_GRANTED; - /* - * We failed to map - we must now remove the brl - * lock entry. - */ - (void)brl_unlock(fsp->dev, fsp->inode, fsp->fnum, - lock_pid, sys_getpid(), conn->cnum, - offset, count, False); - } - } - } - - return status; -} - -/**************************************************************************** - Utility function called by locking requests. This is *DISGUSTING*. It also - appears to be "What Windows Does" (tm). Andrew, ever wonder why Windows 2000 - is so slow on the locking tests...... ? This is the reason. Much though I hate - it, we need this. JRA. -****************************************************************************/ - -NTSTATUS do_lock_spin(files_struct *fsp,struct tcon_context *conn, uint16 lock_pid, - SMB_BIG_UINT count,SMB_BIG_UINT offset,enum brl_type lock_type) -{ - int j, maxj = lp_lock_spin_count(); - int sleeptime = lp_lock_sleep_time(); - NTSTATUS status, ret; - - if (maxj <= 0) - maxj = 1; - - ret = NT_STATUS_OK; /* to keep dumb compilers happy */ - - for (j = 0; j < maxj; j++) { - status = do_lock(fsp, conn, lock_pid, count, offset, lock_type); - if (!NT_STATUS_EQUAL(status, NT_STATUS_LOCK_NOT_GRANTED) && - !NT_STATUS_EQUAL(status, NT_STATUS_FILE_LOCK_CONFLICT)) { - return status; - } - /* if we do fail then return the first error code we got */ - if (j == 0) { - ret = status; - } - if (sleeptime) - sys_usleep(sleeptime); - } - return ret; -} - -/**************************************************************************** - Utility function called by unlocking requests. -****************************************************************************/ - -NTSTATUS do_unlock(files_struct *fsp,struct tcon_context *conn, uint16 lock_pid, - SMB_BIG_UINT count,SMB_BIG_UINT offset) -{ - BOOL ok = False; - - if (!lp_locking(SNUM(conn))) - return NT_STATUS_OK; - - if (!OPEN_FSP(fsp) || !fsp->can_lock || (fsp->conn != conn)) { - return NT_STATUS_INVALID_HANDLE; - } - - DEBUG(10,("do_unlock: unlock start=%.0f len=%.0f requested for file %s\n", - (double)offset, (double)count, fsp->fsp_name )); - - /* - * Remove the existing lock record from the tdb lockdb - * before looking at POSIX locks. If this record doesn't - * match then don't bother looking to remove POSIX locks. - */ - - ok = brl_unlock(fsp->dev, fsp->inode, fsp->fnum, - lock_pid, sys_getpid(), conn->cnum, offset, count, False); - - if (!ok) { - DEBUG(10,("do_unlock: returning ERRlock.\n" )); - return NT_STATUS_RANGE_NOT_LOCKED; - } - - if (!lp_posix_locking(SNUM(conn))) - return NT_STATUS_OK; - - (void)release_posix_lock(fsp, offset, count); - - return NT_STATUS_OK; -} - -/**************************************************************************** - Remove any locks on this fd. Called from file_close(). -****************************************************************************/ - -void locking_close_file(files_struct *fsp) -{ - pid_t pid = sys_getpid(); - - if (!lp_locking(SNUM(fsp->conn))) - return; - - /* - * Just release all the brl locks, no need to release individually. - */ - - brl_close(fsp->dev, fsp->inode, pid, fsp->conn->cnum, fsp->fnum); - - if(lp_posix_locking(SNUM(fsp->conn))) { - - /* - * Release all the POSIX locks. - */ - posix_locking_close_file(fsp); - - } -} - -/**************************************************************************** - Initialise the locking functions. -****************************************************************************/ - -static int open_read_only; - -BOOL locking_init(int read_only) -{ - brl_init(read_only); - - if (tdb) - return True; - - tdb = tdb_open_log(lock_path("locking.tdb"), - 0, TDB_DEFAULT|(read_only?0x0:TDB_CLEAR_IF_FIRST), - read_only?O_RDONLY:O_RDWR|O_CREAT, - 0644); - - if (!tdb) { - DEBUG(0,("ERROR: Failed to initialise locking database\n")); - return False; - } - - if (!posix_locking_init(read_only)) - return False; - - open_read_only = read_only; - - return True; -} - -/******************************************************************* - Deinitialize the share_mode management. -******************************************************************/ - -BOOL locking_end(void) -{ - - brl_shutdown(open_read_only); - if (tdb) { - - if (tdb_close(tdb) != 0) - return False; - } - - return True; -} - -/******************************************************************* - Form a static locking key for a dev/inode pair. -******************************************************************/ - -static TDB_DATA locking_key(SMB_DEV_T dev, SMB_INO_T inode) -{ - static struct locking_key key; - TDB_DATA kbuf; - - memset(&key, '\0', sizeof(key)); - key.dev = dev; - key.inode = inode; - kbuf.dptr = (char *)&key; - kbuf.dsize = sizeof(key); - return kbuf; -} - -static TDB_DATA locking_key_fsp(files_struct *fsp) -{ - return locking_key(fsp->dev, fsp->inode); -} - -/******************************************************************* - Lock a hash bucket entry. -******************************************************************/ - -BOOL lock_share_entry(struct tcon_context *conn, - SMB_DEV_T dev, SMB_INO_T inode) -{ - return tdb_chainlock(tdb, locking_key(dev, inode)) == 0; -} - -/******************************************************************* - Unlock a hash bucket entry. -******************************************************************/ - -void unlock_share_entry(struct tcon_context *conn, - SMB_DEV_T dev, SMB_INO_T inode) -{ - tdb_chainunlock(tdb, locking_key(dev, inode)); -} - -/******************************************************************* - Lock a hash bucket entry. use a fsp for convenience -******************************************************************/ - -BOOL lock_share_entry_fsp(files_struct *fsp) -{ - return tdb_chainlock(tdb, locking_key(fsp->dev, fsp->inode)) == 0; -} - -/******************************************************************* - Unlock a hash bucket entry. -******************************************************************/ - -void unlock_share_entry_fsp(files_struct *fsp) -{ - tdb_chainunlock(tdb, locking_key(fsp->dev, fsp->inode)); -} - -/******************************************************************* - Print out a share mode. -********************************************************************/ - -static char *share_mode_str(int num, share_mode_entry *e) -{ - static pstring share_str; - - slprintf(share_str, sizeof(share_str)-1, "share_mode_entry[%d]: \ -pid = %u, share_mode = 0x%x, desired_access = 0x%x, port = 0x%x, type= 0x%x, file_id = %lu, dev = 0x%x, inode = %.0f", - num, e->pid, e->share_mode, (unsigned int)e->desired_access, e->op_port, e->op_type, e->share_file_id, - (unsigned int)e->dev, (double)e->inode ); - - return share_str; -} - -/******************************************************************* - Print out a share mode table. -********************************************************************/ - -static void print_share_mode_table(struct locking_data *data) -{ - int num_share_modes = data->u.num_share_mode_entries; - share_mode_entry *shares = (share_mode_entry *)(data + 1); - int i; - - for (i = 0; i < num_share_modes; i++) { - share_mode_entry *entry_p = &shares[i]; - DEBUG(10,("print_share_mode_table: %s\n", share_mode_str(i, entry_p) )); - } -} - -/******************************************************************* - Get all share mode entries for a dev/inode pair. -********************************************************************/ - -int get_share_modes(struct tcon_context *conn, - SMB_DEV_T dev, SMB_INO_T inode, - share_mode_entry **pp_shares) -{ - TDB_DATA dbuf; - struct locking_data *data; - int num_share_modes; - share_mode_entry *shares = NULL; - - *pp_shares = NULL; - - dbuf = tdb_fetch(tdb, locking_key(dev, inode)); - if (!dbuf.dptr) - return 0; - - data = (struct locking_data *)dbuf.dptr; - num_share_modes = data->u.num_share_mode_entries; - if(num_share_modes) { - int i; - int del_count = 0; - - shares = (share_mode_entry *)memdup(dbuf.dptr + sizeof(*data), - num_share_modes * sizeof(share_mode_entry)); - - if (!shares) { - SAFE_FREE(dbuf.dptr); - return 0; - } - - /* - * Ensure that each entry has a real process attached. - */ - - for (i = 0; i < num_share_modes; ) { - share_mode_entry *entry_p = &shares[i]; - if (process_exists(entry_p->pid)) { - DEBUG(10,("get_share_modes: %s\n", share_mode_str(i, entry_p) )); - i++; - } else { - DEBUG(10,("get_share_modes: deleted %s\n", share_mode_str(i, entry_p) )); - memcpy( &shares[i], &shares[i+1], - sizeof(share_mode_entry) * (num_share_modes - i - 1)); - num_share_modes--; - del_count++; - } - } - - /* Did we delete any ? If so, re-store in tdb. */ - if (del_count) { - data->u.num_share_mode_entries = num_share_modes; - - if (num_share_modes) - memcpy(dbuf.dptr + sizeof(*data), shares, - num_share_modes * sizeof(share_mode_entry)); - - /* The record has shrunk a bit */ - dbuf.dsize -= del_count * sizeof(share_mode_entry); - - if (tdb_store(tdb, locking_key(dev, inode), dbuf, TDB_REPLACE) == -1) { - SAFE_FREE(shares); - SAFE_FREE(dbuf.dptr); - return 0; - } - } - } - - SAFE_FREE(dbuf.dptr); - *pp_shares = shares; - return num_share_modes; -} - -/******************************************************************* - Fill a share mode entry. -********************************************************************/ - -static void fill_share_mode(char *p, files_struct *fsp, uint16 port, uint16 op_type) -{ - share_mode_entry *e = (share_mode_entry *)p; - void *x = &e->time; /* Needed to force alignment. p may not be aligned.... */ - - memset(e, '\0', sizeof(share_mode_entry)); - e->pid = sys_getpid(); - e->share_mode = fsp->share_mode; - e->desired_access = fsp->desired_access; - e->op_port = port; - e->op_type = op_type; - memcpy(x, &fsp->open_time, sizeof(struct timeval)); - e->share_file_id = fsp->file_id; - e->dev = fsp->dev; - e->inode = fsp->inode; -} - -/******************************************************************* - Check if two share mode entries are identical, ignoring oplock - and port info and desired_access. -********************************************************************/ - -BOOL share_modes_identical( share_mode_entry *e1, share_mode_entry *e2) -{ -#if 1 /* JRA PARANOIA TEST - REMOVE LATER */ - if (e1->pid == e2->pid && - e1->share_file_id == e2->share_file_id && - e1->dev == e2->dev && - e1->inode == e2->inode && - (e1->share_mode & ~DELETE_ON_CLOSE_FLAG) != (e2->share_mode & ~DELETE_ON_CLOSE_FLAG)) { - DEBUG(0,("PANIC: share_modes_identical: share_mode missmatch (e1 = %u, e2 = %u). Logic error.\n", - (unsigned int)(e1->share_mode & ~DELETE_ON_CLOSE_FLAG), - (unsigned int)(e2->share_mode & ~DELETE_ON_CLOSE_FLAG) )); - smb_panic("PANIC: share_modes_identical logic error.\n"); - } -#endif - - return (e1->pid == e2->pid && - (e1->share_mode & ~DELETE_ON_CLOSE_FLAG) == (e2->share_mode & ~DELETE_ON_CLOSE_FLAG) && - e1->dev == e2->dev && - e1->inode == e2->inode && - e1->share_file_id == e2->share_file_id ); -} - -/******************************************************************* - Delete a specific share mode. Return the number - of entries left, and a memdup'ed copy of the entry deleted (if required). - Ignore if no entry deleted. -********************************************************************/ - -ssize_t del_share_entry( SMB_DEV_T dev, SMB_INO_T inode, - share_mode_entry *entry, share_mode_entry **ppse) -{ - TDB_DATA dbuf; - struct locking_data *data; - int i, del_count=0; - share_mode_entry *shares; - ssize_t count = 0; - - if (ppse) - *ppse = NULL; - - /* read in the existing share modes */ - dbuf = tdb_fetch(tdb, locking_key(dev, inode)); - if (!dbuf.dptr) - return -1; - - data = (struct locking_data *)dbuf.dptr; - shares = (share_mode_entry *)(dbuf.dptr + sizeof(*data)); - - /* - * Find any with this pid and delete it - * by overwriting with the rest of the data - * from the record. - */ - - DEBUG(10,("del_share_entry: num_share_modes = %d\n", data->u.num_share_mode_entries )); - - for (i=0;i<data->u.num_share_mode_entries;) { - if (share_modes_identical(&shares[i], entry)) { - DEBUG(10,("del_share_entry: deleted %s\n", - share_mode_str(i, &shares[i]) )); - if (ppse) - *ppse = memdup(&shares[i], sizeof(*shares)); - data->u.num_share_mode_entries--; - memmove(&shares[i], &shares[i+1], - dbuf.dsize - (sizeof(*data) + (i+1)*sizeof(*shares))); - del_count++; - - DEBUG(10,("del_share_entry: deleting entry %d\n", i )); - - } else { - i++; - } - } - - if (del_count) { - /* the record may have shrunk a bit */ - dbuf.dsize -= del_count * sizeof(*shares); - - count = (ssize_t)data->u.num_share_mode_entries; - - /* store it back in the database */ - if (data->u.num_share_mode_entries == 0) { - if (tdb_delete(tdb, locking_key(dev, inode)) == -1) - count = -1; - } else { - if (tdb_store(tdb, locking_key(dev, inode), dbuf, TDB_REPLACE) == -1) - count = -1; - } - } - DEBUG(10,("del_share_entry: Remaining table.\n")); - print_share_mode_table((struct locking_data *)dbuf.dptr); - SAFE_FREE(dbuf.dptr); - return count; -} - -/******************************************************************* - Del the share mode of a file for this process. Return the number - of entries left, and a memdup'ed copy of the entry deleted. -********************************************************************/ - -ssize_t del_share_mode(files_struct *fsp, share_mode_entry **ppse) -{ - share_mode_entry entry; - - /* - * Fake up a share_mode_entry for comparisons. - */ - - fill_share_mode((char *)&entry, fsp, 0, 0); - return del_share_entry(fsp->dev, fsp->inode, &entry, ppse); -} - -/******************************************************************* - Set the share mode of a file. Return False on fail, True on success. -********************************************************************/ - -BOOL set_share_mode(files_struct *fsp, uint16 port, uint16 op_type) -{ - TDB_DATA dbuf; - struct locking_data *data; - char *p=NULL; - int size; - BOOL ret = True; - - /* read in the existing share modes if any */ - dbuf = tdb_fetch(tdb, locking_key_fsp(fsp)); - if (!dbuf.dptr) { - size_t offset; - /* we'll need to create a new record */ - pstring fname; - - pstrcpy(fname, fsp->conn->connectpath); - pstrcat(fname, "/"); - pstrcat(fname, fsp->fsp_name); - - size = sizeof(*data) + sizeof(share_mode_entry) + strlen(fname) + 1; - p = (char *)malloc(size); - if (!p) - return False; - data = (struct locking_data *)p; - data->u.num_share_mode_entries = 1; - - DEBUG(10,("set_share_mode: creating entry for file %s. num_share_modes = 1\n", - fsp->fsp_name )); - - offset = sizeof(*data) + sizeof(share_mode_entry); - safe_strcpy(p + offset, fname, size - offset - 1); - fill_share_mode(p + sizeof(*data), fsp, port, op_type); - dbuf.dptr = p; - dbuf.dsize = size; - if (tdb_store(tdb, locking_key_fsp(fsp), dbuf, TDB_REPLACE) == -1) - ret = False; - - print_share_mode_table((struct locking_data *)p); - - SAFE_FREE(p); - return ret; - } - - /* we're adding to an existing entry - this is a bit fiddly */ - data = (struct locking_data *)dbuf.dptr; - - data->u.num_share_mode_entries++; - - DEBUG(10,("set_share_mode: adding entry for file %s. new num_share_modes = %d\n", - fsp->fsp_name, data->u.num_share_mode_entries )); - - size = dbuf.dsize + sizeof(share_mode_entry); - p = malloc(size); - if (!p) { - SAFE_FREE(dbuf.dptr); - return False; - } - memcpy(p, dbuf.dptr, sizeof(*data)); - fill_share_mode(p + sizeof(*data), fsp, port, op_type); - memcpy(p + sizeof(*data) + sizeof(share_mode_entry), dbuf.dptr + sizeof(*data), - dbuf.dsize - sizeof(*data)); - SAFE_FREE(dbuf.dptr); - dbuf.dptr = p; - dbuf.dsize = size; - if (tdb_store(tdb, locking_key_fsp(fsp), dbuf, TDB_REPLACE) == -1) - ret = False; - print_share_mode_table((struct locking_data *)p); - SAFE_FREE(p); - return ret; -} - -/******************************************************************* - A generic in-place modification call for share mode entries. -********************************************************************/ - -static BOOL mod_share_mode( SMB_DEV_T dev, SMB_INO_T inode, share_mode_entry *entry, - void (*mod_fn)(share_mode_entry *, SMB_DEV_T, SMB_INO_T, void *), - void *param) -{ - TDB_DATA dbuf; - struct locking_data *data; - int i; - share_mode_entry *shares; - BOOL need_store=False; - BOOL ret = True; - - /* read in the existing share modes */ - dbuf = tdb_fetch(tdb, locking_key(dev, inode)); - if (!dbuf.dptr) - return False; - - data = (struct locking_data *)dbuf.dptr; - shares = (share_mode_entry *)(dbuf.dptr + sizeof(*data)); - - /* find any with our pid and call the supplied function */ - for (i=0;i<data->u.num_share_mode_entries;i++) { - if (share_modes_identical(entry, &shares[i])) { - mod_fn(&shares[i], dev, inode, param); - need_store=True; - } - } - - /* if the mod fn was called then store it back */ - if (need_store) { - if (data->u.num_share_mode_entries == 0) { - if (tdb_delete(tdb, locking_key(dev, inode)) == -1) - ret = False; - } else { - if (tdb_store(tdb, locking_key(dev, inode), dbuf, TDB_REPLACE) == -1) - ret = False; - } - } - - SAFE_FREE(dbuf.dptr); - return ret; -} - -/******************************************************************* - Static function that actually does the work for the generic function - below. -********************************************************************/ - -static void remove_share_oplock_fn(share_mode_entry *entry, SMB_DEV_T dev, SMB_INO_T inode, - void *param) -{ - DEBUG(10,("remove_share_oplock_fn: removing oplock info for entry dev=%x ino=%.0f\n", - (unsigned int)dev, (double)inode )); - /* Delete the oplock info. */ - entry->op_port = 0; - entry->op_type = NO_OPLOCK; -} - -/******************************************************************* - Remove an oplock port and mode entry from a share mode. -********************************************************************/ - -BOOL remove_share_oplock(files_struct *fsp) -{ - share_mode_entry entry; - /* - * Fake up an entry for comparisons... - */ - fill_share_mode((char *)&entry, fsp, 0, 0); - return mod_share_mode(fsp->dev, fsp->inode, &entry, remove_share_oplock_fn, NULL); -} - -/******************************************************************* - Static function that actually does the work for the generic function - below. -********************************************************************/ - -static void downgrade_share_oplock_fn(share_mode_entry *entry, SMB_DEV_T dev, SMB_INO_T inode, - void *param) -{ - DEBUG(10,("downgrade_share_oplock_fn: downgrading oplock info for entry dev=%x ino=%.0f\n", - (unsigned int)dev, (double)inode )); - entry->op_type = LEVEL_II_OPLOCK; -} - -/******************************************************************* - Downgrade a oplock type from exclusive to level II. -********************************************************************/ - -BOOL downgrade_share_oplock(files_struct *fsp) -{ - share_mode_entry entry; - /* - * Fake up an entry for comparisons... - */ - fill_share_mode((char *)&entry, fsp, 0, 0); - return mod_share_mode(fsp->dev, fsp->inode, &entry, downgrade_share_oplock_fn, NULL); -} - -/******************************************************************* - Get/Set the delete on close flag in a set of share modes. - Return False on fail, True on success. -********************************************************************/ - -BOOL modify_delete_flag( SMB_DEV_T dev, SMB_INO_T inode, BOOL delete_on_close) -{ - TDB_DATA dbuf; - struct locking_data *data; - int i; - share_mode_entry *shares; - - /* read in the existing share modes */ - dbuf = tdb_fetch(tdb, locking_key(dev, inode)); - if (!dbuf.dptr) - return False; - - data = (struct locking_data *)dbuf.dptr; - shares = (share_mode_entry *)(dbuf.dptr + sizeof(*data)); - - /* Set/Unset the delete on close element. */ - for (i=0;i<data->u.num_share_mode_entries;i++,shares++) { - shares->share_mode = (delete_on_close ? - (shares->share_mode | DELETE_ON_CLOSE_FLAG) : - (shares->share_mode & ~DELETE_ON_CLOSE_FLAG) ); - } - - /* store it back */ - if (data->u.num_share_mode_entries) { - if (tdb_store(tdb, locking_key(dev,inode), dbuf, TDB_REPLACE)==-1) { - SAFE_FREE(dbuf.dptr); - return False; - } - } - - SAFE_FREE(dbuf.dptr); - return True; -} - -/**************************************************************************** - Traverse the whole database with this function, calling traverse_callback - on each share mode -****************************************************************************/ - -static int traverse_fn(TDB_CONTEXT *the_tdb, TDB_DATA kbuf, TDB_DATA dbuf, - void* state) -{ - struct locking_data *data; - share_mode_entry *shares; - char *name; - int i; - - SHAREMODE_FN(traverse_callback) = (SHAREMODE_FN_CAST())state; - - data = (struct locking_data *)dbuf.dptr; - shares = (share_mode_entry *)(dbuf.dptr + sizeof(*data)); - name = dbuf.dptr + sizeof(*data) + data->u.num_share_mode_entries*sizeof(*shares); - - for (i=0;i<data->u.num_share_mode_entries;i++) { - traverse_callback(&shares[i], name); - } - return 0; -} - -/******************************************************************* - Call the specified function on each entry under management by the - share mode system. -********************************************************************/ - -int share_mode_forall(SHAREMODE_FN(fn)) -{ - if (!tdb) - return 0; - return tdb_traverse(tdb, traverse_fn, (void*)fn); -} |