Changeset 988 for vendor/current/source3/locking

Timestamp:

Nov 24, 2016, 1:14:11 PM (9 years ago)

Author:

Silvan Scherrer

Message:

Samba Server: update vendor to version 4.4.3

Location:

vendor/current/source3/locking

Files:

• brlock.c (modified) (74 diffs)
• leases_db.c (added)
• leases_db.h (added)
• locking.c (modified) (45 diffs)
• posix.c (modified) (53 diffs)
• proto.h (modified) (11 diffs)
• share_mode_lock.c (added)

vendor/current/source3/locking/brlock.c

@@ -1 @@
-/* 
+/*
    Unix SMB/CIFS implementation.
    byte range locking code
@@ -6 +6 @@
    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 3 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, see <http://www.gnu.org/licenses/>.
@@ -29 +29 @@
 #include "locking/proto.h"
 #include "smbd/globals.h"
-#include "dbwrap.h"
+#include "dbwrap/dbwrap.h"
+#include "dbwrap/dbwrap_open.h"
 #include "serverid.h"
 #include "messages.h"
+#include "util_tdb.h"
 
 #undef DBGC_CLASS
@@ -41 +43 @@
 
 static struct db_context *brlock_db;
+
+struct byte_range_lock {
+        struct files_struct *fsp;
+        unsigned int num_locks;
+        bool modified;
+        uint32_t num_read_oplocks;
+        struct lock_struct *lock_data;
+        struct db_record *record;
+};
 
 /****************************************************************************
@@ -46 +57 @@
 ****************************************************************************/
 
-static void print_lock_struct(unsigned int i, struct lock_struct *pls)
-{
+static void print_lock_struct(unsigned int i, const struct lock_struct *pls)
+{
+        struct server_id_buf tmp;
+
         DEBUG(10,("[%u]: smblctx = %llu, tid = %u, pid = %s, ",
                         i,
                         (unsigned long long)pls->context.smblctx,
                         (unsigned int)pls->context.tid,
-                        procid_str(talloc_tos(), &pls->context.pid) ));
-        
-        DEBUG(10,("start = %.0f, size = %.0f, fnum = %d, %s %s\n",
-                (double)pls->start,
-                (double)pls->size,
-                pls->fnum,
-                lock_type_name(pls->lock_type),
-                lock_flav_name(pls->lock_flav) ));
+                        server_id_str_buf(pls->context.pid, &tmp) ));
+
+        DEBUG(10, ("start = %ju, size = %ju, fnum = %ju, %s %s\n",
+                   (uintmax_t)pls->start,
+                   (uintmax_t)pls->size,
+                   (uintmax_t)pls->fnum,
+                   lock_type_name(pls->lock_type),
+                   lock_flav_name(pls->lock_flav)));
+}
+
+unsigned int brl_num_locks(const struct byte_range_lock *brl)
+{
+        return brl->num_locks;
+}
+
+struct files_struct *brl_fsp(struct byte_range_lock *brl)
+{
+        return brl->fsp;
+}
+
+uint32_t brl_num_read_oplocks(const struct byte_range_lock *brl)
+{
+        return brl->num_read_oplocks;
+}
+
+void brl_set_num_read_oplocks(struct byte_range_lock *brl,
+                              uint32_t num_read_oplocks)
+{
+        DEBUG(10, ("Setting num_read_oplocks to %"PRIu32"\n",
+                   num_read_oplocks));
+        SMB_ASSERT(brl->record != NULL); /* otherwise we're readonly */
+        brl->num_read_oplocks = num_read_oplocks;
+        brl->modified = true;
 }
 
@@ -66 +104 @@
 ****************************************************************************/
 
