*/
#include "includes.h"
+#include "system/filesys.h"
+#include "locking/proto.h"
+#include "dbwrap/dbwrap.h"
+#include "dbwrap/dbwrap_rbt.h"
+#include "util_tdb.h"
#undef DBGC_CLASS
#define DBGC_CLASS DBGC_LOCKING
* The pending close database handle.
*/
-static TDB_CONTEXT *posix_pending_close_tdb;
+static struct db_context *posix_pending_close_db;
/****************************************************************************
First - the functions that deal with the underlying system locks - these
False if not.
****************************************************************************/
-static bool posix_lock_in_range(SMB_OFF_T *offset_out, SMB_OFF_T *count_out,
- SMB_BIG_UINT u_offset, SMB_BIG_UINT u_count)
+static bool posix_lock_in_range(off_t *offset_out, off_t *count_out,
+ uint64_t u_offset, uint64_t u_count)
{
- SMB_OFF_T offset = (SMB_OFF_T)u_offset;
- SMB_OFF_T count = (SMB_OFF_T)u_count;
+ off_t offset = (off_t)u_offset;
+ off_t count = (off_t)u_count;
/*
* For the type of system we are, attempt to
- * find the maximum positive lock offset as an SMB_OFF_T.
+ * find the maximum positive lock offset as an off_t.
*/
#if defined(MAX_POSITIVE_LOCK_OFFSET) /* Some systems have arbitrary limits. */
- SMB_OFF_T max_positive_lock_offset = (MAX_POSITIVE_LOCK_OFFSET);
-
-#elif defined(LARGE_SMB_OFF_T) && !defined(HAVE_BROKEN_FCNTL64_LOCKS)
-
+ off_t max_positive_lock_offset = (MAX_POSITIVE_LOCK_OFFSET);
+#else
/*
- * In this case SMB_OFF_T is 64 bits,
+ * In this case off_t is 64 bits,
* and the underlying system can handle 64 bit signed locks.
*/
- SMB_OFF_T mask2 = ((SMB_OFF_T)0x4) << (SMB_OFF_T_BITS-4);
- SMB_OFF_T mask = (mask2<<1);
- SMB_OFF_T max_positive_lock_offset = ~mask;
-
-#else /* !LARGE_SMB_OFF_T || HAVE_BROKEN_FCNTL64_LOCKS */
-
- /*
- * In this case either SMB_OFF_T is 32 bits,
- * or the underlying system cannot handle 64 bit signed locks.
- * All offsets & counts must be 2^31 or less.
- */
-
- SMB_OFF_T max_positive_lock_offset = 0x7FFFFFFF;
-
-#endif /* !LARGE_SMB_OFF_T || HAVE_BROKEN_FCNTL64_LOCKS */
+ off_t mask2 = ((off_t)0x4) << (SMB_OFF_T_BITS-4);
+ off_t mask = (mask2<<1);
+ off_t max_positive_lock_offset = ~mask;
+#endif
/*
* POSIX locks of length zero mean lock to end-of-file.
* Win32 locks of length zero are point probes. Ignore
* any Win32 locks of length zero. JRA.
*/
- if (count == (SMB_OFF_T)0) {
+ if (count == (off_t)0) {
DEBUG(10,("posix_lock_in_range: count = 0, ignoring.\n"));
return False;
}
* ignore this lock.
*/
- if (u_offset & ~((SMB_BIG_UINT)max_positive_lock_offset)) {
+ if (u_offset & ~((uint64_t)max_positive_lock_offset)) {
DEBUG(10,("posix_lock_in_range: (offset = %.0f) offset > %.0f and we cannot handle this. Ignoring lock.\n",
- (double)u_offset, (double)((SMB_BIG_UINT)max_positive_lock_offset) ));
+ (double)u_offset, (double)((uint64_t)max_positive_lock_offset) ));
return False;
}
* We must truncate the count to less than max_positive_lock_offset.
*/
- if (u_count & ~((SMB_BIG_UINT)max_positive_lock_offset)) {
+ if (u_count & ~((uint64_t)max_positive_lock_offset)) {
count = max_positive_lock_offset;
}
return True;
}
+bool smb_vfs_call_lock(struct vfs_handle_struct *handle,
+ struct files_struct *fsp, int op, off_t offset,
+ off_t count, int type)
+{
+ VFS_FIND(lock);
+ return handle->fns->lock_fn(handle, fsp, op, offset, count, type);
+}
+
/****************************************************************************
Actual function that does POSIX locks. Copes with 64 -> 32 bit cruft and
broken NFS implementations.
****************************************************************************/
-static bool posix_fcntl_lock(files_struct *fsp, int op, SMB_OFF_T offset, SMB_OFF_T count, int type)
+static bool posix_fcntl_lock(files_struct *fsp, int op, off_t offset, off_t count, int type)
{
bool ret;
DEBUG(8,("posix_fcntl_lock %d %d %.0f %.0f %d\n",fsp->fh->fd,op,(double)offset,(double)count,type));
- ret = SMB_VFS_LOCK(fsp,fsp->fh->fd,op,offset,count,type);
+ ret = SMB_VFS_LOCK(fsp, op, offset, count, type);
if (!ret && ((errno == EFBIG) || (errno == ENOLCK) || (errno == EINVAL))) {
* 32 bit NFS mounted filesystems. Just ignore it.
*/
- if (offset & ~((SMB_OFF_T)0x7fffffff)) {
+ if (offset & ~((off_t)0x7fffffff)) {
DEBUG(0,("Offset greater than 31 bits. Returning success.\n"));
return True;
}
- if (count & ~((SMB_OFF_T)0x7fffffff)) {
+ if (count & ~((off_t)0x7fffffff)) {
/* 32 bit NFS file system, retry with smaller offset */
DEBUG(0,("Count greater than 31 bits - retrying with 31 bit truncated length.\n"));
errno = 0;
count &= 0x7fffffff;
- ret = SMB_VFS_LOCK(fsp,fsp->fh->fd,op,offset,count,type);
+ ret = SMB_VFS_LOCK(fsp, op, offset, count, type);
}
}
return ret;
}
+bool smb_vfs_call_getlock(struct vfs_handle_struct *handle,
+ struct files_struct *fsp, off_t *poffset,
+ off_t *pcount, int *ptype, pid_t *ppid)
+{
+ VFS_FIND(getlock);
+ return handle->fns->getlock_fn(handle, fsp, poffset, pcount, ptype,
+ ppid);
+}
+
/****************************************************************************
Actual function that gets POSIX locks. Copes with 64 -> 32 bit cruft and
broken NFS implementations.
****************************************************************************/
-static bool posix_fcntl_getlock(files_struct *fsp, SMB_OFF_T *poffset, SMB_OFF_T *pcount, int *ptype)
+static bool posix_fcntl_getlock(files_struct *fsp, off_t *poffset, off_t *pcount, int *ptype)
{
pid_t pid;
bool ret;
DEBUG(8,("posix_fcntl_getlock %d %.0f %.0f %d\n",
fsp->fh->fd,(double)*poffset,(double)*pcount,*ptype));
- ret = SMB_VFS_GETLOCK(fsp,fsp->fh->fd,poffset,pcount,ptype,&pid);
+ ret = SMB_VFS_GETLOCK(fsp, poffset, pcount, ptype, &pid);
if (!ret && ((errno == EFBIG) || (errno == ENOLCK) || (errno == EINVAL))) {
* 32 bit NFS mounted filesystems. Just ignore it.
*/
- if (*poffset & ~((SMB_OFF_T)0x7fffffff)) {
+ if (*poffset & ~((off_t)0x7fffffff)) {
DEBUG(0,("Offset greater than 31 bits. Returning success.\n"));
return True;
}
- if (*pcount & ~((SMB_OFF_T)0x7fffffff)) {
+ if (*pcount & ~((off_t)0x7fffffff)) {
/* 32 bit NFS file system, retry with smaller offset */
DEBUG(0,("Count greater than 31 bits - retrying with 31 bit truncated length.\n"));
errno = 0;
*pcount &= 0x7fffffff;
- ret = SMB_VFS_GETLOCK(fsp,fsp->fh->fd,poffset,pcount,ptype,&pid);
+ ret = SMB_VFS_GETLOCK(fsp,poffset,pcount,ptype,&pid);
}
}
****************************************************************************/
bool is_posix_locked(files_struct *fsp,
- SMB_BIG_UINT *pu_offset,
- SMB_BIG_UINT *pu_count,
+ uint64_t *pu_offset,
+ uint64_t *pu_count,
enum brl_type *plock_type,
enum brl_flavour lock_flav)
{
- SMB_OFF_T offset;
- SMB_OFF_T count;
+ off_t offset;
+ off_t count;
int posix_lock_type = map_posix_lock_type(fsp,*plock_type);
- DEBUG(10,("is_posix_locked: File %s, offset = %.0f, count = %.0f, type = %s\n",
- fsp->fsp_name, (double)*pu_offset, (double)*pu_count, posix_lock_type_name(*plock_type) ));
+ DEBUG(10,("is_posix_locked: File %s, offset = %.0f, count = %.0f, "
+ "type = %s\n", fsp_str_dbg(fsp), (double)*pu_offset,
+ (double)*pu_count, posix_lock_type_name(*plock_type)));
/*
* If the requested lock won't fit in the POSIX range, we will
if (lock_flav == POSIX_LOCK) {
/* Only POSIX lock queries need to know the details. */
- *pu_offset = (SMB_BIG_UINT)offset;
- *pu_count = (SMB_BIG_UINT)count;
+ *pu_offset = (uint64_t)offset;
+ *pu_count = (uint64_t)count;
*plock_type = (posix_lock_type == F_RDLCK) ? READ_LOCK : WRITE_LOCK;
}
return True;
Create the in-memory POSIX lock databases.
********************************************************************/
-bool posix_locking_init(int read_only)
+bool posix_locking_init(bool read_only)
{
- if (posix_pending_close_tdb) {
- return True;
+ if (posix_pending_close_db != NULL) {
+ return true;
}
-
- if (!posix_pending_close_tdb) {
- posix_pending_close_tdb = tdb_open_log(NULL, 0, TDB_INTERNAL,
- read_only?O_RDONLY:(O_RDWR|O_CREAT), 0644);
- }
- if (!posix_pending_close_tdb) {
+
+ posix_pending_close_db = db_open_rbt(NULL);
+
+ if (posix_pending_close_db == NULL) {
DEBUG(0,("Failed to open POSIX pending close database.\n"));
- return False;
+ return false;
}
- return True;
+ return true;
}
/*******************************************************************
bool posix_locking_end(void)
{
- if (posix_pending_close_tdb && tdb_close(posix_pending_close_tdb) != 0) {
- return False;
- }
- return True;
+ /*
+ * Shouldn't we close all fd's here?
+ */
+ TALLOC_FREE(posix_pending_close_db);
+ return true;
}
/****************************************************************************
static void increment_windows_lock_ref_count(files_struct *fsp)
{
struct lock_ref_count_key tmp;
- TDB_DATA kbuf = locking_ref_count_key_fsp(fsp, &tmp);
- TDB_DATA dbuf;
- int lock_ref_count;
-
- dbuf = tdb_fetch(posix_pending_close_tdb, kbuf);
- if (dbuf.dptr == NULL) {
- dbuf.dptr = (uint8 *)SMB_MALLOC_P(int);
- if (!dbuf.dptr) {
- smb_panic("increment_windows_lock_ref_count: malloc fail");
- }
- memset(dbuf.dptr, '\0', sizeof(int));
- dbuf.dsize = sizeof(int);
- }
+ struct db_record *rec;
+ int lock_ref_count = 0;
+ NTSTATUS status;
+ TDB_DATA value;
- memcpy(&lock_ref_count, dbuf.dptr, sizeof(int));
- lock_ref_count++;
- memcpy(dbuf.dptr, &lock_ref_count, sizeof(int));
-
- if (tdb_store(posix_pending_close_tdb, kbuf, dbuf, TDB_REPLACE) == -1) {
- smb_panic("increment_windows_lock_ref_count: tdb_store_fail");
- }
- SAFE_FREE(dbuf.dptr);
+ rec = dbwrap_fetch_locked(
+ posix_pending_close_db, talloc_tos(),
+ locking_ref_count_key_fsp(fsp, &tmp));
- DEBUG(10,("increment_windows_lock_ref_count for file now %s = %d\n",
- fsp->fsp_name, lock_ref_count ));
-}
+ SMB_ASSERT(rec != NULL);
-static void decrement_windows_lock_ref_count(files_struct *fsp)
-{
- struct lock_ref_count_key tmp;
- TDB_DATA kbuf = locking_ref_count_key_fsp(fsp, &tmp);
- TDB_DATA dbuf;
- int lock_ref_count;
+ value = dbwrap_record_get_value(rec);
- dbuf = tdb_fetch(posix_pending_close_tdb, kbuf);
- if (!dbuf.dptr) {
- smb_panic("decrement_windows_lock_ref_count: logic error");
+ if (value.dptr != NULL) {
+ SMB_ASSERT(value.dsize == sizeof(lock_ref_count));
+ memcpy(&lock_ref_count, value.dptr,
+ sizeof(lock_ref_count));
}
- memcpy(&lock_ref_count, dbuf.dptr, sizeof(int));
- lock_ref_count--;
- memcpy(dbuf.dptr, &lock_ref_count, sizeof(int));
+ lock_ref_count++;
- if (lock_ref_count < 0) {
- smb_panic("decrement_windows_lock_ref_count: lock_count logic error");
- }
+ status = dbwrap_record_store(rec,
+ make_tdb_data((uint8 *)&lock_ref_count,
+ sizeof(lock_ref_count)), 0);
- if (tdb_store(posix_pending_close_tdb, kbuf, dbuf, TDB_REPLACE) == -1) {
- smb_panic("decrement_windows_lock_ref_count: tdb_store_fail");
- }
- SAFE_FREE(dbuf.dptr);
+ SMB_ASSERT(NT_STATUS_IS_OK(status));
- DEBUG(10,("decrement_windows_lock_ref_count for file now %s = %d\n",
- fsp->fsp_name, lock_ref_count ));
+ TALLOC_FREE(rec);
+
+ DEBUG(10,("increment_windows_lock_ref_count for file now %s = %d\n",
+ fsp_str_dbg(fsp), lock_ref_count));
}
/****************************************************************************
void reduce_windows_lock_ref_count(files_struct *fsp, unsigned int dcount)
{
struct lock_ref_count_key tmp;
- TDB_DATA kbuf = locking_ref_count_key_fsp(fsp, &tmp);
- TDB_DATA dbuf;
- int lock_ref_count;
+ struct db_record *rec;
+ int lock_ref_count = 0;
+ NTSTATUS status;
+ TDB_DATA value;
- dbuf = tdb_fetch(posix_pending_close_tdb, kbuf);
- if (!dbuf.dptr) {
+ rec = dbwrap_fetch_locked(
+ posix_pending_close_db, talloc_tos(),
+ locking_ref_count_key_fsp(fsp, &tmp));
+
+ if (rec == NULL) {
+ DEBUG(0, ("reduce_windows_lock_ref_count: rec not found\n"));
return;
}
- memcpy(&lock_ref_count, dbuf.dptr, sizeof(int));
- lock_ref_count -= dcount;
+ value = dbwrap_record_get_value(rec);
- if (lock_ref_count < 0) {
- smb_panic("reduce_windows_lock_ref_count: lock_count logic error");
- }
- memcpy(dbuf.dptr, &lock_ref_count, sizeof(int));
-
- if (tdb_store(posix_pending_close_tdb, kbuf, dbuf, TDB_REPLACE) == -1) {
- smb_panic("reduce_windows_lock_ref_count: tdb_store_fail");
+ if ((value.dptr == NULL) || (value.dsize != sizeof(lock_ref_count))) {
+ DEBUG(0, ("reduce_windows_lock_ref_count: wrong value\n"));
+ TALLOC_FREE(rec);
+ return;
}
- SAFE_FREE(dbuf.dptr);
+
+ memcpy(&lock_ref_count, value.dptr, sizeof(lock_ref_count));
+
+ SMB_ASSERT(lock_ref_count > 0);
+
+ lock_ref_count -= dcount;
+
+ status = dbwrap_record_store(rec,
+ make_tdb_data((uint8 *)&lock_ref_count,
+ sizeof(lock_ref_count)), 0);
+
+ SMB_ASSERT(NT_STATUS_IS_OK(status));
+
+ TALLOC_FREE(rec);
DEBUG(10,("reduce_windows_lock_ref_count for file now %s = %d\n",
- fsp->fsp_name, lock_ref_count ));
+ fsp_str_dbg(fsp), lock_ref_count));
+}
+
+static void decrement_windows_lock_ref_count(files_struct *fsp)
+{
+ reduce_windows_lock_ref_count(fsp, 1);
}
/****************************************************************************
static int get_windows_lock_ref_count(files_struct *fsp)
{
struct lock_ref_count_key tmp;
- TDB_DATA kbuf = locking_ref_count_key_fsp(fsp, &tmp);
TDB_DATA dbuf;
- int lock_ref_count;
+ NTSTATUS status;
+ int lock_ref_count = 0;
- dbuf = tdb_fetch(posix_pending_close_tdb, kbuf);
- if (!dbuf.dptr) {
- lock_ref_count = 0;
- } else {
- memcpy(&lock_ref_count, dbuf.dptr, sizeof(int));
+ status = dbwrap_fetch(
+ posix_pending_close_db, talloc_tos(),
+ locking_ref_count_key_fsp(fsp, &tmp), &dbuf);
+
+ if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
+ goto done;
+ }
+
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(0, ("get_windows_lock_ref_count: Error fetching "
+ "lock ref count for file %s: %s\n",
+ fsp_str_dbg(fsp), nt_errstr(status)));
+ goto done;
+ }
+
+ if (dbuf.dsize != sizeof(lock_ref_count)) {
+ DEBUG(0, ("get_windows_lock_ref_count: invalid entry "
+ "in lock ref count record for file %s: "
+ "(invalid data size %u)\n",
+ fsp_str_dbg(fsp), (unsigned int)dbuf.dsize));
+ goto done;
}
- SAFE_FREE(dbuf.dptr);
+ memcpy(&lock_ref_count, dbuf.dptr, sizeof(lock_ref_count));
+ TALLOC_FREE(dbuf.dptr);
+
+done:
DEBUG(10,("get_windows_lock_count for file %s = %d\n",
- fsp->fsp_name, lock_ref_count ));
+ fsp_str_dbg(fsp), lock_ref_count));
+
return lock_ref_count;
}
static void delete_windows_lock_ref_count(files_struct *fsp)
{
struct lock_ref_count_key tmp;
- TDB_DATA kbuf = locking_ref_count_key_fsp(fsp, &tmp);
+ struct db_record *rec;
+
+ rec = dbwrap_fetch_locked(
+ posix_pending_close_db, talloc_tos(),
+ locking_ref_count_key_fsp(fsp, &tmp));
+
+ SMB_ASSERT(rec != NULL);
/* Not a bug if it doesn't exist - no locks were ever granted. */
- tdb_delete(posix_pending_close_tdb, kbuf);
- DEBUG(10,("delete_windows_lock_ref_count for file %s\n", fsp->fsp_name));
+
+ dbwrap_record_delete(rec);
+ TALLOC_FREE(rec);
+
+ DEBUG(10,("delete_windows_lock_ref_count for file %s\n",
+ fsp_str_dbg(fsp)));
}
/****************************************************************************
static void add_fd_to_close_entry(files_struct *fsp)
{
- TDB_DATA kbuf = fd_array_key_fsp(fsp);
- TDB_DATA dbuf;
+ struct db_record *rec;
+ uint8_t *new_data;
+ NTSTATUS status;
+ TDB_DATA value;
- dbuf.dptr = NULL;
- dbuf.dsize = 0;
+ rec = dbwrap_fetch_locked(
+ posix_pending_close_db, talloc_tos(),
+ fd_array_key_fsp(fsp));
- dbuf = tdb_fetch(posix_pending_close_tdb, kbuf);
+ SMB_ASSERT(rec != NULL);
- dbuf.dptr = (uint8 *)SMB_REALLOC(dbuf.dptr, dbuf.dsize + sizeof(int));
- if (!dbuf.dptr) {
- smb_panic("add_fd_to_close_entry: SMB_REALLOC failed");
- }
+ value = dbwrap_record_get_value(rec);
- memcpy(dbuf.dptr + dbuf.dsize, &fsp->fh->fd, sizeof(int));
- dbuf.dsize += sizeof(int);
+ new_data = talloc_array(rec, uint8_t,
+ value.dsize + sizeof(fsp->fh->fd));
- if (tdb_store(posix_pending_close_tdb, kbuf, dbuf, TDB_REPLACE) == -1) {
- smb_panic("add_fd_to_close_entry: tdb_store_fail");
- }
+ SMB_ASSERT(new_data != NULL);
- DEBUG(10,("add_fd_to_close_entry: added fd %d file %s\n",
- fsp->fh->fd, fsp->fsp_name ));
+ memcpy(new_data, value.dptr, value.dsize);
+ memcpy(new_data + value.dsize,
+ &fsp->fh->fd, sizeof(fsp->fh->fd));
+
+ status = dbwrap_record_store(
+ rec, make_tdb_data(new_data,
+ value.dsize + sizeof(fsp->fh->fd)), 0);
- SAFE_FREE(dbuf.dptr);
+ SMB_ASSERT(NT_STATUS_IS_OK(status));
+
+ TALLOC_FREE(rec);
+
+ DEBUG(10,("add_fd_to_close_entry: added fd %d file %s\n",
+ fsp->fh->fd, fsp_str_dbg(fsp)));
}
/****************************************************************************
static void delete_close_entries(files_struct *fsp)
{
- TDB_DATA kbuf = fd_array_key_fsp(fsp);
+ struct db_record *rec;
- if (tdb_delete(posix_pending_close_tdb, kbuf) == -1) {
- smb_panic("delete_close_entries: tdb_delete failed");
- }
+ rec = dbwrap_fetch_locked(
+ posix_pending_close_db, talloc_tos(),
+ fd_array_key_fsp(fsp));
+
+ SMB_ASSERT(rec != NULL);
+ dbwrap_record_delete(rec);
+ TALLOC_FREE(rec);
}
/****************************************************************************
- Get the array of POSIX pending close records for an open fsp. Caller must
- free. Returns number of entries.
+ Get the array of POSIX pending close records for an open fsp. Returns number
+ of entries.
****************************************************************************/
-static size_t get_posix_pending_close_entries(files_struct *fsp, int **entries)
+static size_t get_posix_pending_close_entries(TALLOC_CTX *mem_ctx,
+ files_struct *fsp, int **entries)
{
- TDB_DATA kbuf = fd_array_key_fsp(fsp);
TDB_DATA dbuf;
- size_t count = 0;
+ NTSTATUS status;
+
+ status = dbwrap_fetch(
+ posix_pending_close_db, mem_ctx, fd_array_key_fsp(fsp),
+ &dbuf);
- *entries = NULL;
- dbuf.dptr = NULL;
+ if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
+ *entries = NULL;
+ return 0;
+ }
- dbuf = tdb_fetch(posix_pending_close_tdb, kbuf);
+ SMB_ASSERT(NT_STATUS_IS_OK(status));
- if (!dbuf.dptr) {
+ if (dbuf.dsize == 0) {
+ *entries = NULL;
return 0;
}
*entries = (int *)dbuf.dptr;
- count = (size_t)(dbuf.dsize / sizeof(int));
-
- return count;
+ return (size_t)(dbuf.dsize / sizeof(int));
}
/****************************************************************************
to delete all locks on this fsp before this function is called.
****************************************************************************/
-NTSTATUS fd_close_posix(struct connection_struct *conn, files_struct *fsp)
+int fd_close_posix(struct files_struct *fsp)
{
int saved_errno = 0;
int ret;
int *fd_array = NULL;
size_t count, i;
- if (!lp_locking(fsp->conn->params) || !lp_posix_locking(conn->params)) {
+ if (!lp_locking(fsp->conn->params) ||
+ !lp_posix_locking(fsp->conn->params))
+ {
/*
* No locking or POSIX to worry about or we want POSIX semantics
* which will lose all locks on all fd's open on this dev/inode,
* just close.
*/
- ret = SMB_VFS_CLOSE(fsp,fsp->fh->fd);
- fsp->fh->fd = -1;
- if (ret == -1) {
- return map_nt_error_from_unix(errno);
- }
- return NT_STATUS_OK;
+ return close(fsp->fh->fd);
}
if (get_windows_lock_ref_count(fsp)) {
/*
- * There are outstanding locks on this dev/inode pair on other fds.
- * Add our fd to the pending close tdb and set fsp->fh->fd to -1.
+ * There are outstanding locks on this dev/inode pair on
+ * other fds. Add our fd to the pending close tdb and set
+ * fsp->fh->fd to -1.
*/
add_fd_to_close_entry(fsp);
- fsp->fh->fd = -1;
- return NT_STATUS_OK;
+ return 0;
}
/*
* from the tdb and close them all.
*/
- count = get_posix_pending_close_entries(fsp, &fd_array);
+ count = get_posix_pending_close_entries(talloc_tos(), fsp, &fd_array);
if (count) {
- DEBUG(10,("fd_close_posix: doing close on %u fd's.\n", (unsigned int)count ));
+ DEBUG(10,("fd_close_posix: doing close on %u fd's.\n",
+ (unsigned int)count));
for(i = 0; i < count; i++) {
- if (SMB_VFS_CLOSE(fsp,fd_array[i]) == -1) {
+ if (close(fd_array[i]) == -1) {
saved_errno = errno;
}
}
delete_close_entries(fsp);
}
- SAFE_FREE(fd_array);
+ TALLOC_FREE(fd_array);
/* Don't need a lock ref count on this dev/ino anymore. */
delete_windows_lock_ref_count(fsp);
* Finally close the fd associated with this fsp.
*/
- ret = SMB_VFS_CLOSE(fsp,fsp->fh->fd);
+ ret = close(fsp->fh->fd);
if (ret == 0 && saved_errno != 0) {
errno = saved_errno;
ret = -1;
- }
-
- fsp->fh->fd = -1;
-
- if (ret == -1) {
- return map_nt_error_from_unix(errno);
}
- return NT_STATUS_OK;
+ return ret;
}
/****************************************************************************
struct lock_list {
struct lock_list *next;
struct lock_list *prev;
- SMB_OFF_T start;
- SMB_OFF_T size;
+ off_t start;
+ off_t size;
};
/****************************************************************************
| l_curr| | l_new |
+-------+ +---------+
**********************************************/
- struct lock_list *l_new = TALLOC_P(ctx, struct lock_list);
+ struct lock_list *l_new = talloc(ctx, struct lock_list);
if(l_new == NULL) {
DEBUG(0,("posix_lock_list: talloc fail.\n"));
/*
* Add into the dlink list after the l_curr point - NOT at lhead.
- * Note we can't use DLINK_ADD here as this inserts at the head of the given list.
*/
-
- l_new->prev = l_curr;
- l_new->next = l_curr->next;
- l_curr->next = l_new;
+ DLIST_ADD_AFTER(lhead, l_new, l_curr);
/* And move after the link we added. */
l_curr = l_new->next;
*/
char *msg = NULL;
- /* Don't check if alloc succeeds here - we're
- * forcing a core dump anyway. */
-
- asprintf(&msg, "logic flaw in cases: l_curr: start = %.0f, size = %.0f : \
-lock: start = %.0f, size = %.0f", (double)l_curr->start, (double)l_curr->size, (double)lock->start, (double)lock->size );
-
- smb_panic(msg);
+ if (asprintf(&msg, "logic flaw in cases: l_curr: start = %.0f, size = %.0f : \
+lock: start = %.0f, size = %.0f", (double)l_curr->start, (double)l_curr->size, (double)lock->start, (double)lock->size ) != -1) {
+ smb_panic(msg);
+ } else {
+ smb_panic("posix_lock_list");
+ }
}
} /* end for ( l_curr = lhead; l_curr;) */
} /* end for (i=0; i<num_locks && ul_head; i++) */
****************************************************************************/
bool set_posix_lock_windows_flavour(files_struct *fsp,
- SMB_BIG_UINT u_offset,
- SMB_BIG_UINT u_count,
+ uint64_t u_offset,
+ uint64_t u_count,
enum brl_type lock_type,
const struct lock_context *lock_ctx,
const struct lock_struct *plocks,
int num_locks,
int *errno_ret)
{
- SMB_OFF_T offset;
- SMB_OFF_T count;
+ off_t offset;
+ off_t count;
int posix_lock_type = map_posix_lock_type(fsp,lock_type);
bool ret = True;
size_t lock_count;
struct lock_list *llist = NULL;
struct lock_list *ll = NULL;
- DEBUG(5,("set_posix_lock_windows_flavour: File %s, offset = %.0f, count = %.0f, type = %s\n",
- fsp->fsp_name, (double)u_offset, (double)u_count, posix_lock_type_name(lock_type) ));
+ DEBUG(5,("set_posix_lock_windows_flavour: File %s, offset = %.0f, "
+ "count = %.0f, type = %s\n", fsp_str_dbg(fsp),
+ (double)u_offset, (double)u_count,
+ posix_lock_type_name(lock_type)));
/*
* If the requested lock won't fit in the POSIX range, we will
return False;
}
- if ((ll = TALLOC_P(l_ctx, struct lock_list)) == NULL) {
+ if ((ll = talloc(l_ctx, struct lock_list)) == NULL) {
DEBUG(0,("set_posix_lock_windows_flavour: unable to talloc unlock list.\n"));
talloc_destroy(l_ctx);
return False;
DEBUG(5,("set_posix_lock_windows_flavour: Real lock: Type = %s: offset = %.0f, count = %.0f\n",
posix_lock_type_name(posix_lock_type), (double)offset, (double)count ));
- if (!posix_fcntl_lock(fsp,SMB_F_SETLK,offset,count,posix_lock_type)) {
+ if (!posix_fcntl_lock(fsp,F_SETLK,offset,count,posix_lock_type)) {
*errno_ret = errno;
DEBUG(5,("set_posix_lock_windows_flavour: Lock fail !: Type = %s: offset = %.0f, count = %.0f. Errno = %s\n",
posix_lock_type_name(posix_lock_type), (double)offset, (double)count, strerror(errno) ));
DEBUG(5,("set_posix_lock_windows_flavour: Backing out locks: Type = %s: offset = %.0f, count = %.0f\n",
posix_lock_type_name(posix_lock_type), (double)offset, (double)count ));
- posix_fcntl_lock(fsp,SMB_F_SETLK,offset,count,F_UNLCK);
+ posix_fcntl_lock(fsp,F_SETLK,offset,count,F_UNLCK);
}
} else {
/* Remember the number of Windows locks we have on this dev/ino pair. */
****************************************************************************/
bool release_posix_lock_windows_flavour(files_struct *fsp,
- SMB_BIG_UINT u_offset,
- SMB_BIG_UINT u_count,
+ uint64_t u_offset,
+ uint64_t u_count,
enum brl_type deleted_lock_type,
const struct lock_context *lock_ctx,
const struct lock_struct *plocks,
int num_locks)
{
- SMB_OFF_T offset;
- SMB_OFF_T count;
+ off_t offset;
+ off_t count;
bool ret = True;
TALLOC_CTX *ul_ctx = NULL;
struct lock_list *ulist = NULL;
struct lock_list *ul = NULL;
- DEBUG(5,("release_posix_lock_windows_flavour: File %s, offset = %.0f, count = %.0f\n",
- fsp->fsp_name, (double)u_offset, (double)u_count ));
+ DEBUG(5,("release_posix_lock_windows_flavour: File %s, offset = %.0f, "
+ "count = %.0f\n", fsp_str_dbg(fsp),
+ (double)u_offset, (double)u_count));
/* Remember the number of Windows locks we have on this dev/ino pair. */
decrement_windows_lock_ref_count(fsp);
return False;
}
- if ((ul = TALLOC_P(ul_ctx, struct lock_list)) == NULL) {
+ if ((ul = talloc(ul_ctx, struct lock_list)) == NULL) {
DEBUG(0,("release_posix_lock_windows_flavour: unable to talloc unlock list.\n"));
talloc_destroy(ul_ctx);
return False;
DEBUG(5,("release_posix_lock_windows_flavour: downgrading lock to READ: offset = %.0f, count = %.0f\n",
(double)offset, (double)count ));
- if (!posix_fcntl_lock(fsp,SMB_F_SETLK,offset,count,F_RDLCK)) {
+ if (!posix_fcntl_lock(fsp,F_SETLK,offset,count,F_RDLCK)) {
DEBUG(0,("release_posix_lock_windows_flavour: downgrade of lock failed with error %s !\n", strerror(errno) ));
talloc_destroy(ul_ctx);
return False;
DEBUG(5,("release_posix_lock_windows_flavour: Real unlock: offset = %.0f, count = %.0f\n",
(double)offset, (double)count ));
- if (!posix_fcntl_lock(fsp,SMB_F_SETLK,offset,count,F_UNLCK)) {
+ if (!posix_fcntl_lock(fsp,F_SETLK,offset,count,F_UNLCK)) {
ret = False;
}
}
****************************************************************************/
bool set_posix_lock_posix_flavour(files_struct *fsp,
- SMB_BIG_UINT u_offset,
- SMB_BIG_UINT u_count,
+ uint64_t u_offset,
+ uint64_t u_count,
enum brl_type lock_type,
int *errno_ret)
{
- SMB_OFF_T offset;
- SMB_OFF_T count;
+ off_t offset;
+ off_t count;
int posix_lock_type = map_posix_lock_type(fsp,lock_type);
- DEBUG(5,("set_posix_lock_posix_flavour: File %s, offset = %.0f, count = %.0f, type = %s\n",
- fsp->fsp_name, (double)u_offset, (double)u_count, posix_lock_type_name(lock_type) ));
+ DEBUG(5,("set_posix_lock_posix_flavour: File %s, offset = %.0f, count "
+ "= %.0f, type = %s\n", fsp_str_dbg(fsp),
+ (double)u_offset, (double)u_count,
+ posix_lock_type_name(lock_type)));
/*
* If the requested lock won't fit in the POSIX range, we will
return True;
}
- if (!posix_fcntl_lock(fsp,SMB_F_SETLK,offset,count,posix_lock_type)) {
+ if (!posix_fcntl_lock(fsp,F_SETLK,offset,count,posix_lock_type)) {
*errno_ret = errno;
DEBUG(5,("set_posix_lock_posix_flavour: Lock fail !: Type = %s: offset = %.0f, count = %.0f. Errno = %s\n",
posix_lock_type_name(posix_lock_type), (double)offset, (double)count, strerror(errno) ));
****************************************************************************/
bool release_posix_lock_posix_flavour(files_struct *fsp,
- SMB_BIG_UINT u_offset,
- SMB_BIG_UINT u_count,
+ uint64_t u_offset,
+ uint64_t u_count,
const struct lock_context *lock_ctx,
const struct lock_struct *plocks,
int num_locks)
{
bool ret = True;
- SMB_OFF_T offset;
- SMB_OFF_T count;
+ off_t offset;
+ off_t count;
TALLOC_CTX *ul_ctx = NULL;
struct lock_list *ulist = NULL;
struct lock_list *ul = NULL;
- DEBUG(5,("release_posix_lock_posix_flavour: File %s, offset = %.0f, count = %.0f\n",
- fsp->fsp_name, (double)u_offset, (double)u_count ));
+ DEBUG(5,("release_posix_lock_posix_flavour: File %s, offset = %.0f, "
+ "count = %.0f\n", fsp_str_dbg(fsp),
+ (double)u_offset, (double)u_count));
/*
* If the requested lock won't fit in the POSIX range, we will
return False;
}
- if ((ul = TALLOC_P(ul_ctx, struct lock_list)) == NULL) {
+ if ((ul = talloc(ul_ctx, struct lock_list)) == NULL) {
DEBUG(0,("release_posix_lock_windows_flavour: unable to talloc unlock list.\n"));
talloc_destroy(ul_ctx);
return False;
DEBUG(5,("release_posix_lock_posix_flavour: Real unlock: offset = %.0f, count = %.0f\n",
(double)offset, (double)count ));
- if (!posix_fcntl_lock(fsp,SMB_F_SETLK,offset,count,F_UNLCK)) {
+ if (!posix_fcntl_lock(fsp,F_SETLK,offset,count,F_UNLCK)) {
ret = False;
}
}
git.samba.org / kai / samba.git / blobdiff