-bool brl_same_context(const struct lock_context *ctx1, 
+static bool brl_same_context(const struct lock_context *ctx1,
                              const struct lock_context *ctx2)
 {
-        return (procid_equal(&ctx1->pid, &ctx2->pid) &&
+        return (serverid_equal(&ctx1->pid, &ctx2->pid) &&
                 (ctx1->smblctx == ctx2->smblctx) &&
                 (ctx1->tid == ctx2->tid));
@@ -82 +120 @@
 {
         /* XXX Remove for Win7 compatibility. */
-        /* this extra check is not redundent - it copes with locks
+        /* this extra check is not redundant - it copes with locks
            that go beyond the end of 64 bit file space */
         if (lck1->size != 0 &&
@@ -101 +139 @@
 ****************************************************************************/
 
-static bool brl_conflict(const struct lock_struct *lck1, 
+static bool brl_conflict(const struct lock_struct *lck1,
                          const struct lock_struct *lck2)
 {
@@ -122 +160 @@
 
         return brl_overlap(lck1, lck2);
-} 
+}
 
 /****************************************************************************
@@ -130 +168 @@
 ****************************************************************************/
 
-static bool brl_conflict_posix(const struct lock_struct *lck1, 
+static bool brl_conflict_posix(const struct lock_struct *lck1,
                                 const struct lock_struct *lck2)
 {
@@ -147 +185 @@
         }
 
-        /* Locks on the same context con't conflict. Ignore fnum. */
+        /* Locks on the same context don't conflict. Ignore fnum. */
         if (brl_same_context(&lck1->context, &lck2->context)) {
                 return False;
@@ -155 +193 @@
            do they overlap ? */
         return brl_overlap(lck1, lck2);
-} 
+}
 
 #if ZERO_ZERO
-static bool brl_conflict1(const struct lock_struct *lck1, 
+static bool brl_conflict1(const struct lock_struct *lck1,
                          const struct lock_struct *lck2)
 {
@@ -181 +219 @@
                 return False;
         }
-            
+
         return True;
-} 
+}
 #endif
 
@@ -192 +230 @@
 ****************************************************************************/
 
-static bool brl_conflict_other(const struct lock_struct *lck1, const struct lock_struct *lck2)
-{
-        if (IS_PENDING_LOCK(lck1->lock_type) || IS_PENDING_LOCK(lck2->lock_type))
+static bool brl_conflict_other(const struct lock_struct *lock,
+                               const struct lock_struct *rw_probe)
+{
+        if (IS_PENDING_LOCK(lock->lock_type) ||
+            IS_PENDING_LOCK(rw_probe->lock_type)) {
                 return False;
-
-        if (lck1->lock_type == READ_LOCK && lck2->lock_type == READ_LOCK) 
+        }
+
+        if (lock->lock_type == READ_LOCK && rw_probe->lock_type == READ_LOCK) {
                 return False;
-
-        /* POSIX flavour locks never conflict here - this is only called
-           in the read/write path. */
-
-        if (lck1->lock_flav == POSIX_LOCK && lck2->lock_flav == POSIX_LOCK)
+        }
+
+        if (lock->lock_flav == POSIX_LOCK &&
+            rw_probe->lock_flav == POSIX_LOCK) {
+                /*
+                 * POSIX flavour locks never conflict here - this is only called
+                 * in the read/write path.
+                 */
                 return False;
+        }
+
+        if (!brl_overlap(lock, rw_probe)) {
+                /*
+                 * I/O can only conflict when overlapping a lock, thus let it
+                 * pass
+                 */
+                return false;
+        }
+
+        if (!brl_same_context(&lock->context, &rw_probe->context)) {
+                /*
+                 * Different process, conflict
+                 */
+                return true;
+        }
+
+        if (lock->fnum != rw_probe->fnum) {
+                /*
+                 * Different file handle, conflict
+                 */
+                return true;
+        }
+
+        if ((lock->lock_type == READ_LOCK) &&
+            (rw_probe->lock_type == WRITE_LOCK)) {
+                /*
+                 * Incoming WRITE locks conflict with existing READ locks even
+                 * if the context is the same. JRA. See LOCKTEST7 in
+                 * smbtorture.
+                 */
+                return true;
+        }
 
         /*
-         * Incoming WRITE locks conflict with existing READ locks even
-         * if the context is the same. JRA. See LOCKTEST7 in smbtorture.
+         * I/O request compatible with existing lock, let it pass without
+         * conflict
          */
 
-        if (!(lck2->lock_type == WRITE_LOCK && lck1->lock_type == READ_LOCK)) {
-                if (brl_same_context(&lck1->context, &lck2->context) &&
-                                        lck1->fnum == lck2->fnum)
-                        return False;
-        }
-
-        return brl_overlap(lck1, lck2);
-} 
+        return false;
+}
 
 /****************************************************************************
@@ -228 +299 @@
         if ((lock->start <= pend_lock->start) && (lock->start + lock->size > pend_lock->start))
                 return True;
-        if ((lock->start >= pend_lock->start) && (lock->start <= pend_lock->start + pend_lock->size))
+        if ((lock->start >= pend_lock->start) && (lock->start < pend_lock->start + pend_lock->size))
                 return True;
         return False;
@@ -239 +310 @@
 ****************************************************************************/
 
-NTSTATUS brl_lock_failed(files_struct *fsp, const struct lock_struct *lock, bool blocking_lock)
+static NTSTATUS brl_lock_failed(files_struct *fsp,
+                                const struct lock_struct *lock,
+                                bool blocking_lock)
 {
         if (lock->start >= 0xEF000000 && (lock->start >> 63) == 0) {
@@ -252 +325 @@
         }
 
-        if (procid_equal(&lock->context.pid, &fsp->last_lock_failure.context.pid) &&
+        if (serverid_equal(&lock->context.pid, &fsp->last_lock_failure.context.pid) &&
                         lock->context.tid == fsp->last_lock_failure.context.tid &&
                         lock->fnum == fsp->last_lock_failure.fnum &&
@@ -272 +345 @@
 {
         int tdb_flags;
+        char *db_path;
 
         if (brlock_db) {
@@ -288 +362 @@
         }
 
-        brlock_db = db_open(NULL, lock_path("brlock.tdb"),
-                            lp_open_files_db_hash_size(), tdb_flags,
-                            read_only?O_RDONLY:(O_RDWR|O_CREAT), 0644 );
+        db_path = lock_path("brlock.tdb");
+        if (db_path == NULL) {
+                DEBUG(0, ("out of memory!\n"));
+                return;
+        }
+
+        brlock_db = db_open(NULL, db_path,
+                            SMB_OPEN_DATABASE_TDB_HASH_SIZE, tdb_flags,
+                            read_only?O_RDONLY:(O_RDWR|O_CREAT), 0644,
+                            DBWRAP_LOCK_ORDER_2, DBWRAP_FLAG_NONE);
         if (!brlock_db) {
                 DEBUG(0,("Failed to open byte range locking database %s\n",
-                        lock_path("brlock.tdb")));
+                         db_path));
+                TALLOC_FREE(db_path);
                 return;
         }
+        TALLOC_FREE(db_path);
 }
 
@@ -312 +395 @@
 ****************************************************************************/
 
-static int lock_compare(const struct lock_struct *lck1, 
+static int lock_compare(const struct lock_struct *lck1,
                          const struct lock_struct *lck2)
 {
@@ -347 +430 @@
                 /* Do any Windows or POSIX locks conflict ? */
                 if (brl_conflict(&locks[i], plock)) {
+                        if (!serverid_exists(&locks[i].context.pid)) {
+                                locks[i].context.pid.pid = 0;
+                                br_lck->modified = true;
+                                continue;
+                        }
                         /* Remember who blocked us. */
                         plock->context.smblctx = locks[i].context.smblctx;
@@ -352 +440 @@
                 }
 #if ZERO_ZERO
-                if (plock->start == 0 && plock->size == 0 && 
+                if (plock->start == 0 && plock->size == 0 &&
                                 locks[i].size == 0) {
                         break;
@@ -392 +480 @@
 
         /* no conflicts - add it to the list of locks */
-        locks = (struct lock_struct *)SMB_REALLOC(locks, (br_lck->num_locks + 1) * sizeof(*locks));
+        locks = talloc_realloc(br_lck, locks, struct lock_struct,
+                               (br_lck->num_locks + 1));
         if (!locks) {
                 status = NT_STATUS_NO_MEMORY;
@@ -730 +819 @@
            so we need at most 2 more entries. */
 
-        tp = SMB_MALLOC_ARRAY(struct lock_struct, (br_lck->num_locks + 2));
+        tp = talloc_array(br_lck, struct lock_struct, br_lck->num_locks + 2);
         if (!tp) {
                 return NT_STATUS_NO_MEMORY;
@@ -750 +839 @@
                         /* Do any Windows flavour locks conflict ? */
                         if (brl_conflict(curr_lock, plock)) {
+                                if (!serverid_exists(&curr_lock->context.pid)) {
+                                        curr_lock->context.pid.pid = 0;
+                                        br_lck->modified = true;
+                                        continue;
+                                }
                                 /* No games with error messages. */
-                                SAFE_FREE(tp);
+                                TALLOC_FREE(tp);
                                 /* Remember who blocked us. */
                                 plock->context.smblctx = curr_lock->context.smblctx;
@@ -764 +858 @@
                         /* POSIX conflict semantics are different. */
                         if (brl_conflict_posix(curr_lock, plock)) {
+                                if (!serverid_exists(&curr_lock->context.pid)) {
+                                        curr_lock->context.pid.pid = 0;
+                                        br_lck->modified = true;
+                                        continue;
+                                }
                                 /* Can't block ourselves with POSIX locks. */
                                 /* No games with error messages. */
-                                SAFE_FREE(tp);
+                                TALLOC_FREE(tp);
                                 /* Remember who blocked us. */
                                 plock->context.smblctx = curr_lock->context.smblctx;
@@ -831 +930 @@
 
                         if (errno_ret == EACCES || errno_ret == EAGAIN) {
-                                SAFE_FREE(tp);
+                                TALLOC_FREE(tp);
                                 status = NT_STATUS_FILE_LOCK_CONFLICT;
                                 goto fail;
                         } else {
-                                SAFE_FREE(tp);
+                                TALLOC_FREE(tp);
                                 status = map_nt_error_from_unix(errno);
                                 goto fail;
@@ -845 +944 @@
          * Realloc so we don't leak entries per lock call. */
         if (count < br_lck->num_locks + 2) {
-                tp = (struct lock_struct *)SMB_REALLOC(tp, count * sizeof(*locks));
+                tp = talloc_realloc(br_lck, tp, struct lock_struct, count);
                 if (!tp) {
                         status = NT_STATUS_NO_MEMORY;
@@ -853 +952 @@
 
         br_lck->num_locks = count;
-        SAFE_FREE(br_lck->lock_data);
+        TALLOC_FREE(br_lck->lock_data);
         br_lck->lock_data = tp;
         locks = tp;
@@ -873 +972 @@
                         if (pend_lock->lock_type == PENDING_READ_LOCK &&
                                         brl_pending_overlap(plock, pend_lock)) {
-                                DEBUG(10,("brl_lock_posix: sending unlock message to pid %s\n",
-                                        procid_str_static(&pend_lock->context.pid )));
+                                struct server_id_buf tmp;
+
+                                DEBUG(10, ("brl_lock_posix: sending unlock "
+                                           "message to pid %s\n",
+                                           server_id_str_buf(pend_lock->context.pid,
+                                                             &tmp)));
 
                                 messaging_send(msg_ctx, pend_lock->context.pid,
@@ -894 +997 @@
                                        struct byte_range_lock *br_lck,
                                        struct lock_struct *plock,
-                                       bool blocking_lock,
-                                       struct blocking_lock_record *blr)
+                                       bool blocking_lock)
 {
         VFS_FIND(brl_lock_windows);
-        return handle->fns->brl_lock_windows(handle, br_lck, plock,
-                                             blocking_lock, blr);
+        return handle->fns->brl_lock_windows_fn(handle, br_lck, plock,
+                                                blocking_lock);
 }
 
@@ -911 +1013 @@
                 struct server_id pid,
                 br_off start,
-                br_off size, 
+                br_off size,
                 enum brl_type lock_type,
                 enum brl_flavour lock_flav,
                 bool blocking_lock,
-                uint64_t *psmblctx,
-                struct blocking_lock_record *blr)
+                uint64_t *psmblctx)
 {
         NTSTATUS ret;
         struct lock_struct lock;
+
+        ZERO_STRUCT(lock);
 
 #if !ZERO_ZERO
@@ -927 +1030 @@
 #endif
 
-#ifdef DEVELOPER
-        /* Quieten valgrind on test. */
-        memset(&lock, '\0', sizeof(lock));
-#endif
-
-        lock.context.smblctx = smblctx;
-        lock.context.pid = pid;
-        lock.context.tid = br_lck->fsp->conn->cnum;
-        lock.start = start;
-        lock.size = size;
-        lock.fnum = br_lck->fsp->fnum;
-        lock.lock_type = lock_type;
-        lock.lock_flav = lock_flav;
+        lock = (struct lock_struct) {
+                .context.smblctx = smblctx,
+                .context.pid = pid,
+                .context.tid = br_lck->fsp->conn->cnum,
+                .start = start,
+                .size = size,
+                .fnum = br_lck->fsp->fnum,
+                .lock_type = lock_type,
+                .lock_flav = lock_flav
+        };
 
         if (lock_flav == WINDOWS_LOCK) {
                 ret = SMB_VFS_BRL_LOCK_WINDOWS(br_lck->fsp->conn, br_lck,
-                    &lock, blocking_lock, blr);
+                                               &lock, blocking_lock);
         } else {
                 ret = brl_lock_posix(msg_ctx, br_lck, &lock);
@@ -958 +1058 @@
         }
         return ret;
+}
+
+static void brl_delete_lock_struct(struct lock_struct *locks,
+                                   unsigned num_locks,
+                                   unsigned del_idx)
+{
+        if (del_idx >= num_locks) {
+                return;
+        }
+        memmove(&locks[del_idx], &locks[del_idx+1],
+                sizeof(*locks) * (num_locks - del_idx - 1));
 }
 
@@ -1027 +1138 @@
 #endif
 
-        /* Actually delete the lock. */
-        if (i < br_lck->num_locks - 1) {
-                memmove(&locks[i], &locks[i+1], 
-                        sizeof(*locks)*((br_lck->num_locks-1) - i));
-        }
-
+        brl_delete_lock_struct(locks, br_lck->num_locks, i);
         br_lck->num_locks -= 1;
         br_lck->modified = True;
@@ -1058 +1164 @@
                 /* We could send specific lock info here... */
                 if (brl_pending_overlap(plock, pend_lock)) {
-                        DEBUG(10,("brl_unlock: sending unlock message to pid %s\n",
-                                procid_str_static(&pend_lock->context.pid )));
+                        struct server_id_buf tmp;
+
+                        DEBUG(10, ("brl_unlock: sending unlock message to "
+                                   "pid %s\n",
+                                   server_id_str_buf(pend_lock->context.pid,
+                                                     &tmp)));
 
                         messaging_send(msg_ctx, pend_lock->context.pid,
@@ -1099 +1209 @@
            1 more entry. */
 
-        tp = SMB_MALLOC_ARRAY(struct lock_struct, (br_lck->num_locks + 1));
+        tp = talloc_array(br_lck, struct lock_struct, br_lck->num_locks + 1);
         if (!tp) {
                 DEBUG(10,("brl_unlock_posix: malloc fail\n"));
@@ -1121 +1231 @@
                         /* Do any Windows flavour locks conflict ? */
                         if (brl_conflict(lock, plock)) {
-                                SAFE_FREE(tp);
+                                TALLOC_FREE(tp);
                                 return false;
                         }
@@ -1166 +1276 @@
         if (!overlap_found) {
                 /* Just ignore - no change. */
-                SAFE_FREE(tp);
+                TALLOC_FREE(tp);
                 DEBUG(10,("brl_unlock_posix: No overlap - unlocked.\n"));
                 return True;
@@ -1183 +1293 @@
         /* Realloc so we don't leak entries per unlock call. */
         if (count) {
-                tp = (struct lock_struct *)SMB_REALLOC(tp, count * sizeof(*locks));
+                tp = talloc_realloc(br_lck, tp, struct lock_struct, count);
                 if (!tp) {
                         DEBUG(10,("brl_unlock_posix: realloc fail\n"));
@@ -1190 +1300 @@
         } else {
                 /* We deleted the last lock. */
-                SAFE_FREE(tp);
+                TALLOC_FREE(tp);
                 tp = NULL;
         }
@@ -1198 +1308 @@
 
         br_lck->num_locks = count;
-        SAFE_FREE(br_lck->lock_data);
+        TALLOC_FREE(br_lck->lock_data);
         locks = tp;
         br_lck->lock_data = tp;
@@ -1215 +1325 @@
                 /* We could send specific lock info here... */
                 if (brl_pending_overlap(plock, pend_lock)) {
-                        DEBUG(10,("brl_unlock: sending unlock message to pid %s\n",
-                                procid_str_static(&pend_lock->context.pid )));
+                        struct server_id_buf tmp;
+
+                        DEBUG(10, ("brl_unlock: sending unlock message to "
+                                   "pid %s\n",
+                                   server_id_str_buf(pend_lock->context.pid,
+                                                     &tmp)));
 
                         messaging_send(msg_ctx, pend_lock->context.pid,
@@ -1232 +1346 @@
 {
         VFS_FIND(brl_unlock_windows);
-        return handle->fns->brl_unlock_windows(handle, msg_ctx, br_lck, plock);
+        return handle->fns->brl_unlock_windows_fn(handle, msg_ctx, br_lck,
+                                                  plock);
 }
 
@@ -1272 +1387 @@
 
 bool brl_locktest(struct byte_range_lock *br_lck,
-                uint64_t smblctx,
-                struct server_id pid,
-                br_off start,
-                br_off size, 
-                enum brl_type lock_type,
-                enum brl_flavour lock_flav)
+                  const struct lock_struct *rw_probe)
 {
         bool ret = True;
         unsigned int i;
-        struct lock_struct lock;
-        const struct lock_struct *locks = br_lck->lock_data;
+        struct lock_struct *locks = br_lck->lock_data;
         files_struct *fsp = br_lck->fsp;
-
-        lock.context.smblctx = smblctx;
-        lock.context.pid = pid;
-        lock.context.tid = br_lck->fsp->conn->cnum;
-        lock.start = start;
-        lock.size = size;
-        lock.fnum = fsp->fnum;
-        lock.lock_type = lock_type;
-        lock.lock_flav = lock_flav;
 
         /* Make sure existing locks don't conflict */
@@ -1299 +1399 @@
                  * Our own locks don't conflict.
                  */
-                if (brl_conflict_other(&locks[i], &lock)) {
+                if (brl_conflict_other(&locks[i], rw_probe)) {
+                        if (br_lck->record == NULL) {
+                                /* readonly */
+                                return false;
+                        }
+
+                        if (!serverid_exists(&locks[i].context.pid)) {
+                                locks[i].context.pid.pid = 0;
+                                br_lck->modified = true;
+                                continue;
+                        }
+
                         return False;
                 }
@@ -1310 +1421 @@
          */
 
-        if(lp_posix_locking(fsp->conn->params) && (lock_flav == WINDOWS_LOCK)) {
+        if(lp_posix_locking(fsp->conn->params) &&
+           (rw_probe->lock_flav == WINDOWS_LOCK)) {
+                /*
+                 * Make copies -- is_posix_locked might modify the values
+                 */
+
+                br_off start = rw_probe->start;
+                br_off size = rw_probe->size;
+                enum brl_type lock_type = rw_probe->lock_type;
+
                 ret = is_posix_locked(fsp, &start, &size, &lock_type, WINDOWS_LOCK);
 
-                DEBUG(10,("brl_locktest: posix start=%.0f len=%.0f %s for fnum %d file %s\n",
-                        (double)start, (double)size, ret ? "locked" : "unlocked",
-                        fsp->fnum, fsp_str_dbg(fsp)));
+                DEBUG(10, ("brl_locktest: posix start=%ju len=%ju %s for %s "
+                           "file %s\n", (uintmax_t)start, (uintmax_t)size,
+                           ret ? "locked" : "unlocked",
+                           fsp_fnum_dbg(fsp), fsp_str_dbg(fsp)));
 
                 /* We need to return the inverse of is_posix_locked. */
@@ -1333 +1454 @@
                 struct server_id pid,
                 br_off *pstart,
-                br_off *psize, 
+                br_off *psize,
                 enum brl_type *plock_type,
                 enum brl_flavour lock_flav)
@@ -1358 +1479 @@
                 if (exlock->lock_flav == WINDOWS_LOCK) {
                         conflict = brl_conflict(exlock, &lock);
-                } else {        
+                } else {
                         conflict = brl_conflict_posix(exlock, &lock);
                 }
@@ -1379 +1500 @@
                 bool ret = is_posix_locked(fsp, pstart, psize, plock_type, POSIX_LOCK);
 
-                DEBUG(10,("brl_lockquery: posix start=%.0f len=%.0f %s for fnum %d file %s\n",
-                        (double)*pstart, (double)*psize, ret ? "locked" : "unlocked",
-                        fsp->fnum, fsp_str_dbg(fsp)));
+                DEBUG(10, ("brl_lockquery: posix start=%ju len=%ju %s for %s "
+                           "file %s\n", (uintmax_t)*pstart,
+                           (uintmax_t)*psize, ret ? "locked" : "unlocked",
+                           fsp_fnum_dbg(fsp), fsp_str_dbg(fsp)));
 
                 if (ret) {
@@ -1396 +1518 @@
 bool smb_vfs_call_brl_cancel_windows(struct vfs_handle_struct *handle,
                                      struct byte_range_lock *br_lck,
-                                     struct lock_struct *plock,
-                                     struct blocking_lock_record *blr)
+                                     struct lock_struct *plock)
 {
         VFS_FIND(brl_cancel_windows);
-        return handle->fns->brl_cancel_windows(handle, br_lck, plock, blr);
+        return handle->fns->brl_cancel_windows_fn(handle, br_lck, plock);
 }
 
@@ -1411 +1532 @@
                 br_off start,
                 br_off size,
-                enum brl_flavour lock_flav,
-                struct blocking_lock_record *blr)
+                enum brl_flavour lock_flav)
 {
         bool ret;
@@ -1428 +1548 @@
         if (lock_flav == WINDOWS_LOCK) {
                 ret = SMB_VFS_BRL_CANCEL_WINDOWS(br_lck->fsp->conn, br_lck,
-                    &lock, blr);
+                                                 &lock);
         } else {
                 ret = brl_lock_cancel_default(br_lck, &lock);
@@ -1463 +1583 @@
         }
 
-        if (i < br_lck->num_locks - 1) {
-                /* Found this particular pending lock - delete it */
-                memmove(&locks[i], &locks[i+1], 
-                        sizeof(*locks)*((br_lck->num_locks-1) - i));
-        }
-
+        brl_delete_lock_struct(locks, br_lck->num_locks, i);
         br_lck->num_locks -= 1;
         br_lck->modified = True;
@@ -1484 +1599 @@
 {
         files_struct *fsp = br_lck->fsp;
-        uint16 tid = fsp->conn->cnum;
-        int fnum = fsp->fnum;
+        uint32_t tid = fsp->conn->cnum;
+        uint64_t fnum = fsp->fnum;
         unsigned int i;
         struct lock_struct *locks = br_lck->lock_data;
-        struct server_id pid = sconn_server_id(fsp->conn->sconn);
+        struct server_id pid = messaging_server_id(fsp->conn->sconn->msg_ctx);
         struct lock_struct *locks_copy;
         unsigned int num_locks_copy;
@@ -1494 +1609 @@
         /* Copy the current lock array. */
         if (br_lck->num_locks) {
-                locks_copy = (struct lock_struct *)TALLOC_MEMDUP(br_lck, locks, br_lck->num_locks * sizeof(struct lock_struct));
+                locks_copy = (struct lock_struct *)talloc_memdup(br_lck, locks, br_lck->num_locks * sizeof(struct lock_struct));
                 if (!locks_copy) {
                         smb_panic("brl_close_fnum: talloc failed");
@@ -1507 +1622 @@
                 struct lock_struct *lock = &locks_copy[i];
 
-                if (lock->context.tid == tid && procid_equal(&lock->context.pid, &pid) &&
+                if (lock->context.tid == tid && serverid_equal(&lock->context.pid, &pid) &&
                                 (lock->fnum == fnum)) {
                         brl_unlock(msg_ctx,
@@ -1520 +1635 @@
 }
 
-/****************************************************************************
- Ensure this set of lock entries is valid.
-****************************************************************************/
-static bool validate_lock_entries(unsigned int *pnum_entries, struct lock_struct **pplocks)
-{
+bool brl_mark_disconnected(struct files_struct *fsp)
+{
+        uint32_t tid = fsp->conn->cnum;
+        uint64_t smblctx;
+        uint64_t fnum = fsp->fnum;
         unsigned int i;
-        unsigned int num_valid_entries = 0;
-        struct lock_struct *locks = *pplocks;
-
-        for (i = 0; i < *pnum_entries; i++) {
-                struct lock_struct *lock_data = &locks[i];
-                if (!serverid_exists(&lock_data->context.pid)) {
-                        /* This process no longer exists - mark this
-                           entry as invalid by zeroing it. */
-                        ZERO_STRUCTP(lock_data);
-                } else {
-                        num_valid_entries++;
-                }
-        }
-
-        if (num_valid_entries != *pnum_entries) {
-                struct lock_struct *new_lock_data = NULL;
-
-                if (num_valid_entries) {
-                        new_lock_data = SMB_MALLOC_ARRAY(struct lock_struct, num_valid_entries);
-                        if (!new_lock_data) {
-                                DEBUG(3, ("malloc fail\n"));
-                                return False;
-                        }
-
-                        num_valid_entries = 0;
-                        for (i = 0; i < *pnum_entries; i++) {
-                                struct lock_struct *lock_data = &locks[i];
-                                if (lock_data->context.smblctx &&
-                                                lock_data->context.tid) {
-                                        /* Valid (nonzero) entry - copy it. */
-                                        memcpy(&new_lock_data[num_valid_entries],
-                                                lock_data, sizeof(struct lock_struct));
-                                        num_valid_entries++;
-                                }
-                        }
-                }
-
-                SAFE_FREE(*pplocks);
-                *pplocks = new_lock_data;
-                *pnum_entries = num_valid_entries;
-        }
-
-        return True;
+        struct server_id self = messaging_server_id(fsp->conn->sconn->msg_ctx);
+        struct byte_range_lock *br_lck = NULL;
+
+        if (fsp->op == NULL) {
+                return false;
+        }
+
+        smblctx = fsp->op->global->open_persistent_id;
+
+        if (!fsp->op->global->durable) {
+                return false;
+        }
+
+        if (fsp->current_lock_count == 0) {
+                return true;
+        }
+
+        br_lck = brl_get_locks(talloc_tos(), fsp);
+        if (br_lck == NULL) {
+                return false;
+        }
+
+        for (i=0; i < br_lck->num_locks; i++) {
+                struct lock_struct *lock = &br_lck->lock_data[i];
+
+                /*
+                 * as this is a durable handle, we only expect locks
+                 * of the current file handle!
+                 */
+
+                if (lock->context.smblctx != smblctx) {
+                        TALLOC_FREE(br_lck);
+                        return false;
+                }
+
+                if (lock->context.tid != tid) {
+                        TALLOC_FREE(br_lck);
+                        return false;
+                }
+
+                if (!serverid_equal(&lock->context.pid, &self)) {
+                        TALLOC_FREE(br_lck);
+                        return false;
+                }
+
+                if (lock->fnum != fnum) {
+                        TALLOC_FREE(br_lck);
+                        return false;
+                }
+
+                server_id_set_disconnected(&lock->context.pid);
+                lock->context.tid = TID_FIELD_INVALID;
+                lock->fnum = FNUM_FIELD_INVALID;
+        }
+
+        br_lck->modified = true;
+        TALLOC_FREE(br_lck);
+        return true;
+}
+
+bool brl_reconnect_disconnected(struct files_struct *fsp)
+{
+        uint32_t tid = fsp->conn->cnum;
+        uint64_t smblctx;
+        uint64_t fnum = fsp->fnum;
+        unsigned int i;
+        struct server_id self = messaging_server_id(fsp->conn->sconn->msg_ctx);
+        struct byte_range_lock *br_lck = NULL;
+
+        if (fsp->op == NULL) {
+                return false;
+        }
+
+        smblctx = fsp->op->global->open_persistent_id;
+
+        if (!fsp->op->global->durable) {
+                return false;
+        }
+
+        /*
+         * When reconnecting, we do not want to validate the brlock entries
+         * and thereby remove our own (disconnected) entries but reactivate
+         * them instead.
+         */
+
+        br_lck = brl_get_locks(talloc_tos(), fsp);
+        if (br_lck == NULL) {
+                return false;
+        }
+
+        if (br_lck->num_locks == 0) {
+                TALLOC_FREE(br_lck);
+                return true;
+        }
+
+        for (i=0; i < br_lck->num_locks; i++) {
+                struct lock_struct *lock = &br_lck->lock_data[i];
+
+                /*
+                 * as this is a durable handle we only expect locks
+                 * of the current file handle!
+                 */
+
+                if (lock->context.smblctx != smblctx) {
+                        TALLOC_FREE(br_lck);
+                        return false;
+                }
+
+                if (lock->context.tid != TID_FIELD_INVALID) {
+                        TALLOC_FREE(br_lck);
+                        return false;
+                }
+
+                if (!server_id_is_disconnected(&lock->context.pid)) {
+                        TALLOC_FREE(br_lck);
+                        return false;
+                }
+
+                if (lock->fnum != FNUM_FIELD_INVALID) {
+                        TALLOC_FREE(br_lck);
+                        return false;
+                }
+
+                lock->context.pid = self;
+                lock->context.tid = tid;
+                lock->fnum = fnum;
+        }
+
+        fsp->current_lock_count = br_lck->num_locks;
+        br_lck->modified = true;
+        TALLOC_FREE(br_lck);
+        return true;
 }
 
@@ -1585 +1789 @@
 ****************************************************************************/
 
-static int traverse_fn(struct db_record *rec, void *state)
+static int brl_traverse_fn(struct db_record *rec, void *state)
 {
         struct brl_forall_cb *cb = (struct brl_forall_cb *)state;
@@ -1592 +1796 @@
         unsigned int i;
         unsigned int num_locks = 0;
-        unsigned int orig_num_locks = 0;
+        TDB_DATA dbkey;
+        TDB_DATA value;
+
+        dbkey = dbwrap_record_get_key(rec);
+        value = dbwrap_record_get_value(rec);
 
         /* In a traverse function we must make a copy of
            dbuf before modifying it. */
 
-        locks = (struct lock_struct *)memdup(rec->value.dptr,
-                                             rec->value.dsize);
+        locks = (struct lock_struct *)talloc_memdup(
+                talloc_tos(), value.dptr, value.dsize);
         if (!locks) {
                 return -1; /* Terminate traversal. */
         }
 
-        key = (struct file_id *)rec->key.dptr;
-        orig_num_locks = num_locks = rec->value.dsize/sizeof(*locks);
-
-        /* Ensure the lock db is clean of entries from invalid processes. */
-
-        if (!validate_lock_entries(&num_locks, &locks)) {
-                SAFE_FREE(locks);
-                return -1; /* Terminate traversal */
-        }
-
-        if (orig_num_locks != num_locks) {
-                if (num_locks) {
-                        TDB_DATA data;
-                        data.dptr = (uint8_t *)locks;
-                        data.dsize = num_locks*sizeof(struct lock_struct);
-                        rec->store(rec, data, TDB_REPLACE);
-                } else {
-                        rec->delete_rec(rec);
-                }
-        }
+        key = (struct file_id *)dbkey.dptr;
+        num_locks = value.dsize/sizeof(*locks);
 
         if (cb->fn) {
@@ -1636 +1826 @@
         }
 
-        SAFE_FREE(locks);
+        TALLOC_FREE(locks);
         return 0;
 }
@@ -1652 +1842 @@
 {
         struct brl_forall_cb cb;
+        NTSTATUS status;
+        int count = 0;
 
         if (!brlock_db) {
@@ -1658 +1850 @@
         cb.fn = fn;
         cb.private_data = private_data;
-        return brlock_db->traverse(brlock_db, traverse_fn, &cb);
+        status = dbwrap_traverse(brlock_db, brl_traverse_fn, &cb, &count);
+
+        if (!NT_STATUS_IS_OK(status)) {
+                return -1;
+        } else {
+                return count;
+        }
 }
 
@@ -1669 +1867 @@
 static void byte_range_lock_flush(struct byte_range_lock *br_lck)
 {
-        if (br_lck->read_only) {
-                SMB_ASSERT(!br_lck->modified);
-        }
+        unsigned i;
+        struct lock_struct *locks = br_lck->lock_data;
 
         if (!br_lck->modified) {
+                DEBUG(10, ("br_lck not modified\n"));
                 goto done;
         }
 
-        if (br_lck->num_locks == 0) {
+        i = 0;
+
+        while (i < br_lck->num_locks) {
+                if (locks[i].context.pid.pid == 0) {
+                        /*
+                         * Autocleanup, the process conflicted and does not
+                         * exist anymore.
+                         */
+                        locks[i] = locks[br_lck->num_locks-1];
+                        br_lck->num_locks -= 1;
+                } else {
+                        i += 1;
+                }
+        }
+
+        if ((br_lck->num_locks == 0) && (br_lck->num_read_oplocks == 0)) {
                 /* No locks - delete this entry. */
-                NTSTATUS status = br_lck->record->delete_rec(br_lck->record);
+                NTSTATUS status = dbwrap_record_delete(br_lck->record);
                 if (!NT_STATUS_IS_OK(status)) {
                         DEBUG(0, ("delete_rec returned %s\n",
@@ -1686 +1899 @@
                 }
         } else {
+                size_t lock_len, data_len;
                 TDB_DATA data;
                 NTSTATUS status;
 
-                data.dptr = (uint8 *)br_lck->lock_data;
-                data.dsize = br_lck->num_locks * sizeof(struct lock_struct);
-
-                status = br_lck->record->store(br_lck->record, data,
-                                               TDB_REPLACE);
+                lock_len = br_lck->num_locks * sizeof(struct lock_struct);
+                data_len = lock_len + sizeof(br_lck->num_read_oplocks);
+
+                data.dsize = data_len;
+                data.dptr = talloc_array(talloc_tos(), uint8_t, data_len);
+                SMB_ASSERT(data.dptr != NULL);
+
+                memcpy(data.dptr, br_lck->lock_data, lock_len);
+                memcpy(data.dptr + lock_len, &br_lck->num_read_oplocks,
+                       sizeof(br_lck->num_read_oplocks));
+
+                status = dbwrap_record_store(br_lck->record, data, TDB_REPLACE);
+                TALLOC_FREE(data.dptr);
                 if (!NT_STATUS_IS_OK(status)) {
                         DEBUG(0, ("store returned %s\n", nt_errstr(status)));
@@ -1700 +1922 @@
         }
 
+        DEBUG(10, ("seqnum=%d\n", dbwrap_get_seqnum(brlock_db)));
+
  done:
-
-        br_lck->read_only = true;
         br_lck->modified = false;
-
         TALLOC_FREE(br_lck->record);
 }
@@ -1711 +1932 @@
 {
         byte_range_lock_flush(br_lck);
-        SAFE_FREE(br_lck->lock_data);
         return 0;
+}
+
+static bool brl_parse_data(struct byte_range_lock *br_lck, TDB_DATA data)
+{
+        size_t data_len;
+
+        if (data.dsize == 0) {
+                return true;
+        }
+        if (data.dsize % sizeof(struct lock_struct) !=
+            sizeof(br_lck->num_read_oplocks)) {
+                DEBUG(1, ("Invalid data size: %u\n", (unsigned)data.dsize));
+                return false;
+        }
+
+        br_lck->num_locks = data.dsize / sizeof(struct lock_struct);
+        data_len = br_lck->num_locks * sizeof(struct lock_struct);
+
+        br_lck->lock_data = talloc_memdup(br_lck, data.dptr, data_len);
+        if (br_lck->lock_data == NULL) {
+                DEBUG(1, ("talloc_memdup failed\n"));
+                return false;
+        }
+        memcpy(&br_lck->num_read_oplocks, data.dptr + data_len,
+               sizeof(br_lck->num_read_oplocks));
+        return true;
 }
 
@@ -1721 +1967 @@
 ********************************************************************/
 
-static struct byte_range_lock *brl_get_locks_internal(TALLOC_CTX *mem_ctx,
-                                        files_struct *fsp, bool read_only)
+struct byte_range_lock *brl_get_locks(TALLOC_CTX *mem_ctx, files_struct *fsp)
 {
         TDB_DATA key, data;
-        struct byte_range_lock *br_lck = TALLOC_P(mem_ctx, struct byte_range_lock);
-        bool do_read_only = read_only;
-
+        struct byte_range_lock *br_lck;
+
+        br_lck = talloc_zero(mem_ctx, struct byte_range_lock);
         if (br_lck == NULL) {
                 return NULL;
@@ -1733 +1978 @@
 
         br_lck->fsp = fsp;
-        br_lck->num_locks = 0;
-        br_lck->modified = False;
-        br_lck->key = fsp->file_id;
-
-        key.dptr = (uint8 *)&br_lck->key;
+
+        key.dptr = (uint8_t *)&fsp->file_id;
         key.dsize = sizeof(struct file_id);
 
-        if (!fsp->lockdb_clean) {
-                /* We must be read/write to clean
-                   the dead entries. */
-                do_read_only = false;
-        }
-
-        if (do_read_only) {
-                if (brlock_db->fetch(brlock_db, br_lck, key, &data) == -1) {
-                        DEBUG(3, ("Could not fetch byte range lock record\n"));
-                        TALLOC_FREE(br_lck);
-                        return NULL;
-                }
-                br_lck->record = NULL;
-        } else {
-                br_lck->record = brlock_db->fetch_locked(brlock_db, br_lck, key);
-
-                if (br_lck->record == NULL) {
-                        DEBUG(3, ("Could not lock byte range lock entry\n"));
-                        TALLOC_FREE(br_lck);
-                        return NULL;
-                }
-
-                data = br_lck->record->value;
-        }
-
-        br_lck->read_only = do_read_only;
-        br_lck->lock_data = NULL;
+        br_lck->record = dbwrap_fetch_locked(brlock_db, br_lck, key);
+
+        if (br_lck->record == NULL) {
+                DEBUG(3, ("Could not lock byte range lock entry\n"));
+                TALLOC_FREE(br_lck);
+                return NULL;
+        }
+
+        data = dbwrap_record_get_value(br_lck->record);
+
+        if (!brl_parse_data(br_lck, data)) {
+                TALLOC_FREE(br_lck);
+                return NULL;
+        }
 
         talloc_set_destructor(br_lck, byte_range_lock_destructor);
-
-        br_lck->num_locks = data.dsize / sizeof(struct lock_struct);
-
-        if (br_lck->num_locks != 0) {
-                br_lck->lock_data = SMB_MALLOC_ARRAY(struct lock_struct,
-                                                     br_lck->num_locks);
-                if (br_lck->lock_data == NULL) {
-                        DEBUG(0, ("malloc failed\n"));
-                        TALLOC_FREE(br_lck);
-                        return NULL;
-                }
-
-                memcpy(br_lck->lock_data, data.dptr, data.dsize);
-        }
-        
-        if (!fsp->lockdb_clean) {
-                int orig_num_locks = br_lck->num_locks;
-
-                /* This is the first time we've accessed this. */
-                /* Go through and ensure all entries exist - remove any that don't. */
-                /* Makes the lockdb self cleaning at low cost. */
-
-                if (!validate_lock_entries(&br_lck->num_locks,
-                                           &br_lck->lock_data)) {
-                        SAFE_FREE(br_lck->lock_data);
-                        TALLOC_FREE(br_lck);
-                        return NULL;
-                }
-
-                /* Ensure invalid locks are cleaned up in the destructor. */
-                if (orig_num_locks != br_lck->num_locks) {
-                        br_lck->modified = True;
-                }
-
-                /* Mark the lockdb as "clean" as seen from this open file. */
-                fsp->lockdb_clean = True;
-        }
 
         if (DEBUGLEVEL >= 10) {
@@ -1818 +2010 @@
         }
 
-        if (do_read_only != read_only) {
+        return br_lck;
+}
+
+struct brl_get_locks_readonly_state {
+        TALLOC_CTX *mem_ctx;
+        struct byte_range_lock **br_lock;
+};
+
+static void brl_get_locks_readonly_parser(TDB_DATA key, TDB_DATA data,
+                                          void *private_data)
+{
+        struct brl_get_locks_readonly_state *state =
+                (struct brl_get_locks_readonly_state *)private_data;
+        struct byte_range_lock *br_lck;
+
+        br_lck = talloc_pooled_object(
+                state->mem_ctx, struct byte_range_lock, 1, data.dsize);
+        if (br_lck == NULL) {
+                *state->br_lock = NULL;
+                return;
+        }
+        *br_lck = (struct byte_range_lock) { 0 };
+        if (!brl_parse_data(br_lck, data)) {
+                *state->br_lock = NULL;
+                return;
+        }
+        *state->br_lock = br_lck;
+}
+
+struct byte_range_lock *brl_get_locks_readonly(files_struct *fsp)
+{
+        struct byte_range_lock *br_lock = NULL;
+        struct brl_get_locks_readonly_state state;
+        NTSTATUS status;
+
+        DEBUG(10, ("seqnum=%d, fsp->brlock_seqnum=%d\n",
+                   dbwrap_get_seqnum(brlock_db), fsp->brlock_seqnum));
+
+        if ((fsp->brlock_rec != NULL)
+            && (dbwrap_get_seqnum(brlock_db) == fsp->brlock_seqnum)) {
                 /*
-                 * this stores the record and gets rid of
-                 * the write lock that is needed for a cleanup
+                 * We have cached the brlock_rec and the database did not
+                 * change.
                  */
-                byte_range_lock_flush(br_lck);
-        }
-
-        return br_lck;
-}
-
-struct byte_range_lock *brl_get_locks(TALLOC_CTX *mem_ctx,
-                                        files_struct *fsp)
-{
-        return brl_get_locks_internal(mem_ctx, fsp, False);
-}
-
-struct byte_range_lock *brl_get_locks_readonly(files_struct *fsp)
-{
-        struct byte_range_lock *br_lock;
-
-        if (lp_clustering()) {
-                return brl_get_locks_internal(talloc_tos(), fsp, true);
-        }
-
-        if ((fsp->brlock_rec != NULL)
-            && (brlock_db->get_seqnum(brlock_db) == fsp->brlock_seqnum)) {
                 return fsp->brlock_rec;
         }
 
-        TALLOC_FREE(fsp->brlock_rec);
-
-        br_lock = brl_get_locks_internal(talloc_tos(), fsp, true);
+        /*
+         * Parse the record fresh from the database
+         */
+
+        state.mem_ctx = fsp;
+        state.br_lock = &br_lock;
+
+        status = dbwrap_parse_record(
+                brlock_db,
+                make_tdb_data((uint8_t *)&fsp->file_id,
+                              sizeof(fsp->file_id)),
+                brl_get_locks_readonly_parser, &state);
+
+        if (NT_STATUS_EQUAL(status,NT_STATUS_NOT_FOUND)) {
+                /*
+                 * No locks on this file. Return an empty br_lock.
+                 */
+                br_lock = talloc(fsp, struct byte_range_lock);
+                if (br_lock == NULL) {
+                        return NULL;
+                }
+
+                br_lock->num_read_oplocks = 0;
+                br_lock->num_locks = 0;
+                br_lock->lock_data = NULL;
+
+        } else if (!NT_STATUS_IS_OK(status)) {
+                DEBUG(3, ("Could not parse byte range lock record: "
+                          "%s\n", nt_errstr(status)));
+                return NULL;
+        }
         if (br_lock == NULL) {
                 return NULL;
         }
-        fsp->brlock_seqnum = brlock_db->get_seqnum(brlock_db);
-
-        fsp->brlock_rec = talloc_move(fsp, &br_lock);
-
-        return fsp->brlock_rec;
+
+        br_lock->fsp = fsp;
+        br_lock->modified = false;
+        br_lock->record = NULL;
+
+        if (lp_clustering()) {
+                /*
+                 * In the cluster case we can't cache the brlock struct
+                 * because dbwrap_get_seqnum does not work reliably over
+                 * ctdb. Thus we have to throw away the brlock struct soon.
+                 */
+                talloc_steal(talloc_tos(), br_lock);
+        } else {
+                /*
+                 * Cache the brlock struct, invalidated when the dbwrap_seqnum
+                 * changes. See beginning of this routine.
+                 */
+                TALLOC_FREE(fsp->brlock_rec);
+                fsp->brlock_rec = br_lock;
+                fsp->brlock_seqnum = dbwrap_get_seqnum(brlock_db);
+        }
+
+        return br_lock;
 }
 
 struct brl_revalidate_state {
         ssize_t array_size;
-        uint32 num_pids;
+        uint32_t num_pids;
         struct server_id *pids;
 };
@@ -1895 +2150 @@
 static int compare_procids(const void *p1, const void *p2)
 {
-        const struct server_id *i1 = (struct server_id *)p1;
-        const struct server_id *i2 = (struct server_id *)p2;
+        const struct server_id *i1 = (const struct server_id *)p1;
+        const struct server_id *i2 = (const struct server_id *)p2;
 
         if (i1->pid < i2->pid) return -1;
-        if (i2->pid > i2->pid) return 1;
+        if (i1->pid > i2->pid) return 1;
         return 0;
 }
@@ -1912 +2167 @@
  */
 
-static void brl_revalidate(struct messaging_context *msg_ctx,
-                           void *private_data,
-                           uint32_t msg_type,
-                           struct server_id server_id,
-                           DATA_BLOB *data)
+void brl_revalidate(struct messaging_context *msg_ctx,
+                    void *private_data,
+                    uint32_t msg_type,
+                    struct server_id server_id,
+                    DATA_BLOB *data)
 {
         struct brl_revalidate_state *state;
-        uint32 i;
+        uint32_t i;
         struct server_id last_pid;
 
-        if (!(state = TALLOC_ZERO_P(NULL, struct brl_revalidate_state))) {
+        if (!(state = talloc_zero(NULL, struct brl_revalidate_state))) {
                 DEBUG(0, ("talloc failed\n"));
                 return;
@@ -1943 +2198 @@
 
         for (i=0; i<state->num_pids; i++) {
-                if (procid_equal(&last_pid, &state->pids[i])) {
+                if (serverid_equal(&last_pid, &state->pids[i])) {
                         /*
                          * We've seen that one already
@@ -1960 +2215 @@
 }
 
-void brl_register_msgs(struct messaging_context *msg_ctx)
-{
-        messaging_register(msg_ctx, NULL, MSG_SMB_BRL_VALIDATE,
-                           brl_revalidate);
-}
+bool brl_cleanup_disconnected(struct file_id fid, uint64_t open_persistent_id)
+{
+        bool ret = false;
+        TALLOC_CTX *frame = talloc_stackframe();
+        TDB_DATA key, val;
+        struct db_record *rec;
+        struct lock_struct *lock;
+        unsigned n, num;
+        NTSTATUS status;
+
+        key = make_tdb_data((void*)&fid, sizeof(fid));
+
+        rec = dbwrap_fetch_locked(brlock_db, frame, key);
+        if (rec == NULL) {
+                DEBUG(5, ("brl_cleanup_disconnected: failed to fetch record "
+                          "for file %s\n", file_id_string(frame, &fid)));
+                goto done;
+        }
+
+        val = dbwrap_record_get_value(rec);
+        lock = (struct lock_struct*)val.dptr;
+        num = val.dsize / sizeof(struct lock_struct);
+        if (lock == NULL) {
+                DEBUG(10, ("brl_cleanup_disconnected: no byte range locks for "
+                           "file %s\n", file_id_string(frame, &fid)));
+                ret = true;
+                goto done;
+        }
+
+        for (n=0; n<num; n++) {
+                struct lock_context *ctx = &lock[n].context;
+
+                if (!server_id_is_disconnected(&ctx->pid)) {
+                        struct server_id_buf tmp;
+                        DEBUG(5, ("brl_cleanup_disconnected: byte range lock "
+                                  "%s used by server %s, do not cleanup\n",
+                                  file_id_string(frame, &fid),
+                                  server_id_str_buf(ctx->pid, &tmp)));
+                        goto done;
+                }
+
+                if (ctx->smblctx != open_persistent_id) {
+                        DEBUG(5, ("brl_cleanup_disconnected: byte range lock "
+                                  "%s expected smblctx %llu but found %llu"
+                                  ", do not cleanup\n",
+                                  file_id_string(frame, &fid),
+                                  (unsigned long long)open_persistent_id,
+                                  (unsigned long long)ctx->smblctx));
+                        goto done;
+                }
+        }
+
+        status = dbwrap_record_delete(rec);
+        if (!NT_STATUS_IS_OK(status)) {
+                DEBUG(5, ("brl_cleanup_disconnected: failed to delete record "
+                          "for file %s from %s, open %llu: %s\n",
+                          file_id_string(frame, &fid), dbwrap_name(brlock_db),
+                          (unsigned long long)open_persistent_id,
+                          nt_errstr(status)));
+                goto done;
+        }
+
+        DEBUG(10, ("brl_cleanup_disconnected: "
+                   "file %s cleaned up %u entries from open %llu\n",
+                   file_id_string(frame, &fid), num,
+                   (unsigned long long)open_persistent_id));
+
+        ret = true;
+done:
+        talloc_free(frame);
+        return ret;
+}

vendor/current/source3/locking/locking.c

@@ -5 +5 @@
    Copyright (C) Jeremy Allison 1992-2006
    Copyright (C) Volker Lendecke 2005
-   
+
    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 3 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, see <http://www.gnu.org/licenses/>.
@@ -30 +30 @@
    support.
 
-   rewrtten completely to use new tdb code. Tridge, Dec '99
+   rewritten completely to use new tdb code. Tridge, Dec '99
 
    Added POSIX locking support. Jeremy Allison (jeremy@valinux.com), Apr. 2000.
@@ -40 +40 @@
 #include "locking/proto.h"
 #include "smbd/globals.h"
-#include "dbwrap.h"
+#include "dbwrap/dbwrap.h"
+#include "dbwrap/dbwrap_open.h"
 #include "../libcli/security/security.h"
 #include "serverid.h"
 #include "messages.h"
 #include "util_tdb.h"
-#include "../librpc/gen_ndr/ndr_security.h"
+#include "../librpc/gen_ndr/ndr_open_files.h"
+#include "librpc/gen_ndr/ndr_file_id.h"
+#include "locking/leases_db.h"
 
 #undef DBGC_CLASS
@@ -51 +54 @@
 
 #define NO_LOCKING_COUNT (-1)
-
-/* the locking database handle */
-static struct db_context *lock_db;
 
 /****************************************************************************
@@ -96 +96 @@
         plock->context.smblctx = smblctx;
         plock->context.tid = fsp->conn->cnum;
-        plock->context.pid = sconn_server_id(fsp->conn->sconn);
+        plock->context.pid = messaging_server_id(fsp->conn->sconn->msg_ctx);
         plock->start = start;
         plock->size = size;
@@ -106 +106 @@
 bool strict_lock_default(files_struct *fsp, struct lock_struct *plock)
 {
+        struct byte_range_lock *br_lck;
         int strict_locking = lp_strict_locking(fsp->conn->params);
         bool ret = False;
@@ -118 +119 @@
 
         if (strict_locking == Auto) {
-                if  (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type) && (plock->lock_type == READ_LOCK || plock->lock_type == WRITE_LOCK)) {
-                        DEBUG(10,("is_locked: optimisation - exclusive oplock on file %s\n", fsp_str_dbg(fsp)));
-                        ret = True;
-                } else if ((fsp->oplock_type == LEVEL_II_OPLOCK) &&
-                           (plock->lock_type == READ_LOCK)) {
-                        DEBUG(10,("is_locked: optimisation - level II oplock on file %s\n", fsp_str_dbg(fsp)));
-                        ret = True;
-                } else {
-                        struct byte_range_lock *br_lck;
-
-                        br_lck = brl_get_locks_readonly(fsp);
-                        if (!br_lck) {
-                                return True;
-                        }
-                        ret = brl_locktest(br_lck,
-                                        plock->context.smblctx,
-                                        plock->context.pid,
-                                        plock->start,
-                                        plock->size,
-                                        plock->lock_type,
-                                        plock->lock_flav);
-                }
-        } else {
-                struct byte_range_lock *br_lck;
-
-                br_lck = brl_get_locks_readonly(fsp);
-                if (!br_lck) {
-                        return True;
-                }
-                ret = brl_locktest(br_lck,
-                                plock->context.smblctx,
-                                plock->context.pid,
-                                plock->start,
-                                plock->size,
-                                plock->lock_type,
-                                plock->lock_flav);
-        }
-
-        DEBUG(10,("strict_lock_default: flavour = %s brl start=%.0f "
-                        "len=%.0f %s for fnum %d file %s\n",
-                        lock_flav_name(plock->lock_flav),
-                        (double)plock->start, (double)plock->size,
-                        ret ? "unlocked" : "locked",
-                        plock->fnum, fsp_str_dbg(fsp)));
+                if  (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type) &&
+                     (plock->lock_type == READ_LOCK ||
+                      plock->lock_type == WRITE_LOCK)) {
+                        DEBUG(10, ("is_locked: optimisation - exclusive oplock "
+                                   "on file %s\n", fsp_str_dbg(fsp)));
+                        return true;
+                }
+                if ((fsp->oplock_type == LEVEL_II_OPLOCK) &&
+                    (plock->lock_type == READ_LOCK)) {
+                        DEBUG(10, ("is_locked: optimisation - level II oplock "
+                                   "on file %s\n", fsp_str_dbg(fsp)));
+                        return true;
+                }
+        }
+
+        br_lck = brl_get_locks_readonly(fsp);
+        if (!br_lck) {
+                return true;
+        }
+        ret = brl_locktest(br_lck, plock);
+
+        if (!ret) {
+                /*
+                 * We got a lock conflict. Retry with rw locks to enable
+                 * autocleanup. This is the slow path anyway.
+                 */
+                br_lck = brl_get_locks(talloc_tos(), fsp);
+                ret = brl_locktest(br_lck, plock);
+                TALLOC_FREE(br_lck);
+        }
+
+        DEBUG(10, ("strict_lock_default: flavour = %s brl start=%ju "
+                   "len=%ju %s for fnum %ju file %s\n",
+                   lock_flav_name(plock->lock_flav),
+                   (uintmax_t)plock->start, (uintmax_t)plock->size,
+                   ret ? "unlocked" : "locked",
+                   (uintmax_t)plock->fnum, fsp_str_dbg(fsp)));
 
         return ret;
@@ -198 +192 @@
         return brl_lockquery(br_lck,
                         psmblctx,
-                        sconn_server_id(fsp->conn->sconn),
+                        messaging_server_id(fsp->conn->sconn->msg_ctx),
                         poffset,
                         pcount,
@@ -246 +240 @@
                         bool blocking_lock,
                         NTSTATUS *perr,
-                        uint64_t *psmblctx,
-                        struct blocking_lock_record *blr)
+                        uint64_t *psmblctx)
 {
         struct byte_range_lock *br_lck = NULL;
@@ -269 +262 @@
         /* NOTE! 0 byte long ranges ARE allowed and should be stored  */
 
-        DEBUG(10,("do_lock: lock flavour %s lock type %s start=%.0f len=%.0f "
-                "blocking_lock=%s requested for fnum %d file %s\n",
+        DEBUG(10,("do_lock: lock flavour %s lock type %s start=%ju len=%ju "
+                "blocking_lock=%s requested for %s file %s\n",
                 lock_flav_name(lock_flav), lock_type_name(lock_type),
-                (double)offset, (double)count, blocking_lock ? "true" :
-                "false", fsp->fnum, fsp_str_dbg(fsp)));
+                (uintmax_t)offset, (uintmax_t)count, blocking_lock ? "true" :
+                "false", fsp_fnum_dbg(fsp), fsp_str_dbg(fsp)));
 
         br_lck = brl_get_locks(talloc_tos(), fsp);
@@ -284 +277 @@
                         br_lck,
                         smblctx,
-                        sconn_server_id(fsp->conn->sconn),
+                        messaging_server_id(fsp->conn->sconn->msg_ctx),
                         offset,
                         count,
@@ -290 +283 @@
                         lock_flav,
                         blocking_lock,
-                        psmblctx,
-                        blr);
+                        psmblctx);
 
         DEBUG(10, ("do_lock: returning status=%s\n", nt_errstr(*perr)));
@@ -312 +304 @@
         bool ok = False;
         struct byte_range_lock *br_lck = NULL;
-        
+
         if (!fsp->can_lock) {
                 return fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
         }
-        
+
         if (!lp_locking(fsp->conn->params)) {
                 return NT_STATUS_OK;
         }
-        
-        DEBUG(10,("do_unlock: unlock start=%.0f len=%.0f requested for fnum %d file %s\n",
-                  (double)offset, (double)count, fsp->fnum,
-                  fsp_str_dbg(fsp)));
+
+        DEBUG(10, ("do_unlock: unlock start=%ju len=%ju requested for %s file "
+                   "%s\n", (uintmax_t)offset, (uintmax_t)count,
+                   fsp_fnum_dbg(fsp), fsp_str_dbg(fsp)));
 
         br_lck = brl_get_locks(talloc_tos(), fsp);
@@ -333 +325 @@
                         br_lck,
                         smblctx,
-                        sconn_server_id(fsp->conn->sconn),
+                        messaging_server_id(fsp->conn->sconn->msg_ctx),
                         offset,
                         count,
                         lock_flav);
-   
+
         TALLOC_FREE(br_lck);
 
@@ -354 +346 @@
 
 NTSTATUS do_lock_cancel(files_struct *fsp,
-                        uint64 smblctx,
+                        uint64_t smblctx,
                         uint64_t count,
                         uint64_t offset,
-                        enum brl_flavour lock_flav,
-                        struct blocking_lock_record *blr)
+                        enum brl_flavour lock_flav)
 {
         bool ok = False;
@@ -367 +358 @@
                         NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
         }
-        
+
         if (!lp_locking(fsp->conn->params)) {
                 return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
         }
 
-        DEBUG(10,("do_lock_cancel: cancel start=%.0f len=%.0f requested for fnum %d file %s\n",
-                  (double)offset, (double)count, fsp->fnum,
-                  fsp_str_dbg(fsp)));
+        DEBUG(10, ("do_lock_cancel: cancel start=%ju len=%ju requested for "
+                   "%s file %s\n", (uintmax_t)offset, (uintmax_t)count,
+                   fsp_fnum_dbg(fsp), fsp_str_dbg(fsp)));
 
         br_lck = brl_get_locks(talloc_tos(), fsp);
@@ -383 +374 @@
         ok = brl_lock_cancel(br_lck,
                         smblctx,
-                        sconn_server_id(fsp->conn->sconn),
+                        messaging_server_id(fsp->conn->sconn->msg_ctx),
                         offset,
                         count,
-                        lock_flav,
-                        blr);
+                        lock_flav);
 
         TALLOC_FREE(br_lck);
@@ -414 +404 @@
         }
 
-        /* If we have not outstanding locks or pending
+        /* If we have no outstanding locks or pending
          * locks then we don't need to look in the lock db.
          */
@@ -431 +421 @@
 }
 
-/****************************************************************************
- Initialise the locking functions.
-****************************************************************************/
-
-static bool locking_init_internal(bool read_only)
-{
-        brl_init(read_only);
-
-        if (lock_db)
-                return True;
-
-        lock_db = db_open(NULL, lock_path("locking.tdb"),
-                          lp_open_files_db_hash_size(),
-                          TDB_DEFAULT|TDB_VOLATILE|TDB_CLEAR_IF_FIRST|TDB_INCOMPATIBLE_HASH,
-                          read_only?O_RDONLY:O_RDWR|O_CREAT, 0644);
-
-        if (!lock_db) {
-                DEBUG(0,("ERROR: Failed to initialise locking database\n"));
-                return False;
-        }
-
-        if (!posix_locking_init(read_only))
-                return False;
-
-        return True;
-}
-
-bool locking_init(void)
-{
-        return locking_init_internal(false);
-}
-
-bool locking_init_readonly(void)
-{
-        return locking_init_internal(true);
-}
-
-/*******************************************************************
- Deinitialize the share_mode management.
-******************************************************************/
-
-bool locking_end(void)
-{
-        brl_shutdown();
-        TALLOC_FREE(lock_db);
-        return true;
-}
-
-/*******************************************************************
- Form a static locking key for a dev/inode pair.
-******************************************************************/
-
-static TDB_DATA locking_key(const struct file_id *id, struct file_id *tmp)
-{
-        *tmp = *id;
-        return make_tdb_data((const uint8_t *)tmp, sizeof(*tmp));
-}
-
 /*******************************************************************
  Print out a share mode.
@@ -495 +427 @@
 char *share_mode_str(TALLOC_CTX *ctx, int num, const struct share_mode_entry *e)
 {
-        return talloc_asprintf(ctx, "share_mode_entry[%d]: %s "
+        struct server_id_buf tmp;
+
+        return talloc_asprintf(ctx, "share_mode_entry[%d]: "
                  "pid = %s, share_access = 0x%x, private_options = 0x%x, "
-                 "access_mask = 0x%x, mid = 0x%llx, type= 0x%x, gen_id = %lu, "
+                 "access_mask = 0x%x, mid = 0x%llx, type= 0x%x, gen_id = %llu, "
                  "uid = %u, flags = %u, file_id %s, name_hash = 0x%x",
                  num,
-                 e->op_type == UNUSED_SHARE_MODE_ENTRY ? "UNUSED" : "",
-                 procid_str_static(&e->pid),
+                 server_id_str_buf(e->pid, &tmp),
                  e->share_access, e->private_options,
                  e->access_mask, (unsigned long long)e->op_mid,
-                 e->op_type, e->share_file_id,
+                 e->op_type, (unsigned long long)e->share_file_id,
                  (unsigned int)e->uid, (unsigned int)e->flags,
                  file_id_string_tos(&e->id),
@@ -511 +444 @@
 
 /*******************************************************************
- Print out a share mode table.
+ Fetch a share mode where we know one MUST exist. This call reference
+ counts it internally to allow for nested lock fetches.
 ********************************************************************/
 
-static void print_share_mode_table(struct locking_data *data)
-{
-        int num_share_modes = data->u.s.num_share_mode_entries;
-        struct share_mode_entry *shares =
-                (struct share_mode_entry *)(data + 1);
-        int i;
-
-        for (i = 0; i < num_share_modes; i++) {
-                struct share_mode_entry entry;
-                char *str;
-
-                /*
-                 * We need to memcpy the entry here due to alignment
-                 * restrictions that are not met when directly accessing
-                 * shares[i]
-                 */
-
-                memcpy(&entry, &shares[i], sizeof(struct share_mode_entry));
-                str = share_mode_str(talloc_tos(), i, &entry);
-
-                DEBUG(10,("print_share_mode_table: %s\n", str ? str : ""));
-                TALLOC_FREE(str);
-        }
-}
-
-static int parse_delete_tokens_list(struct share_mode_lock *lck,
-                struct locking_data *pdata,
-                const TDB_DATA dbuf)
-{
-        uint8_t *p = dbuf.dptr + sizeof(struct locking_data) +
-                        (lck->num_share_modes *
-                        sizeof(struct share_mode_entry));
-        uint8_t *end_ptr = dbuf.dptr + (dbuf.dsize - 2);
-        int delete_tokens_size = 0;
-        int i;
-
-        lck->delete_tokens = NULL;
-
-        for (i = 0; i < pdata->u.s.num_delete_token_entries; i++) {
-                DATA_BLOB blob;
-                enum ndr_err_code ndr_err;
-                struct delete_token_list *pdtl;
-                size_t token_len = 0;
-
-                pdtl = TALLOC_ZERO_P(lck, struct delete_token_list);
-                if (pdtl == NULL) {
-                        DEBUG(0,("parse_delete_tokens_list: talloc failed"));
-                        return -1;
-                }
-                /* Copy out the name_hash. */
-                memcpy(&pdtl->name_hash, p, sizeof(pdtl->name_hash));
-                p += sizeof(pdtl->name_hash);
-                delete_tokens_size += sizeof(pdtl->name_hash);
-
-                pdtl->delete_token = TALLOC_ZERO_P(pdtl, struct security_unix_token);
-                if (pdtl->delete_token == NULL) {
-                        DEBUG(0,("parse_delete_tokens_list: talloc failed"));
-                        return -1;
-                }
-
-                if (p >= end_ptr) {
-                        DEBUG(0,("parse_delete_tokens_list: corrupt data"));
-                        return -1;
-                }
-
-                blob.data = p;
-                blob.length = end_ptr - p;
-
-                ndr_err = ndr_pull_struct_blob(&blob,
-                                pdtl,
-                                pdtl->delete_token,
-                                (ndr_pull_flags_fn_t)ndr_pull_security_unix_token);
-                if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
-                        DEBUG(1, ("parse_delete_tokens_list: "
-                                "ndr_pull_security_unix_token failed\n"));
-                        return -1;
-                }
-
-                token_len = ndr_size_security_unix_token(pdtl->delete_token, 0);
-
-                p += token_len;
-                delete_tokens_size += token_len;
-
-                if (p >= end_ptr) {
-                        DEBUG(0,("parse_delete_tokens_list: corrupt data"));
-                        return -1;
-                }
-
-                pdtl->delete_nt_token = TALLOC_ZERO_P(pdtl, struct security_token);
-                if (pdtl->delete_nt_token == NULL) {
-                        DEBUG(0,("parse_delete_tokens_list: talloc failed"));
-                        return -1;
-                }
-
-                blob.data = p;
-                blob.length = end_ptr - p;
-
-                ndr_err = ndr_pull_struct_blob(&blob,
-                                pdtl,
-                                pdtl->delete_nt_token,
-                                (ndr_pull_flags_fn_t)ndr_pull_security_token);
-                if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
-                        DEBUG(1, ("parse_delete_tokens_list: "
-                                "ndr_pull_security_token failed\n"));
-                        return -1;
-                }
-
-                token_len = ndr_size_security_token(pdtl->delete_nt_token, 0);
-
-                p += token_len;
-                delete_tokens_size += token_len;
-
-                /* Add to the list. */
-                DLIST_ADD(lck->delete_tokens, pdtl);
-        }
-
-        return delete_tokens_size;
-}
-
-/*******************************************************************
- Get all share mode entries for a dev/inode pair.
-********************************************************************/
-
-static bool parse_share_modes(const TDB_DATA dbuf, struct share_mode_lock *lck)
-{
-        struct locking_data data;
-        int delete_tokens_size;
-        int i;
-
-        if (dbuf.dsize < sizeof(struct locking_data)) {
-                smb_panic("parse_share_modes: buffer too short");
-        }
-
-        memcpy(&data, dbuf.dptr, sizeof(data));
-
-        lck->old_write_time = data.u.s.old_write_time;
-        lck->changed_write_time = data.u.s.changed_write_time;
-        lck->num_share_modes = data.u.s.num_share_mode_entries;
-
-        DEBUG(10, ("parse_share_modes: owrt: %s, "
-                   "cwrt: %s, ntok: %u, num_share_modes: %d\n",
-                   timestring(talloc_tos(),
-                              convert_timespec_to_time_t(lck->old_write_time)),
-                   timestring(talloc_tos(),
-                              convert_timespec_to_time_t(
-                                      lck->changed_write_time)),
-                   (unsigned int)data.u.s.num_delete_token_entries,
-                   lck->num_share_modes));
-
-        if ((lck->num_share_modes < 0) || (lck->num_share_modes > 1000000)) {
-                DEBUG(0, ("invalid number of share modes: %d\n",
-                          lck->num_share_modes));
-                smb_panic("parse_share_modes: invalid number of share modes");
-        }
-
-        lck->share_modes = NULL;
-        
-        if (lck->num_share_modes != 0) {
-
-                if (dbuf.dsize < (sizeof(struct locking_data) +
-                                  (lck->num_share_modes *
-                                   sizeof(struct share_mode_entry)))) {
-                        smb_panic("parse_share_modes: buffer too short");
-                }
-                                  
-                lck->share_modes = (struct share_mode_entry *)
-                        TALLOC_MEMDUP(lck,
-                                      dbuf.dptr+sizeof(struct locking_data),
-                                      lck->num_share_modes *
-                                      sizeof(struct share_mode_entry));
-
-                if (lck->share_modes == NULL) {
-                        smb_panic("parse_share_modes: talloc failed");
-                }
-        }
-
-        /* Get any delete tokens. */
-        delete_tokens_size = parse_delete_tokens_list(lck, &data, dbuf);
-        if (delete_tokens_size < 0) {
-                smb_panic("parse_share_modes: parse_delete_tokens_list failed");
-        }
-
-        /* Save off the associated service path and filename. */
-        lck->servicepath = (const char *)dbuf.dptr + sizeof(struct locking_data) +
-                (lck->num_share_modes * sizeof(struct share_mode_entry)) +
-                delete_tokens_size;
-
-        lck->base_name = (const char *)dbuf.dptr + sizeof(struct locking_data) +
-                (lck->num_share_modes * sizeof(struct share_mode_entry)) +
-                delete_tokens_size +
-                strlen(lck->servicepath) + 1;
-
-        lck->stream_name = (const char *)dbuf.dptr + sizeof(struct locking_data) +
-                (lck->num_share_modes * sizeof(struct share_mode_entry)) +
-                delete_tokens_size +
-                strlen(lck->servicepath) + 1 +
-                strlen(lck->base_name) + 1;
-
-        /*
-         * Ensure that each entry has a real process attached.
-         */
-
-        for (i = 0; i < lck->num_share_modes; i++) {
-                struct share_mode_entry *entry_p = &lck->share_modes[i];
-                char *str = NULL;
-                if (DEBUGLEVEL >= 10) {
-                        str = share_mode_str(NULL, i, entry_p);
-                }
-                DEBUG(10,("parse_share_modes: %s\n",
-                        str ? str : ""));
-                if (!serverid_exists(&entry_p->pid)) {
-                        DEBUG(10,("parse_share_modes: deleted %s\n",
-                                str ? str : ""));
-                        entry_p->op_type = UNUSED_SHARE_MODE_ENTRY;
-                        lck->modified = True;
-                }
-                TALLOC_FREE(str);
-        }
-
-        return True;
-}
-
-static TDB_DATA unparse_share_modes(const struct share_mode_lock *lck)
-{
-        TDB_DATA result;
-        int num_valid = 0;
-        int i;
-        struct locking_data *data;
-        ssize_t offset;
-        ssize_t sp_len, bn_len, sn_len;
-        uint32_t delete_tokens_size = 0;
-        struct delete_token_list *pdtl = NULL;
-        uint32_t num_delete_token_entries = 0;
-
-        result.dptr = NULL;
-        result.dsize = 0;
-
-        for (i=0; i<lck->num_share_modes; i++) {
-                if (!is_unused_share_mode_entry(&lck->share_modes[i])) {
-                        num_valid += 1;
-                }
-        }
-
-        if (num_valid == 0) {
-                return result;
-        }
-
-        sp_len = strlen(lck->servicepath);
-        bn_len = strlen(lck->base_name);
-        sn_len = lck->stream_name != NULL ? strlen(lck->stream_name) : 0;
-
-        for (pdtl = lck->delete_tokens; pdtl; pdtl = pdtl->next) {
-                num_delete_token_entries++;
-                delete_tokens_size += sizeof(uint32_t) +
-                                ndr_size_security_unix_token(pdtl->delete_token, 0) +
-                                ndr_size_security_token(pdtl->delete_nt_token, 0);
-        }
-
-        result.dsize = sizeof(*data) +
-                lck->num_share_modes * sizeof(struct share_mode_entry) +
-                delete_tokens_size +
-                sp_len + 1 +
-                bn_len + 1 +
-                sn_len + 1;
-        result.dptr = TALLOC_ARRAY(lck, uint8, result.dsize);
-
-        if (result.dptr == NULL) {
-                smb_panic("talloc failed");
-        }
-
-        data = (struct locking_data *)result.dptr;
-        ZERO_STRUCTP(data);
-        data->u.s.num_share_mode_entries = lck->num_share_modes;
-        data->u.s.old_write_time = lck->old_write_time;
-        data->u.s.changed_write_time = lck->changed_write_time;
-        data->u.s.num_delete_token_entries = num_delete_token_entries;
-
-        DEBUG(10,("unparse_share_modes: owrt: %s cwrt: %s, ntok: %u, "
-                  "num: %d\n",
-                  timestring(talloc_tos(),
-                             convert_timespec_to_time_t(lck->old_write_time)),
-                  timestring(talloc_tos(),
-                             convert_timespec_to_time_t(
-                                     lck->changed_write_time)),
-                  (unsigned int)data->u.s.num_delete_token_entries,
-                  data->u.s.num_share_mode_entries));
-
-        memcpy(result.dptr + sizeof(*data), lck->share_modes,
-               sizeof(struct share_mode_entry)*lck->num_share_modes);
-        offset = sizeof(*data) +
-                sizeof(struct share_mode_entry)*lck->num_share_modes;
-
-        /* Store any delete on close tokens. */
-        for (pdtl = lck->delete_tokens; pdtl; pdtl = pdtl->next) {
-                struct security_unix_token *pdt = pdtl->delete_token;
-                struct security_token *pdt_nt = pdtl->delete_nt_token;
-                uint8_t *p = result.dptr + offset;
-                DATA_BLOB blob;
-                enum ndr_err_code ndr_err;
-
-                memcpy(p, &pdtl->name_hash, sizeof(uint32_t));
-                p += sizeof(uint32_t);
-                offset += sizeof(uint32_t);
-
-                ndr_err = ndr_push_struct_blob(&blob,
-                                talloc_tos(),
-                                pdt,
-                                (ndr_push_flags_fn_t)ndr_push_security_unix_token);
-
-                if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
-                        smb_panic("ndr_push_security_unix_token failed");
-                }
-
-                /* We know we have space here as we counted above. */
-                memcpy(p, blob.data, blob.length);
-                p += blob.length;
-                offset += blob.length;
-                TALLOC_FREE(blob.data);
-
-                ndr_err = ndr_push_struct_blob(&blob,
-                                talloc_tos(),
-                                pdt_nt,
-                                (ndr_push_flags_fn_t)ndr_push_security_token);
-
-                if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
-                        smb_panic("ndr_push_security_token failed");
-                }
-
-                /* We know we have space here as we counted above. */
-                memcpy(p, blob.data, blob.length);
-                p += blob.length;
-                offset += blob.length;
-                TALLOC_FREE(blob.data);
-        }
-
-        safe_strcpy((char *)result.dptr + offset, lck->servicepath,
-                    result.dsize - offset - 1);
-        offset += sp_len + 1;
-        safe_strcpy((char *)result.dptr + offset, lck->base_name,
-                    result.dsize - offset - 1);
-        offset += bn_len + 1;
-        safe_strcpy((char *)result.dptr + offset, lck->stream_name,
-                    result.dsize - offset - 1);
-
-        if (DEBUGLEVEL >= 10) {
-                print_share_mode_table(data);
-        }
-
-        return result;
-}
-
-static int share_mode_lock_destructor(struct share_mode_lock *lck)
-{
-        NTSTATUS status;
-        TDB_DATA data;
-
-        if (!lck->modified) {
-                return 0;
-        }
-
-        data = unparse_share_modes(lck);
-
-        if (data.dptr == NULL) {
-                if (!lck->fresh) {
-                        /* There has been an entry before, delete it */
-
-                        status = lck->record->delete_rec(lck->record);
-                        if (!NT_STATUS_IS_OK(status)) {
-                                char *errmsg;
-
-                                DEBUG(0, ("delete_rec returned %s\n",
-                                          nt_errstr(status)));
-
-                                if (asprintf(&errmsg, "could not delete share "
-                                             "entry: %s\n",
-                                             nt_errstr(status)) == -1) {
-                                        smb_panic("could not delete share"
-                                                  "entry");
-                                }
-                                smb_panic(errmsg);
-                        }
-                }
-                goto done;
-        }
-
-        status = lck->record->store(lck->record, data, TDB_REPLACE);
-        if (!NT_STATUS_IS_OK(status)) {
-                char *errmsg;
-
-                DEBUG(0, ("store returned %s\n", nt_errstr(status)));
-
-                if (asprintf(&errmsg, "could not store share mode entry: %s",
-                             nt_errstr(status)) == -1) {
-                        smb_panic("could not store share mode entry");
-                }
-                smb_panic(errmsg);
-        }
-
- done:
-
-        return 0;
-}
-
-static bool fill_share_mode_lock(struct share_mode_lock *lck,
-                                 struct file_id id,
-                                 const char *servicepath,
-                                 const struct smb_filename *smb_fname,
-                                 TDB_DATA share_mode_data,
-                                 const struct timespec *old_write_time)
-{
-        /* Ensure we set every field here as the destructor must be
-           valid even if parse_share_modes fails. */
-
-        lck->servicepath = NULL;
-        lck->base_name = NULL;
-        lck->stream_name = NULL;
-        lck->id = id;
-        lck->num_share_modes = 0;
-        lck->share_modes = NULL;
-        lck->delete_tokens = NULL;
-        ZERO_STRUCT(lck->old_write_time);
-        ZERO_STRUCT(lck->changed_write_time);
-        lck->fresh = False;
-        lck->modified = False;
-
-        lck->fresh = (share_mode_data.dptr == NULL);
-
-        if (lck->fresh) {
-                bool has_stream;
-                if (smb_fname == NULL || servicepath == NULL
-                    || old_write_time == NULL) {
-                        return False;
-                }
-
-                has_stream = smb_fname->stream_name != NULL;
-
-                lck->base_name = talloc_strdup(lck, smb_fname->base_name);
-                lck->stream_name = talloc_strdup(lck, smb_fname->stream_name);
-                lck->servicepath = talloc_strdup(lck, servicepath);
-                if (lck->base_name == NULL ||
-                    (has_stream && lck->stream_name == NULL) ||
-                    lck->servicepath == NULL) {
-                        DEBUG(0, ("talloc failed\n"));
-                        return False;
-                }
-                lck->old_write_time = *old_write_time;
-        } else {
-                if (!parse_share_modes(share_mode_data, lck)) {
-                        DEBUG(0, ("Could not parse share modes\n"));
-                        return False;
-                }
-        }
-
-        return True;
-}
-
-struct share_mode_lock *get_share_mode_lock(TALLOC_CTX *mem_ctx,
-                                            const struct file_id id,
-                                            const char *servicepath,
-                                            const struct smb_filename *smb_fname,
-                                            const struct timespec *old_write_time)
-{
-        struct share_mode_lock *lck;
-        struct file_id tmp;
-        TDB_DATA key = locking_key(&id, &tmp);
-
-        if (!(lck = TALLOC_P(mem_ctx, struct share_mode_lock))) {
-                DEBUG(0, ("talloc failed\n"));
-                return NULL;
-        }
-
-        if (!(lck->record = lock_db->fetch_locked(lock_db, lck, key))) {
-                DEBUG(3, ("Could not lock share entry\n"));
-                TALLOC_FREE(lck);
-                return NULL;
-        }
-
-        if (!fill_share_mode_lock(lck, id, servicepath, smb_fname,
-                                  lck->record->value, old_write_time)) {
-                DEBUG(3, ("fill_share_mode_lock failed\n"));
-                TALLOC_FREE(lck);
-                return NULL;
-        }
-
-        talloc_set_destructor(lck, share_mode_lock_destructor);
-
-        return lck;
-}
-
-struct share_mode_lock *fetch_share_mode_unlocked(TALLOC_CTX *mem_ctx,
-                                                  const struct file_id id)
-{
-        struct share_mode_lock *lck;
-        struct file_id tmp;
-        TDB_DATA key = locking_key(&id, &tmp);
-        TDB_DATA data;
-
-        if (!(lck = TALLOC_P(mem_ctx, struct share_mode_lock))) {
-                DEBUG(0, ("talloc failed\n"));
-                return NULL;
-        }
-
-        if (lock_db->fetch(lock_db, lck, key, &data) == -1) {
-                DEBUG(3, ("Could not fetch share entry\n"));
-                TALLOC_FREE(lck);
-                return NULL;
-        }
-
-        if (!fill_share_mode_lock(lck, id, NULL, NULL, data, NULL)) {
-                DEBUG(10, ("fetch_share_mode_unlocked: no share_mode record "
-                           "around (file not open)\n"));
-                TALLOC_FREE(lck);
-                return NULL;
-        }
-
-        return lck;
+struct share_mode_lock *get_existing_share_mode_lock(TALLOC_CTX *mem_ctx,
+                                                     const struct file_id id)
+{
+        return get_share_mode_lock(mem_ctx, id, NULL, NULL, NULL);
 }
 
@@ -1041 +463 @@
 bool rename_share_filename(struct messaging_context *msg_ctx,
                         struct share_mode_lock *lck,
+                        struct file_id id,
                         const char *servicepath,
                         uint32_t orig_name_hash,
@@ -1046 +469 @@
                         const struct smb_filename *smb_fname_dst)
 {
+        struct share_mode_data *d = lck->data;
         size_t sp_len;
         size_t bn_len;
@@ -1051 +475 @@
         size_t msg_len;
         char *frm = NULL;
-        int i;
+        uint32_t i;
         bool strip_two_chars = false;
         bool has_stream = smb_fname_dst->stream_name != NULL;
+        struct server_id self_pid = messaging_server_id(msg_ctx);
 
         DEBUG(10, ("rename_share_filename: servicepath %s newname %s\n",
@@ -1069 +494 @@
         }
 
-        lck->servicepath = talloc_strdup(lck, servicepath);
-        lck->base_name = talloc_strdup(lck, smb_fname_dst->base_name +
+        d->servicepath = talloc_strdup(d, servicepath);
+        d->base_name = talloc_strdup(d, smb_fname_dst->base_name +
                                        (strip_two_chars ? 2 : 0));
-        lck->stream_name = talloc_strdup(lck, smb_fname_dst->stream_name);
-        if (lck->base_name == NULL ||
-            (has_stream && lck->stream_name == NULL) ||
-            lck->servicepath == NULL) {
+        d->stream_name = talloc_strdup(d, smb_fname_dst->stream_name);
+        if (d->base_name == NULL ||
+            (has_stream && d->stream_name == NULL) ||
+            d->servicepath == NULL) {
                 DEBUG(0, ("rename_share_filename: talloc failed\n"));
                 return False;
         }
-        lck->modified = True;
-
-        sp_len = strlen(lck->servicepath);
-        bn_len = strlen(lck->base_name);
-        sn_len = has_stream ? strlen(lck->stream_name) : 0;
+        d->modified = True;
+
+        sp_len = strlen(d->servicepath);
+        bn_len = strlen(d->base_name);
+        sn_len = has_stream ? strlen(d->stream_name) : 0;
 
         msg_len = MSG_FILE_RENAMED_MIN_SIZE + sp_len + 1 + bn_len + 1 +
@@ -1089 +514 @@
 
         /* Set up the name changed message. */
-        frm = TALLOC_ARRAY(lck, char, msg_len);
+        frm = talloc_array(d, char, msg_len);
         if (!frm) {
                 return False;
         }
 
-        push_file_id_24(frm, &lck->id);
+        push_file_id_24(frm, &id);
 
         DEBUG(10,("rename_share_filename: msg_len = %u\n", (unsigned int)msg_len ));
 
-        safe_strcpy(&frm[24], lck->servicepath, sp_len);
-        safe_strcpy(&frm[24 + sp_len + 1], lck->base_name, bn_len);
-        safe_strcpy(&frm[24 + sp_len + 1 + bn_len + 1], lck->stream_name,
-                    sn_len);
+        strlcpy(&frm[24],
+                d->servicepath ? d->servicepath : "",
+                sp_len+1);
+        strlcpy(&frm[24 + sp_len + 1],
+                d->base_name ? d->base_name : "",
+                bn_len+1);
+        strlcpy(&frm[24 + sp_len + 1 + bn_len + 1],
+                d->stream_name ? d->stream_name : "",
+                sn_len+1);
 
         /* Send the messages. */
-        for (i=0; i<lck->num_share_modes; i++) {
-                struct share_mode_entry *se = &lck->share_modes[i];
+        for (i=0; i<d->num_share_modes; i++) {
+                struct share_mode_entry *se = &d->share_modes[i];
+                struct server_id_buf tmp;
+
                 if (!is_valid_share_mode_entry(se)) {
                         continue;
@@ -1119 +551 @@
 
                 /* But not to ourselves... */
-                if (procid_is_me(&se->pid)) {
+                if (serverid_equal(&se->pid, &self_pid)) {
+                        continue;
+                }
+
+                if (share_mode_stale_pid(d, i)) {
                         continue;
                 }
@@ -1126 +562 @@
                           "pid %s file_id %s sharepath %s base_name %s "
                           "stream_name %s\n",
-                          procid_str_static(&se->pid),
-                          file_id_string_tos(&lck->id),
-                          lck->servicepath, lck->base_name,
-                        has_stream ? lck->stream_name : ""));
+                          server_id_str_buf(se->pid, &tmp),
+                          file_id_string_tos(&id),
+                          d->servicepath, d->base_name,
+                        has_stream ? d->stream_name : ""));
 
                 messaging_send_buf(msg_ctx, se->pid, MSG_SMB_FILE_RENAME,
-                                   (uint8 *)frm, msg_len);
+                                   (uint8_t *)frm, msg_len);
+        }
+
+        for (i=0; i<d->num_leases; i++) {
+                /* Update the filename in leases_db. */
+                NTSTATUS status;
+                struct share_mode_lease *l;
+
+                l = &d->leases[i];
+
+                status = leases_db_rename(&l->client_guid,
+                                        &l->lease_key,
+                                        &id,
+                                        d->servicepath,
+                                        d->base_name,
+                                        d->stream_name);
+                if (!NT_STATUS_IS_OK(status)) {
+                        /* Any error recovery possible here ? */
+                        DEBUG(1,("Failed to rename lease key for "
+                                "renamed file %s:%s. %s\n",
+                                d->base_name,
+                                d->stream_name,
+                                nt_errstr(status)));
+                        continue;
+                }
         }
 
@@ -1162 +622 @@
 
         if (write_time) {
-                struct timespec wt;
-
-                wt = lck->changed_write_time;
-                if (null_timespec(wt)) {
-                        wt = lck->old_write_time;
-                }
-
-                *write_time = wt;
+                *write_time = get_share_mode_write_time(lck);
         }
 
@@ -1179 +632 @@
         int num_props = 0;
 
-        if (e->op_type == UNUSED_SHARE_MODE_ENTRY) {
-                /* cope with dead entries from the process not
-                   existing. These should not be considered valid,
-                   otherwise we end up doing zero timeout sharing
-                   violation */
-                return False;
+        if (e->stale) {
+                return false;
         }
 
@@ -1190 +639 @@
         num_props += (EXCLUSIVE_OPLOCK_TYPE(e->op_type) ? 1 : 0);
         num_props += (LEVEL_II_OPLOCK_TYPE(e->op_type) ? 1 : 0);
-
-        SMB_ASSERT(num_props <= 1);
+        num_props += (e->op_type == LEASE_OPLOCK);
+
+        if ((num_props > 1) && serverid_exists(&e->pid)) {
+                smb_panic("Invalid share mode entry");
+        }
         return (num_props != 0);
 }
 
-bool is_deferred_open_entry(const struct share_mode_entry *e)
-{
-        return (e->op_type == DEFERRED_OPEN_ENTRY);
-}
-
-bool is_unused_share_mode_entry(const struct share_mode_entry *e)
-{
-        return (e->op_type == UNUSED_SHARE_MODE_ENTRY);
-}
-
-/*******************************************************************
- Fill a share mode entry.
-********************************************************************/
-
-static void fill_share_mode_entry(struct share_mode_entry *e,
-                                  files_struct *fsp,
-                                  uid_t uid, uint64_t mid, uint16 op_type)
-{
+/*
+ * See if we need to remove a lease being referred to by a
+ * share mode that is being marked stale or deleted.
+ */
+
+static void remove_share_mode_lease(struct share_mode_data *d,
+                                    struct share_mode_entry *e)
+{
+        struct GUID client_guid;
+        struct smb2_lease_key lease_key;
+        uint16_t op_type;
+        uint32_t lease_idx;
+        uint32_t i;
+
+        op_type = e->op_type;
+        e->op_type = NO_OPLOCK;
+
+        d->modified = true;
+
+        if (op_type != LEASE_OPLOCK) {
+                return;
+        }
+
+        /*
+         * This used to reference a lease. If there's no other one referencing
+         * it, remove it.
+         */
+
+        lease_idx = e->lease_idx;
+        e->lease_idx = UINT32_MAX;
+
+        for (i=0; i<d->num_share_modes; i++) {
+                if (d->share_modes[i].stale) {
+                        continue;
+                }
+                if (e == &d->share_modes[i]) {
+                        /* Not ourselves. */
+                        continue;
+                }
+                if (d->share_modes[i].lease_idx == lease_idx) {
+                        break;
+                }
+        }
+        if (i < d->num_share_modes) {
+                /*
+                 * Found another one
+                 */
+                return;
+        }
+
+        memcpy(&client_guid,
+                &d->leases[lease_idx].client_guid,
+                sizeof(client_guid));
+        lease_key = d->leases[lease_idx].lease_key;
+
+        d->num_leases -= 1;
+        d->leases[lease_idx] = d->leases[d->num_leases];
+
+        /*
+         * We changed the lease array. Fix all references to it.
+         */
+        for (i=0; i<d->num_share_modes; i++) {
+                if (d->share_modes[i].lease_idx == d->num_leases) {
+                        d->share_modes[i].lease_idx = lease_idx;
+                        d->share_modes[i].lease = &d->leases[lease_idx];
+                }
+        }
+
+        {
+                NTSTATUS status;
+
+                status = leases_db_del(&client_guid,
+                                        &lease_key,
+                                        &e->id);
+
+                DEBUG(10, ("%s: leases_db_del returned %s\n", __func__,
+                           nt_errstr(status)));
+        }
+}
+
+/*
+ * In case d->share_modes[i] conflicts with something or otherwise is
+ * being used, we need to make sure the corresponding process still
+ * exists.
+ */
+bool share_mode_stale_pid(struct share_mode_data *d, uint32_t idx)
+{
+        struct server_id_buf tmp;
+        struct share_mode_entry *e;
+
+        if (idx > d->num_share_modes) {
+                DEBUG(1, ("Asking for index %u, only %u around\n",
+                          idx, (unsigned)d->num_share_modes));
+                return false;
+        }
+        e = &d->share_modes[idx];
+        if (e->stale) {
+                /*
+                 * Checked before
+                 */
+                return true;
+        }
+        if (serverid_exists(&e->pid)) {
+                DEBUG(10, ("PID %s (index %u out of %u) still exists\n",
+                           server_id_str_buf(e->pid, &tmp), idx,
+                           (unsigned)d->num_share_modes));
+                return false;
+        }
+        DEBUG(10, ("PID %s (index %u out of %u) does not exist anymore\n",
+                   server_id_str_buf(e->pid, &tmp), idx,
+                   (unsigned)d->num_share_modes));
+
+        e->stale = true;
+
+        if (d->num_delete_tokens != 0) {
+                uint32_t i, num_stale;
+
+                /*
+                 * We cannot have any delete tokens
+                 * if there are no valid share modes.
+                 */
+
+                num_stale = 0;
+
+                for (i=0; i<d->num_share_modes; i++) {
+                        if (d->share_modes[i].stale) {
+                                num_stale += 1;
+                        }
+                }
+
+                if (num_stale == d->num_share_modes) {
+                        /*
+                         * No non-stale share mode found
+                         */
+                        TALLOC_FREE(d->delete_tokens);
+                        d->num_delete_tokens = 0;
+                }
+        }
+
+        remove_share_mode_lease(d, e);
+
+        d->modified = true;
+        return true;
+}
+
+void remove_stale_share_mode_entries(struct share_mode_data *d)
+{
+        uint32_t i;
+
+        i = 0;
+        while (i < d->num_share_modes) {
+                if (d->share_modes[i].stale) {
+                        struct share_mode_entry *m = d->share_modes;
+                        m[i] = m[d->num_share_modes-1];
+                        d->num_share_modes -= 1;
+                } else {
+                        i += 1;
+                }
+        }
+}
+
+bool set_share_mode(struct share_mode_lock *lck, struct files_struct *fsp,
+                    uid_t uid, uint64_t mid, uint16_t op_type,
+                    uint32_t lease_idx)
+{
+        struct share_mode_data *d = lck->data;
+        struct share_mode_entry *tmp, *e;
+        struct share_mode_lease *lease = NULL;
+
+        if (lease_idx == UINT32_MAX) {
+                lease = NULL;
+        } else if (lease_idx >= d->num_leases) {
+                return false;
+        } else {
+                lease = &d->leases[lease_idx];
+        }
+
+        tmp = talloc_realloc(d, d->share_modes, struct share_mode_entry,
+                             d->num_share_modes+1);
+        if (tmp == NULL) {
+                return false;
+        }
+        d->share_modes = tmp;
+        e = &d->share_modes[d->num_share_modes];
+        d->num_share_modes += 1;
+        d->modified = true;
+
         ZERO_STRUCTP(e);
-        e->pid = sconn_server_id(fsp->conn->sconn);
+        e->pid = messaging_server_id(fsp->conn->sconn->msg_ctx);
         e->share_access = fsp->share_access;
         e->private_options = fsp->fh->private_options;
@@ -1220 +841 @@
         e->op_mid = mid;
         e->op_type = op_type;
+        e->lease_idx = lease_idx;
+        e->lease = lease;
         e->time.tv_sec = fsp->open_time.tv_sec;
         e->time.tv_usec = fsp->open_time.tv_usec;
         e->id = fsp->file_id;
         e->share_file_id = fsp->fh->gen_id;
-        e->uid = (uint32)uid;
-        e->flags = fsp->posix_open ? SHARE_MODE_FLAG_POSIX_OPEN : 0;
+        e->uid = (uint32_t)uid;
+        e->flags = (fsp->posix_flags & FSP_POSIX_FLAGS_OPEN) ?
+                SHARE_MODE_FLAG_POSIX_OPEN : 0;
         e->name_hash = fsp->name_hash;
-}
-
-static void fill_deferred_open_entry(struct share_mode_entry *e,
-                                     const struct timeval request_time,
-                                     struct file_id id,
-                                     struct server_id pid,
-                                     uint64_t mid)
-{
-        ZERO_STRUCTP(e);
-        e->pid = pid;
-        e->op_mid = mid;
-        e->op_type = DEFERRED_OPEN_ENTRY;
-        e->time.tv_sec = request_time.tv_sec;
-        e->time.tv_usec = request_time.tv_usec;
-        e->id = id;
-        e->uid = (uint32)-1;
-        e->flags = 0;
-}
-
-static void add_share_mode_entry(struct share_mode_lock *lck,
-                                 const struct share_mode_entry *entry)
-{
+
+        return true;
+}
+
+static struct share_mode_entry *find_share_mode_entry(
+        struct share_mode_lock *lck, files_struct *fsp)
+{
+        struct share_mode_data *d = lck->data;
+        struct server_id pid;
         int i;
 
-        for (i=0; i<lck->num_share_modes; i++) {
-                struct share_mode_entry *e = &lck->share_modes[i];
-                if (is_unused_share_mode_entry(e)) {
-                        *e = *entry;
-                        break;
-                }
-        }
-
-        if (i == lck->num_share_modes) {
-                /* No unused entry found */
-                ADD_TO_ARRAY(lck, struct share_mode_entry, *entry,
-                             &lck->share_modes, &lck->num_share_modes);
-        }
-        lck->modified = True;
-}
-
-void set_share_mode(struct share_mode_lock *lck, files_struct *fsp,
-                    uid_t uid, uint64_t mid, uint16 op_type)
-{
-        struct share_mode_entry entry;
-        fill_share_mode_entry(&entry, fsp, uid, mid, op_type);
-        add_share_mode_entry(lck, &entry);
-}
-
-void add_deferred_open(struct share_mode_lock *lck, uint64_t mid,
-                       struct timeval request_time,
-                       struct server_id pid, struct file_id id)
-{
-        struct share_mode_entry entry;
-        fill_deferred_open_entry(&entry, request_time, id, pid, mid);
-        add_share_mode_entry(lck, &entry);
-}
-
-/*******************************************************************
- Check if two share mode entries are identical, ignoring oplock 
- and mid info and desired_access. (Removed paranoia test - it's
- not automatically a logic error if they are identical. JRA.)
-********************************************************************/
-
-static bool share_modes_identical(struct share_mode_entry *e1,
-                                  struct share_mode_entry *e2)
-{
-        /* We used to check for e1->share_access == e2->share_access here
-           as well as the other fields but 2 different DOS or FCB opens
-           sharing the same share mode entry may validly differ in
-           fsp->share_access field. */
-
-        return (procid_equal(&e1->pid, &e2->pid) &&
-                file_id_equal(&e1->id, &e2->id) &&
-                e1->share_file_id == e2->share_file_id );
-}
-
-static bool deferred_open_identical(struct share_mode_entry *e1,
-                                    struct share_mode_entry *e2)
-{
-        return (procid_equal(&e1->pid, &e2->pid) &&
-                (e1->op_mid == e2->op_mid) &&
-                file_id_equal(&e1->id, &e2->id));
-}
-
-static struct share_mode_entry *find_share_mode_entry(struct share_mode_lock *lck,
-                                                      struct share_mode_entry *entry)
-{
-        int i;
-
-        for (i=0; i<lck->num_share_modes; i++) {
-                struct share_mode_entry *e = &lck->share_modes[i];
-                if (is_valid_share_mode_entry(entry) &&
-                    is_valid_share_mode_entry(e) &&
-                    share_modes_identical(e, entry)) {
-                        return e;
-                }
-                if (is_deferred_open_entry(entry) &&
-                    is_deferred_open_entry(e) &&
-                    deferred_open_identical(e, entry)) {
-                        return e;
-                }
+        pid = messaging_server_id(fsp->conn->sconn->msg_ctx);
+
+        for (i=0; i<d->num_share_modes; i++) {
+                struct share_mode_entry *e = &d->share_modes[i];
+
+                if (!is_valid_share_mode_entry(e)) {
+                        continue;
+                }
+                if (!serverid_equal(&pid, &e->pid)) {
+                        continue;
+                }
+                if (!file_id_equal(&fsp->file_id, &e->id)) {
+                        continue;
+                }
+                if (fsp->fh->gen_id != e->share_file_id) {
+                        continue;
+                }
+                return e;
         }
         return NULL;
@@ -1339 +891 @@
 bool del_share_mode(struct share_mode_lock *lck, files_struct *fsp)
 {
-        struct share_mode_entry entry, *e;
-
-        /* Don't care about the pid owner being correct here - just a search. */
-        fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
-
-        e = find_share_mode_entry(lck, &entry);
+        struct share_mode_entry *e;
+
+        e = find_share_mode_entry(lck, fsp);
         if (e == NULL) {
                 return False;
         }
-
-        e->op_type = UNUSED_SHARE_MODE_ENTRY;
-        lck->modified = True;
+        remove_share_mode_lease(lck->data, e);
+        *e = lck->data->share_modes[lck->data->num_share_modes-1];
+        lck->data->num_share_modes -= 1;
+        lck->data->modified = True;
         return True;
 }
 
-void del_deferred_open_entry(struct share_mode_lock *lck, uint64_t mid,
-                             struct server_id pid)
-{
-        struct share_mode_entry entry, *e;
-
-        fill_deferred_open_entry(&entry, timeval_zero(),
-                                 lck->id, pid, mid);
-
-        e = find_share_mode_entry(lck, &entry);
+bool mark_share_mode_disconnected(struct share_mode_lock *lck,
+                                  struct files_struct *fsp)
+{
+        struct share_mode_entry *e;
+
+        if (lck->data->num_share_modes != 1) {
+                return false;
+        }
+
+        if (fsp->op == NULL) {
+                return false;
+        }
+        if (!fsp->op->global->durable) {
+                return false;
+        }
+
+        e = find_share_mode_entry(lck, fsp);
         if (e == NULL) {
-                return;
-        }
-
-        e->op_type = UNUSED_SHARE_MODE_ENTRY;
-        lck->modified = True;
+                return false;
+        }
+
+        DEBUG(10, ("Marking share mode entry disconnected for durable handle\n"));
+
+        server_id_set_disconnected(&e->pid);
+
+        /*
+         * On reopen the caller needs to check that
+         * the client comes with the correct handle.
+         */
+        e->share_file_id = fsp->op->global->open_persistent_id;
+
+        lck->data->modified = true;
+        return true;
 }
 
@@ -1377 +945 @@
 bool remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
 {
-        struct share_mode_entry entry, *e;
-
-        /* Don't care about the pid owner being correct here - just a search. */
-        fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
-
-        e = find_share_mode_entry(lck, &entry);
+        struct share_mode_data *d = lck->data;
+        struct share_mode_entry *e;
+
+        e = find_share_mode_entry(lck, fsp);
         if (e == NULL) {
                 return False;
         }
 
-        if (EXCLUSIVE_OPLOCK_TYPE(e->op_type)) {
-                /*
-                 * Going from exclusive or batch,
-                 * we always go through FAKE_LEVEL_II
-                 * first.
-                 */
-                if (!EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
-                        smb_panic("remove_share_oplock: logic error");
-                }
-                e->op_type = FAKE_LEVEL_II_OPLOCK;
-        } else {
-                e->op_type = NO_OPLOCK;
-        }
-        lck->modified = True;
-        return True;
+        remove_share_mode_lease(d, e);
+        d->modified = True;
+        return true;
 }
 
@@ -1410 +964 @@
 bool downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
 {
-        struct share_mode_entry entry, *e;
-
-        /* Don't care about the pid owner being correct here - just a search. */
-        fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
-
-        e = find_share_mode_entry(lck, &entry);
+        struct share_mode_entry *e;
+
+        e = find_share_mode_entry(lck, fsp);
         if (e == NULL) {
                 return False;
@@ -1421 +972 @@
 
         e->op_type = LEVEL_II_OPLOCK;
-        lck->modified = True;
+        lck->data->modified = True;
         return True;
 }
 
-/****************************************************************************
- Check if setting delete on close is allowed on this fsp.
-****************************************************************************/
-
-NTSTATUS can_set_delete_on_close(files_struct *fsp, uint32 dosmode)
-{
+NTSTATUS downgrade_share_lease(struct smbd_server_connection *sconn,
+                               struct share_mode_lock *lck,
+                               const struct smb2_lease_key *key,
+                               uint32_t new_lease_state,
+                               struct share_mode_lease **_l)
+{
+        struct share_mode_data *d = lck->data;
+        struct share_mode_lease *l;
+        uint32_t i;
+
+        *_l = NULL;
+
+        for (i=0; i<d->num_leases; i++) {
+                if (smb2_lease_equal(&sconn->client->connections->smb2.client.guid,
+                                     key,
+                                     &d->leases[i].client_guid,
+                                     &d->leases[i].lease_key)) {
+                        break;
+                }
+        }
+        if (i == d->num_leases) {
+                DEBUG(10, ("lease not found\n"));
+                return NT_STATUS_INVALID_PARAMETER;
+        }
+
+        l = &d->leases[i];
+
+        if (!l->breaking) {
+                DEBUG(1, ("Attempt to break from %d to %d - but we're not in breaking state\n",
+                           (int)l->current_state, (int)new_lease_state));
+                return NT_STATUS_UNSUCCESSFUL;
+        }
+
         /*
-         * Only allow delete on close for writable files.
+         * Can't upgrade anything: l->breaking_to_requested (and l->current_state)
+         * must be a strict bitwise superset of new_lease_state
          */
-
-        if ((dosmode & FILE_ATTRIBUTE_READONLY) &&
-            !lp_delete_readonly(SNUM(fsp->conn))) {
-                DEBUG(10,("can_set_delete_on_close: file %s delete on close "
-                          "flag set but file attribute is readonly.\n",
-                          fsp_str_dbg(fsp)));
-                return NT_STATUS_CANNOT_DELETE;
-        }
-
-        /*
-         * Only allow delete on close for writable shares.
-         */
-
-        if (!CAN_WRITE(fsp->conn)) {
-                DEBUG(10,("can_set_delete_on_close: file %s delete on "
-                          "close flag set but write access denied on share.\n",
-                          fsp_str_dbg(fsp)));
-                return NT_STATUS_ACCESS_DENIED;
-        }
-
-        /*
-         * Only allow delete on close for files/directories opened with delete
-         * intent.
-         */
-
-        if (!(fsp->access_mask & DELETE_ACCESS)) {
-                DEBUG(10,("can_set_delete_on_close: file %s delete on "
-                          "close flag set but delete access denied.\n",
-                          fsp_str_dbg(fsp)));
-                return NT_STATUS_ACCESS_DENIED;
-        }
-
-        /* Don't allow delete on close for non-empty directories. */
-        if (fsp->is_directory) {
-                SMB_ASSERT(!is_ntfs_stream_smb_fname(fsp->fsp_name));
-
-                /* Or the root of a share. */
-                if (ISDOT(fsp->fsp_name->base_name)) {
-                        DEBUG(10,("can_set_delete_on_close: can't set delete on "
-                                  "close for the root of a share.\n"));
-                        return NT_STATUS_ACCESS_DENIED;
-                }
-
-                return can_delete_directory_fsp(fsp);
-        }
+        if ((new_lease_state & l->breaking_to_requested) != new_lease_state) {
+                DEBUG(1, ("Attempt to upgrade from %d to %d - expected %d\n",
+                           (int)l->current_state, (int)new_lease_state,
+                           (int)l->breaking_to_requested));
+                return NT_STATUS_REQUEST_NOT_ACCEPTED;
+        }
+
+        if (l->current_state != new_lease_state) {
+                l->current_state = new_lease_state;
+                d->modified = true;
+        }
+
+        if ((new_lease_state & ~l->breaking_to_required) != 0) {
+                DEBUG(5, ("lease state %d not fully broken from %d to %d\n",
+                           (int)new_lease_state,
+                           (int)l->current_state,
+                           (int)l->breaking_to_required));
+                l->breaking_to_requested = l->breaking_to_required;
+                if (l->current_state & (~SMB2_LEASE_READ)) {
+                        /*
+                         * Here we break in steps, as windows does
+                         * see the breaking3 and v2_breaking3 tests.
+                         */
+                        l->breaking_to_requested |= SMB2_LEASE_READ;
+                }
+                d->modified = true;
+                *_l = l;
+                return NT_STATUS_OPLOCK_BREAK_IN_PROGRESS;
+        }
+
+        DEBUG(10, ("breaking from %d to %d - expected %d\n",
+                   (int)l->current_state, (int)new_lease_state,
+                   (int)l->breaking_to_requested));
+
+        l->breaking_to_requested = 0;
+        l->breaking_to_required = 0;
+        l->breaking = false;
+
+        d->modified = true;
 
         return NT_STATUS_OK;
-}
-
-/*************************************************************************
- Return a talloced copy of a struct security_unix_token. NULL on fail.
- (Should this be in locking.c.... ?).
-*************************************************************************/
-
-static struct security_unix_token *copy_unix_token(TALLOC_CTX *ctx, const struct security_unix_token *tok)
-{
-        struct security_unix_token *cpy;
-
-        cpy = TALLOC_P(ctx, struct security_unix_token);
-        if (!cpy) {
-                return NULL;
-        }
-
-        cpy->uid = tok->uid;
-        cpy->gid = tok->gid;
-        cpy->ngroups = tok->ngroups;
-        if (tok->ngroups) {
-                /* Make this a talloc child of cpy. */
-                cpy->groups = TALLOC_ARRAY(cpy, gid_t, tok->ngroups);
-                if (!cpy->groups) {
-                        return NULL;
-                }
-                memcpy(cpy->groups, tok->groups, tok->ngroups * sizeof(gid_t));
-        }
-        return cpy;
 }
 
@@ -1515 +1060 @@
 ****************************************************************************/
 
-static bool add_delete_on_close_token(struct share_mode_lock *lck,
+static bool add_delete_on_close_token(struct share_mode_data *d,
                         uint32_t name_hash,
                         const struct security_token *nt_tok,
                         const struct security_unix_token *tok)
 {
-        struct delete_token_list *dtl;
-
-        dtl = TALLOC_ZERO_P(lck, struct delete_token_list);
-        if (dtl == NULL) {
+        struct delete_token *tmp, *dtl;
+
+        tmp = talloc_realloc(d, d->delete_tokens, struct delete_token,
+                             d->num_delete_tokens+1);
+        if (tmp == NULL) {
                 return false;
         }
+        d->delete_tokens = tmp;
+        dtl = &d->delete_tokens[d->num_delete_tokens];
 
         dtl->name_hash = name_hash;
-        dtl->delete_token = copy_unix_token(dtl, tok);
+        dtl->delete_nt_token = dup_nt_token(d->delete_tokens, nt_tok);
+        if (dtl->delete_nt_token == NULL) {
+                return false;
+        }
+        dtl->delete_token = copy_unix_token(d->delete_tokens, tok);
         if (dtl->delete_token == NULL) {
-                TALLOC_FREE(dtl);
                 return false;
         }
-        dtl->delete_nt_token = dup_nt_token(dtl, nt_tok);
-        if (dtl->delete_nt_token == NULL) {
-                TALLOC_FREE(dtl);
-                return false;
-        }
-        DLIST_ADD(lck->delete_tokens, dtl);
-        lck->modified = true;
+        d->num_delete_tokens += 1;
+        d->modified = true;
         return true;
+}
+
+void reset_delete_on_close_lck(files_struct *fsp,
+                               struct share_mode_lock *lck)
+{
+        struct share_mode_data *d = lck->data;
+        uint32_t i;
+
+        for (i=0; i<d->num_delete_tokens; i++) {
+                struct delete_token *dt = &d->delete_tokens[i];
+
+                if (dt->name_hash == fsp->name_hash) {
+                        d->modified = true;
+
+                        /* Delete this entry. */
+                        TALLOC_FREE(dt->delete_nt_token);
+                        TALLOC_FREE(dt->delete_token);
+                        *dt = d->delete_tokens[d->num_delete_tokens-1];
+                        d->num_delete_tokens -= 1;
+                }
+        }
 }
 
@@ -1556 +1123 @@
 void set_delete_on_close_lck(files_struct *fsp,
                         struct share_mode_lock *lck,
-                        bool delete_on_close,
                         const struct security_token *nt_tok,
                         const struct security_unix_token *tok)
 {
-        struct delete_token_list *dtl;
+        struct messaging_context *msg_ctx = fsp->conn->sconn->msg_ctx;
+        struct share_mode_data *d = lck->data;
+        uint32_t i;
         bool ret;
-
-        if (delete_on_close) {
-                SMB_ASSERT(nt_tok != NULL);
-                SMB_ASSERT(tok != NULL);
-        } else {
-                SMB_ASSERT(nt_tok == NULL);
-                SMB_ASSERT(tok == NULL);
-        }
-
-        for (dtl = lck->delete_tokens; dtl; dtl = dtl->next) {
-                if (dtl->name_hash == fsp->name_hash) {
-                        lck->modified = true;
-                        if (delete_on_close == false) {
-                                /* Delete this entry. */
-                                DLIST_REMOVE(lck->delete_tokens, dtl);
-                                TALLOC_FREE(dtl);
-                        } else {
-                                /* Replace this token with the
-                                   given tok. */
-                                TALLOC_FREE(dtl->delete_token);
-                                dtl->delete_token = copy_unix_token(dtl, tok);
-                                SMB_ASSERT(dtl->delete_token != NULL);
-                                TALLOC_FREE(dtl->delete_nt_token);
-                                dtl->delete_nt_token = dup_nt_token(dtl, nt_tok);
-                                SMB_ASSERT(dtl->delete_nt_token != NULL);
-                        }
+        DATA_BLOB fid_blob = {};
+        enum ndr_err_code ndr_err;
+
+        SMB_ASSERT(nt_tok != NULL);
+        SMB_ASSERT(tok != NULL);
+
+        for (i=0; i<d->num_delete_tokens; i++) {
+                struct delete_token *dt = &d->delete_tokens[i];
+                if (dt->name_hash == fsp->name_hash) {
+                        d->modified = true;
+
+                        /* Replace this token with the given tok. */
+                        TALLOC_FREE(dt->delete_nt_token);
+                        dt->delete_nt_token = dup_nt_token(dt, nt_tok);
+                        SMB_ASSERT(dt->delete_nt_token != NULL);
+                        TALLOC_FREE(dt->delete_token);
+                        dt->delete_token = copy_unix_token(dt, tok);
+                        SMB_ASSERT(dt->delete_token != NULL);
+
                         return;
                 }
         }
 
-        if (!delete_on_close) {
-                /* Nothing to delete - not found. */
-                return;
-        }
-
-        ret = add_delete_on_close_token(lck, fsp->name_hash, nt_tok, tok);
+        ret = add_delete_on_close_token(lck->data, fsp->name_hash, nt_tok, tok);
         SMB_ASSERT(ret);
+
+        ndr_err = ndr_push_struct_blob(&fid_blob, talloc_tos(), &fsp->file_id,
+                                       (ndr_push_flags_fn_t)ndr_push_file_id);
+        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+                DEBUG(10, ("ndr_push_file_id failed: %s\n",
+                           ndr_errstr(ndr_err)));
+        }
+
+        for (i=0; i<d->num_share_modes; i++) {
+                struct share_mode_entry *e = &d->share_modes[i];
+                NTSTATUS status;
+
+                status = messaging_send(
+                        msg_ctx, e->pid, MSG_SMB_NOTIFY_CANCEL_DELETED,
+                        &fid_blob);
+
+                if (!NT_STATUS_IS_OK(status)) {
+                        struct server_id_buf tmp;
+                        DEBUG(10, ("%s: messaging_send to %s returned %s\n",
+                                   __func__, server_id_str_buf(e->pid, &tmp),
+                                   nt_errstr(status)));
+                }
+        }
+
+        TALLOC_FREE(fid_blob.data);
 }
 
@@ -1606 +1187 @@
 {
         struct share_mode_lock *lck;
-        
+
         DEBUG(10,("set_delete_on_close: %s delete on close flag for "
-                  "fnum = %d, file %s\n",
-                  delete_on_close ? "Adding" : "Removing", fsp->fnum,
+                  "%s, file %s\n",
+                  delete_on_close ? "Adding" : "Removing", fsp_fnum_dbg(fsp),
                   fsp_str_dbg(fsp)));
 
-        lck = get_share_mode_lock(talloc_tos(), fsp->file_id, NULL, NULL,
-                                  NULL);
+        lck = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
         if (lck == NULL) {
                 return False;
@@ -1619 +1199 @@
 
         if (delete_on_close) {
-                set_delete_on_close_lck(fsp, lck, true,
-                        nt_tok,
-                        tok);
+                set_delete_on_close_lck(fsp, lck, nt_tok, tok);
         } else {
-                set_delete_on_close_lck(fsp, lck, false,
-                        NULL,
-                        NULL);
+                reset_delete_on_close_lck(fsp, lck);
         }
 
@@ -1641 +1217 @@
 }
 
+static struct delete_token *find_delete_on_close_token(
+        struct share_mode_data *d, uint32_t name_hash)
+{
+        uint32_t i;
+
+        DEBUG(10, ("find_delete_on_close_token: name_hash = 0x%x\n",
+                   (unsigned int)name_hash));
+
+        for (i=0; i<d->num_delete_tokens; i++) {
+                struct delete_token *dt = &d->delete_tokens[i];
+
+                DEBUG(10, ("find__delete_on_close_token: dt->name_hash = 0x%x\n",
+                           (unsigned int)dt->name_hash ));
+                if (dt->name_hash == name_hash) {
+                        return dt;
+                }
+        }
+        return NULL;
+}
+
 /****************************************************************************
  Return the NT token and UNIX token if there's a match. Return true if
@@ -1647 +1243 @@
 
 bool get_delete_on_close_token(struct share_mode_lock *lck,
-                                uint32_t name_hash,
-                                const struct security_token **pp_nt_tok,
-                                const struct security_unix_token **pp_tok)
-{
-        struct delete_token_list *dtl;
-
-        DEBUG(10,("get_delete_on_close_token: name_hash = 0x%x\n",
-                        (unsigned int)name_hash ));
-
-        for (dtl = lck->delete_tokens; dtl; dtl = dtl->next) {
-                DEBUG(10,("get_delete_on_close_token: dtl->name_hash = 0x%x\n",
-                                (unsigned int)dtl->name_hash ));
-                if (dtl->name_hash == name_hash) {
-                        if (pp_nt_tok) {
-                                *pp_nt_tok = dtl->delete_nt_token;
-                        }
-                        if (pp_tok) {
-                                *pp_tok =  dtl->delete_token;
-                        }
-                        return true;
-                }
-        }
-        return false;
+                                        uint32_t name_hash,
+                                        const struct security_token **pp_nt_tok,
+                                        const struct security_unix_token **pp_tok)
+{
+        struct delete_token *dt;
+
+        dt = find_delete_on_close_token(lck->data, name_hash);
+        if (dt == NULL) {
+                return false;
+        }
+        *pp_nt_tok = dt->delete_nt_token;
+        *pp_tok =  dt->delete_token;
+        return true;
 }
 
 bool is_delete_on_close_set(struct share_mode_lock *lck, uint32_t name_hash)
 {
-        return get_delete_on_close_token(lck, name_hash, NULL, NULL);
+        return find_delete_on_close_token(lck->data, name_hash) != NULL;
 }
 
@@ -1686 +1272 @@
                  file_id_string_tos(&fileid)));
 
-        lck = get_share_mode_lock(NULL, fileid, NULL, NULL, NULL);
+        lck = get_existing_share_mode_lock(talloc_tos(), fileid);
         if (lck == NULL) {
                 return False;
         }
 
-        if (timespec_compare(&lck->changed_write_time, &write_time) != 0) {
-                lck->modified = True;
-                lck->changed_write_time = write_time;
+        if (timespec_compare(&lck->data->changed_write_time, &write_time) != 0) {
+                lck->data->modified = True;
+                lck->data->changed_write_time = write_time;
         }
 
@@ -1709 +1295 @@
                  file_id_string_tos(&fileid)));
 
-        lck = get_share_mode_lock(NULL, fileid, NULL, NULL, NULL);
+        lck = get_existing_share_mode_lock(talloc_tos(), fileid);
         if (lck == NULL) {
                 return False;
         }
 
-        if (timespec_compare(&lck->old_write_time, &write_time) != 0) {
-                lck->modified = True;
-                lck->old_write_time = write_time;
+        if (timespec_compare(&lck->data->old_write_time, &write_time) != 0) {
+                lck->data->modified = True;
+                lck->data->old_write_time = write_time;
         }
 
@@ -1723 +1309 @@
 }
 
-
-struct forall_state {
-        void (*fn)(const struct share_mode_entry *entry,
-                   const char *sharepath,
-                   const char *fname,
-                   void *private_data);
-        void *private_data;
-};
-
-static int traverse_fn(struct db_record *rec, void *_state)
-{
-        struct forall_state *state = (struct forall_state *)_state;
-        int i;
-        struct share_mode_lock *lck;
-
-        /* Ensure this is a locking_key record. */
-        if (rec->key.dsize != sizeof(struct file_id))
-                return 0;
-
-        lck = TALLOC_ZERO_P(talloc_tos(), struct share_mode_lock);
-        if (lck == NULL) {
-                return 0;
-        }
-
-        if (!parse_share_modes(rec->value, lck)) {
-                TALLOC_FREE(lck);
-                DEBUG(1, ("parse_share_modes failed\n"));
-                return 0;
-        }
-
-        for (i=0; i<lck->num_share_modes; i++) {
-                struct share_mode_entry *se = &lck->share_modes[i];
-                state->fn(se,
-                        lck->servicepath,
-                        lck->base_name,
-                        state->private_data);
-        }
-        TALLOC_FREE(lck);
-        return 0;
-}
-
-/*******************************************************************
- Call the specified function on each entry under management by the
- share mode system.
-********************************************************************/
-
-int share_mode_forall(void (*fn)(const struct share_mode_entry *, const char *,
-                                 const char *, void *),
-                      void *private_data)
-{
-        struct forall_state state;
-
-        if (lock_db == NULL)
-                return 0;
-
-        state.fn = fn;
-        state.private_data = private_data;
-
-        return lock_db->traverse_read(lock_db, traverse_fn, (void *)&state);
-}
+struct timespec get_share_mode_write_time(struct share_mode_lock *lck)
+{
+        struct share_mode_data *d = lck->data;
+
+        if (!null_timespec(d->changed_write_time)) {
+                return d->changed_write_time;
+        }
+        return d->old_write_time;
+}

vendor/current/source3/locking/posix.c

@@ -25 +25 @@
 #include "system/filesys.h"
 #include "locking/proto.h"
-#include "dbwrap.h"
+#include "dbwrap/dbwrap.h"
+#include "dbwrap/dbwrap_rbt.h"
 #include "util_tdb.h"
 
@@ -83 +84 @@
 ****************************************************************************/
 
-static bool posix_lock_in_range(SMB_OFF_T *offset_out, SMB_OFF_T *count_out,
+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)
-
-        /*
-         * In this case SMB_OFF_T is 64 bits,
+        off_t max_positive_lock_offset = (MAX_POSITIVE_LOCK_OFFSET);
+#else
+        /*
+         * 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.
@@ -127 +115 @@
          */
 
-        if (count == (SMB_OFF_T)0) {
+        if (count == 0) {
                 DEBUG(10,("posix_lock_in_range: count = 0, ignoring.\n"));
                 return False;
@@ -138 +126 @@
 
         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)((uint64_t)max_positive_lock_offset) ));
+                DEBUG(10, ("posix_lock_in_range: (offset = %ju) offset > %ju "
+                           "and we cannot handle this. Ignoring lock.\n",
+                           (uintmax_t)u_offset,
+                           (uintmax_t)max_positive_lock_offset));
                 return False;
         }
@@ -164 +154 @@
 
         if (count == 0) {
-                DEBUG(10,("posix_lock_in_range: Count = 0. Ignoring lock u_offset = %.0f, u_count = %.0f\n",
-                                (double)u_offset, (double)u_count ));
+                DEBUG(10, ("posix_lock_in_range: Count = 0. Ignoring lock "
+                           "u_offset = %ju, u_count = %ju\n",
+                           (uintmax_t)u_offset,
+                           (uintmax_t)u_count));
                 return False;
         }
@@ -173 +165 @@
          */
 
-        DEBUG(10,("posix_lock_in_range: offset_out = %.0f, count_out = %.0f\n",
-                        (double)offset, (double)count ));
+        DEBUG(10, ("posix_lock_in_range: offset_out = %ju, "
+                   "count_out = %ju\n",
+                   (uintmax_t)offset, (uintmax_t)count));
 
         *offset_out = offset;
@@ -183 +176 @@
 
 bool smb_vfs_call_lock(struct vfs_handle_struct *handle,
-                       struct files_struct *fsp, int op, SMB_OFF_T offset,
-                       SMB_OFF_T count, int type)
+                       struct files_struct *fsp, int op, off_t offset,
+                       off_t count, int type)
 {
         VFS_FIND(lock);
-        return handle->fns->lock(handle, fsp, op, offset, count, type);
+        return handle->fns->lock_fn(handle, fsp, op, offset, count, type);
 }
 
@@ -195 +188 @@
 ****************************************************************************/
 
-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));
+        DEBUG(8,("posix_fcntl_lock %d %d %jd %jd %d\n",
+                 fsp->fh->fd,op,(intmax_t)offset,(intmax_t)count,type));
 
         ret = SMB_VFS_LOCK(fsp, op, offset, count, type);
@@ -205 +199 @@
         if (!ret && ((errno == EFBIG) || (errno == ENOLCK) || (errno ==  EINVAL))) {
 
-                DEBUG(0,("posix_fcntl_lock: WARNING: lock request at offset %.0f, length %.0f returned\n",
-                                        (double)offset,(double)count));
-                DEBUGADD(0,("an %s error. This can happen when using 64 bit lock offsets\n", strerror(errno)));
-                DEBUGADD(0,("on 32 bit NFS mounted file systems.\n"));
+                DEBUG(0, ("posix_fcntl_lock: WARNING: lock request at offset "
+                          "%ju, length %ju returned\n",
+                          (uintmax_t)offset, (uintmax_t)count));
+                DEBUGADD(0, ("an %s error. This can happen when using 64 bit "
+                             "lock offsets\n", strerror(errno)));
+                DEBUGADD(0, ("on 32 bit NFS mounted file systems.\n"));
 
                 /*
@@ -215 +211 @@
                  */
 
-                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"));
@@ -234 +230 @@
 
 bool smb_vfs_call_getlock(struct vfs_handle_struct *handle,
-                          struct files_struct *fsp, SMB_OFF_T *poffset,
-                          SMB_OFF_T *pcount, int *ptype, pid_t *ppid)
+                          struct files_struct *fsp, off_t *poffset,
+                          off_t *pcount, int *ptype, pid_t *ppid)
 {
         VFS_FIND(getlock);
-        return handle->fns->getlock(handle, fsp, poffset, pcount, ptype, ppid);
+        return handle->fns->getlock_fn(handle, fsp, poffset, pcount, ptype, 
+                                       ppid);
 }
 
@@ -246 +243 @@
 ****************************************************************************/
 
-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));
+        DEBUG(8, ("posix_fcntl_getlock %d %ju %ju %d\n",
+                  fsp->fh->fd, (uintmax_t)*poffset, (uintmax_t)*pcount,
+                  *ptype));
 
         ret = SMB_VFS_GETLOCK(fsp, poffset, pcount, ptype, &pid);
@@ -258 +256 @@
         if (!ret && ((errno == EFBIG) || (errno == ENOLCK) || (errno ==  EINVAL))) {
 
-                DEBUG(0,("posix_fcntl_getlock: WARNING: lock request at offset %.0f, length %.0f returned\n",
-                                        (double)*poffset,(double)*pcount));
-                DEBUGADD(0,("an %s error. This can happen when using 64 bit lock offsets\n", strerror(errno)));
-                DEBUGADD(0,("on 32 bit NFS mounted file systems.\n"));
+                DEBUG(0, ("posix_fcntl_getlock: WARNING: lock request at "
+                          "offset %ju, length %ju returned\n",
+                          (uintmax_t)*poffset, (uintmax_t)*pcount));
+                DEBUGADD(0, ("an %s error. This can happen when using 64 bit "
+                             "lock offsets\n", strerror(errno)));
+                DEBUGADD(0, ("on 32 bit NFS mounted file systems.\n"));
 
                 /*
@@ -268 +268 @@
                  */
 
-                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"));
@@ -297 +297 @@
                         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_str_dbg(fsp), (double)*pu_offset,
-                  (double)*pu_count,  posix_lock_type_name(*plock_type)));
+        DEBUG(10, ("is_posix_locked: File %s, offset = %ju, count = %ju, "
+                   "type = %s\n", fsp_str_dbg(fsp), (uintmax_t)*pu_offset,
+                   (uintmax_t)*pu_count,  posix_lock_type_name(*plock_type)));
 
         /*
@@ -362 +362 @@
 static TDB_DATA fd_array_key_fsp(files_struct *fsp)
 {
-        return make_tdb_data((uint8 *)&fsp->file_id, sizeof(fsp->file_id));
+        return make_tdb_data((uint8_t *)&fsp->file_id, sizeof(fsp->file_id));
 }
 
@@ -404 +404 @@
 
 /****************************************************************************
- The records in posix_pending_close_tdb are composed of an array of ints
- keyed by dev/ino pair.
- The first int is a reference count of the number of outstanding locks on
- all open fd's on this dev/ino pair. Any subsequent ints are the fd's that
- were open on this dev/ino pair that should have been closed, but can't as
- the lock ref count is non zero.
+ The records in posix_pending_close_db are composed of an array of
+ ints keyed by dev/ino pair. Those ints are the fd's that were open on
+ this dev/ino pair that should have been closed, but can't as the lock
+ ref count is non zero.
 ****************************************************************************/
 
@@ -420 +418 @@
 {
         struct lock_ref_count_key tmp;
-        struct db_record *rec;
-        int lock_ref_count = 0;
+        int32_t lock_ref_count = 0;
         NTSTATUS status;
 
-        rec = posix_pending_close_db->fetch_locked(
-                posix_pending_close_db, talloc_tos(),
-                locking_ref_count_key_fsp(fsp, &tmp));
-
-        SMB_ASSERT(rec != NULL);
-
-        if (rec->value.dptr != NULL) {
-                SMB_ASSERT(rec->value.dsize == sizeof(lock_ref_count));
-                memcpy(&lock_ref_count, rec->value.dptr,
-                       sizeof(lock_ref_count));
-        }
-
-        lock_ref_count++;
-
-        status = rec->store(rec, make_tdb_data((uint8 *)&lock_ref_count,
-                                               sizeof(lock_ref_count)), 0);
+        status = dbwrap_change_int32_atomic(
+                posix_pending_close_db, locking_ref_count_key_fsp(fsp, &tmp),
+                &lock_ref_count, 1);
 
         SMB_ASSERT(NT_STATUS_IS_OK(status));
-
-        TALLOC_FREE(rec);
+        SMB_ASSERT(lock_ref_count < INT32_MAX);
 
         DEBUG(10,("increment_windows_lock_ref_count for file now %s = %d\n",
-                  fsp_str_dbg(fsp), lock_ref_count));
+                  fsp_str_dbg(fsp), (int)lock_ref_count));
 }
 
@@ -453 +436 @@
 ****************************************************************************/
 
-void reduce_windows_lock_ref_count(files_struct *fsp, unsigned int dcount)
+static void decrement_windows_lock_ref_count(files_struct *fsp)
 {
         struct lock_ref_count_key tmp;
-        struct db_record *rec;
-        int lock_ref_count = 0;
+        int32_t lock_ref_count = 0;
         NTSTATUS status;
 
-        rec = posix_pending_close_db->fetch_locked(
-                posix_pending_close_db, talloc_tos(),
-                locking_ref_count_key_fsp(fsp, &tmp));
-
-        SMB_ASSERT((rec != NULL)
-                   && (rec->value.dptr != NULL)
-                   && (rec->value.dsize == sizeof(lock_ref_count)));
-
-        memcpy(&lock_ref_count, rec->value.dptr, sizeof(lock_ref_count));
-
-        SMB_ASSERT(lock_ref_count > 0);
-
-        lock_ref_count -= dcount;
-
-        status = rec->store(rec, make_tdb_data((uint8 *)&lock_ref_count,
-                                               sizeof(lock_ref_count)), 0);
+        status = dbwrap_change_int32_atomic(
+                posix_pending_close_db, locking_ref_count_key_fsp(fsp, &tmp),
+                &lock_ref_count, -1);
 
         SMB_ASSERT(NT_STATUS_IS_OK(status));
-
-        TALLOC_FREE(rec);
+        SMB_ASSERT(lock_ref_count >= 0);
 
         DEBUG(10,("reduce_windows_lock_ref_count for file now %s = %d\n",
-                  fsp_str_dbg(fsp), lock_ref_count));
-}
-
-static void decrement_windows_lock_ref_count(files_struct *fsp)
-{
-        reduce_windows_lock_ref_count(fsp, 1);
+                  fsp_str_dbg(fsp), (int)lock_ref_count));
 }
 
@@ -494 +457 @@
 ****************************************************************************/
 
-static int get_windows_lock_ref_count(files_struct *fsp)
+static int32_t get_windows_lock_ref_count(files_struct *fsp)
 {
         struct lock_ref_count_key tmp;
-        TDB_DATA dbuf;
-        int res;
-        int lock_ref_count = 0;
-
-        res = posix_pending_close_db->fetch(
-                posix_pending_close_db, talloc_tos(),
-                locking_ref_count_key_fsp(fsp, &tmp), &dbuf);
-
-        SMB_ASSERT(res == 0);
-
-        if (dbuf.dsize != 0) {
-                SMB_ASSERT(dbuf.dsize == sizeof(lock_ref_count));
-                memcpy(&lock_ref_count, dbuf.dptr, sizeof(lock_ref_count));
-                TALLOC_FREE(dbuf.dptr);
-        }
-
-        DEBUG(10,("get_windows_lock_count for file %s = %d\n",
-                  fsp_str_dbg(fsp), lock_ref_count));
-
+        NTSTATUS status;
+        int32_t lock_ref_count = 0;
+
+        status = dbwrap_fetch_int32(
+                posix_pending_close_db, locking_ref_count_key_fsp(fsp, &tmp),
+                &lock_ref_count);
+
+        if (!NT_STATUS_IS_OK(status) &&
+            !NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
+                DEBUG(0, ("get_windows_lock_ref_count: Error fetching "
+                          "lock ref count for file %s: %s\n",
+                          fsp_str_dbg(fsp), nt_errstr(status)));
+        }
         return lock_ref_count;
 }
@@ -526 +483 @@
 {
         struct lock_ref_count_key tmp;
-        struct db_record *rec;
-
-        rec = posix_pending_close_db->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. */
 
-        rec->delete_rec(rec);
-        TALLOC_FREE(rec);
+        dbwrap_delete(posix_pending_close_db,
+                      locking_ref_count_key_fsp(fsp, &tmp));
 
         DEBUG(10,("delete_windows_lock_ref_count for file %s\n",
@@ -550 +500 @@
 {
         struct db_record *rec;
-        uint8_t *new_data;
+        int *fds;
+        size_t num_fds;
         NTSTATUS status;
-
-        rec = posix_pending_close_db->fetch_locked(
+        TDB_DATA value;
+
+        rec = dbwrap_fetch_locked(
                 posix_pending_close_db, talloc_tos(),
                 fd_array_key_fsp(fsp));
@@ -559 +511 @@
         SMB_ASSERT(rec != NULL);
 
-        new_data = TALLOC_ARRAY(
-                rec, uint8_t, rec->value.dsize + sizeof(fsp->fh->fd));
-
-        SMB_ASSERT(new_data != NULL);
-
-        memcpy(new_data, rec->value.dptr, rec->value.dsize);
-        memcpy(new_data + rec->value.dsize,
-               &fsp->fh->fd, sizeof(fsp->fh->fd));
-
-        status = rec->store(
-                rec, make_tdb_data(new_data,
-                                   rec->value.dsize + sizeof(fsp->fh->fd)), 0);
+        value = dbwrap_record_get_value(rec);
+        SMB_ASSERT((value.dsize % sizeof(int)) == 0);
+
+        num_fds = value.dsize / sizeof(int);
+        fds = talloc_array(rec, int, num_fds+1);
+
+        SMB_ASSERT(fds != NULL);
+
+        memcpy(fds, value.dptr, value.dsize);
+        fds[num_fds] = fsp->fh->fd;
+
+        status = dbwrap_record_store(
+                rec, make_tdb_data((uint8_t *)fds, talloc_get_size(fds)), 0);
 
         SMB_ASSERT(NT_STATUS_IS_OK(status));
@@ -588 +541 @@
         struct db_record *rec;
 
-        rec = posix_pending_close_db->fetch_locked(
+        rec = dbwrap_fetch_locked(
                 posix_pending_close_db, talloc_tos(),
                 fd_array_key_fsp(fsp));
 
         SMB_ASSERT(rec != NULL);
-        rec->delete_rec(rec);
+        dbwrap_record_delete(rec);
         TALLOC_FREE(rec);
 }
@@ -606 +559 @@
 {
         TDB_DATA dbuf;
-        int res;
-
-        res = posix_pending_close_db->fetch(
+        NTSTATUS status;
+
+        status = dbwrap_fetch(
                 posix_pending_close_db, mem_ctx, fd_array_key_fsp(fsp),
                 &dbuf);
 
-        SMB_ASSERT(res == 0);
+        if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
+                *entries = NULL;
+                return 0;
+        }
+
+        SMB_ASSERT(NT_STATUS_IS_OK(status));
 
         if (dbuf.dsize == 0) {
@@ -716 +674 @@
         struct lock_list *next;
         struct lock_list *prev;
-        SMB_OFF_T start;
-        SMB_OFF_T size;
+        off_t start;
+        off_t size;
 };
 
@@ -729 +687 @@
                                                 struct lock_list *lhead,
                                                 const struct lock_context *lock_ctx, /* Lock context lhead belongs to. */
-                                                files_struct *fsp,
                                                 const struct lock_struct *plocks,
                                                 int num_locks)
@@ -740 +697 @@
          */
 
-        DEBUG(10,("posix_lock_list: curr: start=%.0f,size=%.0f\n",
-                (double)lhead->start, (double)lhead->size ));
+        DEBUG(10, ("posix_lock_list: curr: start=%ju,size=%ju\n",
+                   (uintmax_t)lhead->start, (uintmax_t)lhead->size ));
 
         for (i=0; i<num_locks && lhead; i++) {
@@ -753 +710 @@
 
                 /* Ignore locks not owned by this process. */
-                if (!procid_equal(&lock->context.pid, &lock_ctx->pid)) {
+                if (!serverid_equal(&lock->context.pid, &lock_ctx->pid)) {
                         continue;
                 }
@@ -765 +722 @@
                 for (l_curr = lhead; l_curr;) {
 
-                        DEBUG(10,("posix_lock_list: lock: fnum=%d: start=%.0f,size=%.0f:type=%s", lock->fnum,
-                                (double)lock->start, (double)lock->size, posix_lock_type_name(lock->lock_type) ));
+                        DEBUG(10, ("posix_lock_list: lock: fnum=%ju: "
+                                   "start=%ju,size=%ju:type=%s",
+                                   (uintmax_t)lock->fnum,
+                                   (uintmax_t)lock->start,
+                                   (uintmax_t)lock->size,
+                                   posix_lock_type_name(lock->lock_type) ));
 
                         if ( (l_curr->start >= (lock->start + lock->size)) ||
@@ -840 +801 @@
                                 l_curr->start = lock->start + lock->size;
 
-                                DEBUG(10,(" truncate high case: start=%.0f,size=%.0f\n",
-                                                                (double)l_curr->start, (double)l_curr->size ));
+                                DEBUG(10, (" truncate high case: start=%ju,"
+                                           "size=%ju\n",
+                                           (uintmax_t)l_curr->start,
+                                           (uintmax_t)l_curr->size ));
 
                                 l_curr = l_curr->next;
@@ -868 +831 @@
                                 l_curr->size = lock->start - l_curr->start;
 
-                                DEBUG(10,(" truncate low case: start=%.0f,size=%.0f\n",
-                                                                (double)l_curr->start, (double)l_curr->size ));
+                                DEBUG(10, (" truncate low case: start=%ju,"
+                                           "size=%ju\n",
+                                           (uintmax_t)l_curr->start,
+                                           (uintmax_t)l_curr->size ));
 
                                 l_curr = l_curr->next;
@@ -893 +858 @@
         +-------+         +---------+
 **********************************************/
-                                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) {
@@ -907 +872 @@
                                 l_curr->size = lock->start - l_curr->start;
 
-                                DEBUG(10,(" split case: curr: start=%.0f,size=%.0f \
-new: start=%.0f,size=%.0f\n", (double)l_curr->start, (double)l_curr->size,
-                                                                (double)l_new->start, (double)l_new->size ));
+                                DEBUG(10, (" split case: curr: start=%ju,"
+                                           "size=%ju new: start=%ju,"
+                                           "size=%ju\n",
+                                           (uintmax_t)l_curr->start,
+                                           (uintmax_t)l_curr->size,
+                                           (uintmax_t)l_new->start,
+                                           (uintmax_t)l_new->size ));
 
                                 /*
@@ -927 +896 @@
                                 char *msg = NULL;
 
-                                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) {
+                                if (asprintf(&msg, "logic flaw in cases: "
+                                             "l_curr: start = %ju, "
+                                             "size = %ju : lock: "
+                                             "start = %ju, size = %ju",
+                                             (uintmax_t)l_curr->start,
+                                             (uintmax_t)l_curr->size,
+                                             (uintmax_t)lock->start,
+                                             (uintmax_t)lock->size ) != -1) {
                                         smb_panic(msg);
                                 } else {
@@ -954 +929 @@
                         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;
@@ -963 +938 @@
         struct lock_list *ll = NULL;
 
-        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)));
+        DEBUG(5, ("set_posix_lock_windows_flavour: File %s, offset = %ju, "
+                  "count = %ju, type = %s\n", fsp_str_dbg(fsp),
+                  (uintmax_t)u_offset, (uintmax_t)u_count,
+                  posix_lock_type_name(lock_type)));
 
         /*
@@ -1001 +976 @@
         }
 
-        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);
@@ -1029 +1004 @@
                                 llist,
                                 lock_ctx, /* Lock context llist belongs to. */
-                                fsp,
                                 plocks,
                                 num_locks);
@@ -1043 +1017 @@
                 count = ll->size;
 
-                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)) {
+                DEBUG(5, ("set_posix_lock_windows_flavour: Real lock: "
+                          "Type = %s: offset = %ju, count = %ju\n",
+                          posix_lock_type_name(posix_lock_type),
+                          (uintmax_t)offset, (uintmax_t)count ));
+
+                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: Lock "
+                                  "fail !: Type = %s: offset = %ju, "
+                                  "count = %ju. Errno = %s\n",
+                                  posix_lock_type_name(posix_lock_type),
+                                  (uintmax_t)offset, (uintmax_t)count,
+                                  strerror(errno) ));
                         ret = False;
                         break;
@@ -1065 +1045 @@
                         count = ll->size;
 
-                        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);
+                        DEBUG(5, ("set_posix_lock_windows_flavour: Backing "
+                                  "out locks: Type = %s: offset = %ju, "
+                                  "count = %ju\n",
+                                  posix_lock_type_name(posix_lock_type),
+                                  (uintmax_t)offset, (uintmax_t)count ));
+
+                        posix_fcntl_lock(fsp,F_SETLK,offset,count,F_UNLCK);
                 }
         } else {
@@ -1092 +1075 @@
                                 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;
@@ -1099 +1082 @@
         struct lock_list *ul = NULL;
 
-        DEBUG(5,("release_posix_lock_windows_flavour: File %s, offset = %.0f, "
-                 "count = %.0f\n", fsp_str_dbg(fsp),
-                 (double)u_offset, (double)u_count));
+        DEBUG(5, ("release_posix_lock_windows_flavour: File %s, offset = %ju, "
+                  "count = %ju\n", fsp_str_dbg(fsp),
+                  (uintmax_t)u_offset, (uintmax_t)u_count));
 
         /* Remember the number of Windows locks we have on this dev/ino pair. */
@@ -1120 +1103 @@
         }
 
-        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);
@@ -1149 +1132 @@
                                 ulist,
                                 lock_ctx, /* Lock context ulist belongs to. */
-                                fsp,
                                 plocks,
                                 num_locks);
@@ -1164 +1146 @@
                         (!ulist || ulist->next != NULL || ulist->start != offset || ulist->size != count)) {
 
-                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)) {
+                DEBUG(5, ("release_posix_lock_windows_flavour: downgrading "
+                          "lock to READ: offset = %ju, count = %ju\n",
+                          (uintmax_t)offset, (uintmax_t)count ));
+
+                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);
@@ -1182 +1165 @@
                 count = ulist->size;
 
-                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)) {
+                DEBUG(5, ("release_posix_lock_windows_flavour: Real unlock: "
+                          "offset = %ju, count = %ju\n",
+                          (uintmax_t)offset, (uintmax_t)count ));
+
+                if (!posix_fcntl_lock(fsp,F_SETLK,offset,count,F_UNLCK)) {
                         ret = False;
                 }
@@ -1214 +1198 @@
                         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_str_dbg(fsp),
-                 (double)u_offset, (double)u_count,
+        DEBUG(5,("set_posix_lock_posix_flavour: File %s, offset = %ju, count "
+                 "= %ju, type = %s\n", fsp_str_dbg(fsp),
+                 (uintmax_t)u_offset, (uintmax_t)u_count,
                  posix_lock_type_name(lock_type)));
 
@@ -1232 +1216 @@
         }
 
-        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) ));
+                DEBUG(5,("set_posix_lock_posix_flavour: Lock fail !: Type = %s: offset = %ju, count = %ju. Errno = %s\n",
+                        posix_lock_type_name(posix_lock_type), (intmax_t)offset, (intmax_t)count, strerror(errno) ));
                 return False;
         }
@@ -1258 +1242 @@
 {
         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_str_dbg(fsp),
-                 (double)u_offset, (double)u_count));
+        DEBUG(5, ("release_posix_lock_posix_flavour: File %s, offset = %ju, "
+                  "count = %ju\n", fsp_str_dbg(fsp),
+                  (uintmax_t)u_offset, (uintmax_t)u_count));
 
         /*
@@ -1282 +1266 @@
         }
 
-        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);
@@ -1307 +1291 @@
                                 ulist,
                                 lock_ctx, /* Lock context ulist belongs to. */
-                                fsp,
                                 plocks,
                                 num_locks);
@@ -1319 +1302 @@
                 count = ulist->size;
 
-                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)) {
+                DEBUG(5, ("release_posix_lock_posix_flavour: Real unlock: "
+                          "offset = %ju, count = %ju\n",
+                          (uintmax_t)offset, (uintmax_t)count ));
+
+                if (!posix_fcntl_lock(fsp,F_SETLK,offset,count,F_UNLCK)) {
                         ret = False;
                 }

vendor/current/source3/locking/proto.h

@@ -26 +26 @@
 /* The following definitions come from locking/brlock.c  */
 
-bool brl_same_context(const struct lock_context *ctx1,
-                             const struct lock_context *ctx2);
-NTSTATUS brl_lock_failed(files_struct *fsp, const struct lock_struct *lock, bool blocking_lock);
 void brl_init(bool read_only);
 void brl_shutdown(void);
+
+unsigned int brl_num_locks(const struct byte_range_lock *brl);
+struct files_struct *brl_fsp(struct byte_range_lock *brl);
+uint32_t brl_num_read_oplocks(const struct byte_range_lock *brl);
+void brl_set_num_read_oplocks(struct byte_range_lock *brl,
+                              uint32_t num_read_oplocks);
 
 NTSTATUS brl_lock_windows_default(struct byte_range_lock *br_lck,
@@ -45 +48 @@
                 enum brl_flavour lock_flav,
                 bool blocking_lock,
-                uint64_t *psmblctx,
-                struct blocking_lock_record *blr);
+                uint64_t *psmblctx);
 bool brl_unlock(struct messaging_context *msg_ctx,
                 struct byte_range_lock *br_lck,
@@ -58 +60 @@
                                const struct lock_struct *plock);
 bool brl_locktest(struct byte_range_lock *br_lck,
-                uint64_t smblctx,
-                struct server_id pid,
-                br_off start,
-                br_off size,
-                enum brl_type lock_type,
-                enum brl_flavour lock_flav);
+                  const struct lock_struct *rw_probe);
 NTSTATUS brl_lockquery(struct byte_range_lock *br_lck,
                 uint64_t *psmblctx,
@@ -76 +73 @@
                 br_off start,
                 br_off size,
-                enum brl_flavour lock_flav,
-                struct blocking_lock_record *blr);
+                enum brl_flavour lock_flav);
 bool brl_lock_cancel_default(struct byte_range_lock *br_lck,
                 struct lock_struct *plock);
+bool brl_mark_disconnected(struct files_struct *fsp);
+bool brl_reconnect_disconnected(struct files_struct *fsp);
 void brl_close_fnum(struct messaging_context *msg_ctx,
                     struct byte_range_lock *br_lck);
@@ -91 +89 @@
                                         files_struct *fsp);
 struct byte_range_lock *brl_get_locks_readonly(files_struct *fsp);
-void brl_register_msgs(struct messaging_context *msg_ctx);
+void brl_revalidate(struct messaging_context *msg_ctx,
+                    void *private_data,
+                    uint32_t msg_type,
+                    struct server_id server_id,
+                    DATA_BLOB *data);
+bool brl_cleanup_disconnected(struct file_id fid, uint64_t open_persistent_id);
 
 /* The following definitions come from locking/locking.c  */
@@ -122 +125 @@
                         bool blocking_lock,
                         NTSTATUS *perr,
-                        uint64_t *psmblctx,
-                        struct blocking_lock_record *blr);
+                        uint64_t *psmblctx);
 NTSTATUS do_unlock(struct messaging_context *msg_ctx,
                         files_struct *fsp,
@@ -131 +133 @@
                         enum brl_flavour lock_flav);
 NTSTATUS do_lock_cancel(files_struct *fsp,
-                        uint64 smblctx,
+                        uint64_t smblctx,
                         uint64_t count,
                         uint64_t offset,
-                        enum brl_flavour lock_flav,
-                        struct blocking_lock_record *blr);
+                        enum brl_flavour lock_flav);
 void locking_close_file(struct messaging_context *msg_ctx,
                         files_struct *fsp,
@@ -143 +144 @@
 bool locking_end(void);
 char *share_mode_str(TALLOC_CTX *ctx, int num, const struct share_mode_entry *e);
-struct share_mode_lock *get_share_mode_lock(TALLOC_CTX *mem_ctx,
-                                            const struct file_id id,
-                                            const char *servicepath,
-                                            const struct smb_filename *smb_fname,
-                                            const struct timespec *old_write_time);
+struct share_mode_lock *get_existing_share_mode_lock(TALLOC_CTX *mem_ctx,
+                                                     struct file_id id);
+struct share_mode_lock *get_share_mode_lock(
+        TALLOC_CTX *mem_ctx,
+        struct file_id id,
+        const char *servicepath,
+        const struct smb_filename *smb_fname,
+        const struct timespec *old_write_time);
 struct share_mode_lock *fetch_share_mode_unlocked(TALLOC_CTX *mem_ctx,
-                                                  const struct file_id id);
+                                                  struct file_id id);
 bool rename_share_filename(struct messaging_context *msg_ctx,
                         struct share_mode_lock *lck,
+                        struct file_id id,
                         const char *servicepath,
                         uint32_t orig_name_hash,
@@ -161 +166 @@
                     struct timespec *write_time);
 bool is_valid_share_mode_entry(const struct share_mode_entry *e);
-bool is_deferred_open_entry(const struct share_mode_entry *e);
-bool is_unused_share_mode_entry(const struct share_mode_entry *e);
-void set_share_mode(struct share_mode_lock *lck, files_struct *fsp,
-                    uid_t uid, uint64_t mid, uint16 op_type);
-void add_deferred_open(struct share_mode_lock *lck, uint64_t mid,
-                       struct timeval request_time,
-                       struct server_id pid, struct file_id id);
+bool share_mode_stale_pid(struct share_mode_data *d, uint32_t idx);
+bool set_share_mode(struct share_mode_lock *lck, struct files_struct *fsp,
+                    uid_t uid, uint64_t mid, uint16_t op_type,
+                    uint32_t lease_idx);
+void remove_stale_share_mode_entries(struct share_mode_data *d);
 bool del_share_mode(struct share_mode_lock *lck, files_struct *fsp);
-void del_deferred_open_entry(struct share_mode_lock *lck, uint64_t mid,
-                             struct server_id pid);
+bool mark_share_mode_disconnected(struct share_mode_lock *lck,
+                                  struct files_struct *fsp);
 bool remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp);
 bool downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp);
-NTSTATUS can_set_delete_on_close(files_struct *fsp, uint32 dosmode);
+struct share_mode_lease;
+NTSTATUS downgrade_share_lease(struct smbd_server_connection *sconn,
+                               struct share_mode_lock *lck,
+                               const struct smb2_lease_key *key,
+                               uint32_t new_lease_state,
+                               struct share_mode_lease **_l);
 bool get_delete_on_close_token(struct share_mode_lock *lck,
-                        uint32_t name_hash,
-                        const struct security_token **pp_nt_tok,
-                        const struct security_unix_token **pp_tok);
+                                uint32_t name_hash,
+                                const struct security_token **pp_nt_tok,
+                                const struct security_unix_token **pp_tok);
+void reset_delete_on_close_lck(files_struct *fsp,
+                               struct share_mode_lock *lck);
 void set_delete_on_close_lck(files_struct *fsp,
                         struct share_mode_lock *lck,
-                        bool delete_on_close,
                         const struct security_token *nt_tok,
                         const struct security_unix_token *tok);
@@ -189 +198 @@
 bool set_sticky_write_time(struct file_id fileid, struct timespec write_time);
 bool set_write_time(struct file_id fileid, struct timespec write_time);
-int share_mode_forall(void (*fn)(const struct share_mode_entry *, const char *,
+struct timespec get_share_mode_write_time(struct share_mode_lock *lck);
+int share_mode_forall(int (*fn)(struct file_id fid,
+                                const struct share_mode_data *data,
+                                void *private_data),
+                      void *private_data);
+int share_entry_forall(int (*fn)(const struct share_mode_entry *,
+                                 const char *, const char *,
                                  const char *, void *),
                       void *private_data);
+bool share_mode_cleanup_disconnected(struct file_id id,
+                                     uint64_t open_persistent_id);
+
 
 /* The following definitions come from locking/posix.c  */
@@ -202 +220 @@
 bool posix_locking_init(bool read_only);
 bool posix_locking_end(void);
-void reduce_windows_lock_ref_count(files_struct *fsp, unsigned int dcount);
 int fd_close_posix(struct files_struct *fsp);
 bool set_posix_lock_windows_flavour(files_struct *fsp,