Changeset 745 for trunk/server/source3/smbd/smb2_lock.c

Timestamp:

Nov 27, 2012, 4:43:17 PM (13 years ago)

Author:

Silvan Scherrer

Message:

Samba Server: updated trunk to 3.6.0

Location:

trunk/server

Files:

• . (modified) (1 prop)
• source3/smbd/smb2_lock.c (modified) (19 diffs)

trunk/server/source3/smbd/smb2_lock.c

@@ -4 +4 @@
 
    Copyright (C) Stefan Metzmacher 2009
+   Copyright (C) Jeremy Allison 2010
 
    This program is free software; you can redistribute it and/or modify
@@ -20 +21 @@
 
 #include "includes.h"
+#include "smbd/smbd.h"
 #include "smbd/globals.h"
 #include "../libcli/smb/smb_common.h"
+#include "../lib/util/tevent_ntstatus.h"
+#include "messages.h"
 
 struct smbd_smb2_lock_element {
@@ -28 +32 @@
         uint32_t flags;
 };
+
+struct smbd_smb2_lock_state {
+        struct smbd_smb2_request *smb2req;
+        struct smb_request *smb1req;
+        struct blocking_lock_record *blr;
+        uint16_t lock_count;
+        struct smbd_lock_element *locks;
+};
+
+static void remove_pending_lock(struct smbd_smb2_lock_state *state,
+                                struct blocking_lock_record *blr);
 
 static struct tevent_req *smbd_smb2_lock_send(TALLOC_CTX *mem_ctx,
@@ -84 +99 @@
         if (req->compat_chain_fsp) {
                 /* skip check */
-        } else if (in_file_id_persistent != 0) {
+        } else if (in_file_id_persistent != in_file_id_volatile) {
                 return smbd_smb2_request_error(req, NT_STATUS_FILE_CLOSED);
         }
@@ -130 +145 @@
 static void smbd_smb2_request_lock_done(struct tevent_req *subreq)
 {
-        struct smbd_smb2_request *req = tevent_req_callback_data(subreq,
+        struct smbd_smb2_request *smb2req = tevent_req_callback_data(subreq,
                                         struct smbd_smb2_request);
         DATA_BLOB outbody;
@@ -136 +151 @@
         NTSTATUS error; /* transport error */
 
+        if (smb2req->cancelled) {
+                const uint8_t *inhdr = (const uint8_t *)
+                        smb2req->in.vector[smb2req->current_idx].iov_base;
+                uint64_t mid = BVAL(inhdr, SMB2_HDR_MESSAGE_ID);
+                struct smbd_smb2_lock_state *state;
+
+                DEBUG(10,("smbd_smb2_request_lock_done: cancelled mid %llu\n",
+                        (unsigned long long)mid ));
+
+                state = tevent_req_data(smb2req->subreq,
+                                struct smbd_smb2_lock_state);
+
+                SMB_ASSERT(state);
+                SMB_ASSERT(state->blr);
+
+                remove_pending_lock(state, state->blr);
+
+                error = smbd_smb2_request_error(smb2req, NT_STATUS_CANCELLED);
+                if (!NT_STATUS_IS_OK(error)) {
+                        smbd_server_connection_terminate(smb2req->sconn,
+                                nt_errstr(error));
+                        return;
+                }
+                return;
+        }
+
         status = smbd_smb2_lock_recv(subreq);
         TALLOC_FREE(subreq);
         if (!NT_STATUS_IS_OK(status)) {
-                error = smbd_smb2_request_error(req, status);
+                error = smbd_smb2_request_error(smb2req, status);
                 if (!NT_STATUS_IS_OK(error)) {
-                        smbd_server_connection_terminate(req->sconn,
+                        smbd_server_connection_terminate(smb2req->sconn,
                                                          nt_errstr(error));
                         return;
@@ -148 +189 @@
         }
 
-        outbody = data_blob_talloc(req->out.vector, NULL, 0x04);
+        outbody = data_blob_talloc(smb2req->out.vector, NULL, 0x04);
         if (outbody.data == NULL) {
-                error = smbd_smb2_request_error(req, NT_STATUS_NO_MEMORY);
+                error = smbd_smb2_request_error(smb2req, NT_STATUS_NO_MEMORY);
                 if (!NT_STATUS_IS_OK(error)) {
-                        smbd_server_connection_terminate(req->sconn,
+                        smbd_server_connection_terminate(smb2req->sconn,
                                                          nt_errstr(error));
                         return;
@@ -162 +203 @@
         SSVAL(outbody.data, 0x02, 0);           /* reserved */
 
-        error = smbd_smb2_request_done(req, outbody, NULL);
+        error = smbd_smb2_request_done(smb2req, outbody, NULL);
         if (!NT_STATUS_IS_OK(error)) {
-                smbd_server_connection_terminate(req->sconn,
+                smbd_server_connection_terminate(smb2req->sconn,
                                                  nt_errstr(error));
                 return;
         }
 }
-
-struct smbd_smb2_lock_state {
-        struct smbd_smb2_request *smb2req;
-};
 
 static struct tevent_req *smbd_smb2_lock_send(TALLOC_CTX *mem_ctx,
@@ -184 +221 @@
         struct tevent_req *req;
         struct smbd_smb2_lock_state *state;
-        struct smb_request *smbreq;
+        struct smb_request *smb1req;
         connection_struct *conn = smb2req->tcon->compat_conn;
         files_struct *fsp;
@@ -195 +232 @@
 
         req = tevent_req_create(mem_ctx, &state,
-                                struct smbd_smb2_lock_state);
+                        struct smbd_smb2_lock_state);
         if (req == NULL) {
                 return NULL;
         }
         state->smb2req = smb2req;
+        smb2req->subreq = req; /* So we can find this when going async. */
+
+        smb1req = smbd_smb2_fake_smb_request(smb2req);
+        if (tevent_req_nomem(smb1req, req)) {
+                return tevent_req_post(req, ev);
+        }
+        state->smb1req = smb1req;
 
         DEBUG(10,("smbd_smb2_lock_send: file_id[0x%016llX]\n",
                   (unsigned long long)in_file_id_volatile));
 
-        smbreq = smbd_smb2_fake_smb_request(smb2req);
-        if (tevent_req_nomem(smbreq, req)) {
-                return tevent_req_post(req, ev);
-        }
-
-        fsp = file_fsp(smbreq, (uint16_t)in_file_id_volatile);
+        fsp = file_fsp(smb1req, (uint16_t)in_file_id_volatile);
         if (fsp == NULL) {
                 tevent_req_nterror(req, NT_STATUS_FILE_CLOSED);
@@ -257 +296 @@
 
         for (i=0; i<in_lock_count; i++) {
-                uint64_t max_count;
                 bool invalid = false;
 
@@ -263 +301 @@
                 case SMB2_LOCK_FLAG_SHARED:
                 case SMB2_LOCK_FLAG_EXCLUSIVE:
+                        if (isunlock) {
+                                invalid = true;
+                                break;
+                        }
                         if (i > 0) {
                                 tevent_req_nterror(req,
@@ -268 +310 @@
                                 return tevent_req_post(req, ev);
                         }
-                        if (isunlock) {
-                                tevent_req_nterror(req,
-                                                   NT_STATUS_INVALID_PARAMETER);
-                                return tevent_req_post(req, ev);
-                        }
                         break;
 
@@ -278 +315 @@
                 case SMB2_LOCK_FLAG_EXCLUSIVE|SMB2_LOCK_FLAG_FAIL_IMMEDIATELY:
                         if (isunlock) {
-                                tevent_req_nterror(req,
-                                                   NT_STATUS_INVALID_PARAMETER);
-                                return tevent_req_post(req, ev);
+                                invalid = true;
                         }
                         break;
@@ -307 +342 @@
                 }
 
-                locks[i].smbpid = in_smbpid;
+                locks[i].smblctx = in_file_id_volatile;
                 locks[i].offset = in_locks[i].offset;
                 locks[i].count  = in_locks[i].length;
@@ -327 +362 @@
                 }
 
-                max_count = UINT64_MAX - locks[i].offset;
-                if (locks[i].count > max_count) {
-                        tevent_req_nterror(req, NT_STATUS_INVALID_LOCK_RANGE);
-                        return tevent_req_post(req, ev);
-                }
-        }
+                DEBUG(10,("smbd_smb2_lock_send: index %d offset=%llu, count=%llu, "
+                        "smblctx = %llu type %d\n",
+                        i,
+                        (unsigned long long)locks[i].offset,
+                        (unsigned long long)locks[i].count,
+                        (unsigned long long)locks[i].smblctx,
+                        (int)locks[i].brltype ));
+        }
+
+        state->locks = locks;
+        state->lock_count = in_lock_count;
 
         if (isunlock) {
-                status = smbd_do_locking(smbreq, fsp,
+                status = smbd_do_locking(smb1req, fsp,
                                          0,
                                          timeout,
@@ -344 +384 @@
                                          &async);
         } else {
-                status = smbd_do_locking(smbreq, fsp,
+                status = smbd_do_locking(smb1req, fsp,
                                          0,
                                          timeout,
@@ -362 +402 @@
 
         if (async) {
-                tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
-                return tevent_req_post(req, ev);
+                return req;
         }
 
@@ -382 +421 @@
         return NT_STATUS_OK;
 }
+
+/****************************************************************
+ Cancel an outstanding blocking lock request.
+*****************************************************************/
+
+static bool smbd_smb2_lock_cancel(struct tevent_req *req)
+{
+        struct smbd_smb2_request *smb2req = NULL;
+        struct smbd_smb2_lock_state *state = tevent_req_data(req,
+                                struct smbd_smb2_lock_state);
+        if (!state) {
+                return false;
+        }
+
+        if (!state->smb2req) {
+                return false;
+        }
+
+        smb2req = state->smb2req;
+        smb2req->cancelled = true;
+
+        tevent_req_done(req);
+        return true;
+}
+
+/****************************************************************
+ Got a message saying someone unlocked a file. Re-schedule all
+ blocking lock requests as we don't know if anything overlapped.
+*****************************************************************/
+
+static void received_unlock_msg(struct messaging_context *msg,
+                                void *private_data,
+                                uint32_t msg_type,
+                                struct server_id server_id,
+                                DATA_BLOB *data)
+{
+        struct smbd_server_connection *sconn;
+
+        DEBUG(10,("received_unlock_msg (SMB2)\n"));
+
+        sconn = msg_ctx_to_sconn(msg);
+        if (sconn == NULL) {
+                DEBUG(1, ("could not find sconn\n"));
+                return;
+        }
+        process_blocking_lock_queue_smb2(sconn, timeval_current());
+}
+
+/****************************************************************
+ Function to get the blr on a pending record.
+*****************************************************************/
+
+struct blocking_lock_record *get_pending_smb2req_blr(struct smbd_smb2_request *smb2req)
+{
+        struct smbd_smb2_lock_state *state = NULL;
+        const uint8_t *inhdr;
+
+        if (!smb2req) {
+                return NULL;
+        }
+        if (smb2req->subreq == NULL) {
+                return NULL;
+        }
+        if (!tevent_req_is_in_progress(smb2req->subreq)) {
+                return NULL;
+        }
+        inhdr = (const uint8_t *)smb2req->in.vector[smb2req->current_idx].iov_base;
+        if (SVAL(inhdr, SMB2_HDR_OPCODE) != SMB2_OP_LOCK) {
+                return NULL;
+        }
+        state = tevent_req_data(smb2req->subreq,
+                        struct smbd_smb2_lock_state);
+        if (!state) {
+                return NULL;
+        }
+        return state->blr;
+}
+/****************************************************************
+ Set up the next brl timeout.
+*****************************************************************/
+
+static bool recalc_smb2_brl_timeout(struct smbd_server_connection *sconn)
+{
+        struct smbd_smb2_request *smb2req;
+        struct timeval next_timeout = timeval_zero();
+        int max_brl_timeout = lp_parm_int(-1, "brl", "recalctime", 5);
+
+        TALLOC_FREE(sconn->smb2.locks.brl_timeout);
+
+        for (smb2req = sconn->smb2.requests; smb2req; smb2req = smb2req->next) {
+                struct blocking_lock_record *blr =
+                        get_pending_smb2req_blr(smb2req);
+                if (!blr) {
+                        continue;
+                }
+                if (timeval_is_zero(&blr->expire_time)) {
+                        /*
+                         * If we're blocked on pid 0xFFFFFFFFFFFFFFFFLL this is
+                         * a POSIX lock, so calculate a timeout of
+                         * 10 seconds into the future.
+                         */
+                        if (blr->blocking_smblctx == 0xFFFFFFFFFFFFFFFFLL) {
+                                struct timeval psx_to = timeval_current_ofs(10, 0);
+                                next_timeout = timeval_brl_min(&next_timeout, &psx_to);
+                        }
+
+                        continue;
+                }
+
+                next_timeout = timeval_brl_min(&next_timeout, &blr->expire_time);
+        }
+
+        if (timeval_is_zero(&next_timeout)) {
+                DEBUG(10, ("recalc_smb2_brl_timeout:Next "
+                        "timeout = Infinite.\n"));
+                return true;
+        }
+
+        /*
+         * To account for unclean shutdowns by clients we need a
+         * maximum timeout that we use for checking pending locks. If
+         * we have any pending locks at all, then check if the pending
+         * lock can continue at least every brl:recalctime seconds
+         * (default 5 seconds).
+         *
+         * This saves us needing to do a message_send_all() in the
+         * SIGCHLD handler in the parent daemon. That
+         * message_send_all() caused O(n^2) work to be done when IP
+         * failovers happened in clustered Samba, which could make the
+         * entire system unusable for many minutes.
+         */
+
+        if (max_brl_timeout > 0) {
+                struct timeval min_to = timeval_current_ofs(max_brl_timeout, 0);
+                next_timeout = timeval_brl_min(&next_timeout, &min_to);
+        }
+
+        if (DEBUGLVL(10)) {
+                struct timeval cur, from_now;
+
+                cur = timeval_current();
+                from_now = timeval_until(&cur, &next_timeout);
+                DEBUG(10, ("recalc_smb2_brl_timeout: Next "
+                        "timeout = %d.%d seconds from now.\n",
+                        (int)from_now.tv_sec, (int)from_now.tv_usec));
+        }
+
+        sconn->smb2.locks.brl_timeout = event_add_timed(
+                                smbd_event_context(),
+                                NULL,
+                                next_timeout,
+                                brl_timeout_fn,
+                                NULL);
+        if (!sconn->smb2.locks.brl_timeout) {
+                return false;
+        }
+        return true;
+}
+
+/****************************************************************
+ Get an SMB2 lock reqeust to go async. lock_timeout should
+ always be -1 here.
+*****************************************************************/
+
+bool push_blocking_lock_request_smb2( struct byte_range_lock *br_lck,
+                                struct smb_request *smb1req,
+                                files_struct *fsp,
+                                int lock_timeout,
+                                int lock_num,
+                                uint64_t smblctx,
+                                enum brl_type lock_type,
+                                enum brl_flavour lock_flav,
+                                uint64_t offset,
+                                uint64_t count,
+                                uint64_t blocking_smblctx)
+{
+        struct smbd_server_connection *sconn = smb1req->sconn;
+        struct smbd_smb2_request *smb2req = smb1req->smb2req;
+        struct tevent_req *req = NULL;
+        struct smbd_smb2_lock_state *state = NULL;
+        struct blocking_lock_record *blr = NULL;
+        NTSTATUS status = NT_STATUS_OK;
+
+        if (!smb2req) {
+                return false;
+        }
+        req = smb2req->subreq;
+        if (!req) {
+                return false;
+        }
+        if (!tevent_req_is_in_progress(smb2req->subreq)) {
+                return false;
+        }
+        state = tevent_req_data(req, struct smbd_smb2_lock_state);
+        if (!state) {
+                return false;
+        }
+
+        blr = talloc_zero(state, struct blocking_lock_record);
+        if (!blr) {
+                return false;
+        }
+        blr->fsp = fsp;
+
+        if (lock_timeout == -1) {
+                blr->expire_time.tv_sec = 0;
+                blr->expire_time.tv_usec = 0; /* Never expire. */
+        } else {
+                blr->expire_time = timeval_current_ofs(
+                        lock_timeout/1000,
+                        (lock_timeout % 1000) * 1000);
+        }
+
+        blr->lock_num = lock_num;
+        blr->smblctx = smblctx;
+        blr->blocking_smblctx = blocking_smblctx;
+        blr->lock_flav = lock_flav;
+        blr->lock_type = lock_type;
+        blr->offset = offset;
+        blr->count = count;
+
+        /* Specific brl_lock() implementations can fill this in. */
+        blr->blr_private = NULL;
+
+        /* Add a pending lock record for this. */
+        status = brl_lock(sconn->msg_ctx,
+                        br_lck,
+                        smblctx,
+                        sconn_server_id(sconn),
+                        offset,
+                        count,
+                        lock_type == READ_LOCK ? PENDING_READ_LOCK : PENDING_WRITE_LOCK,
+                        blr->lock_flav,
+                        true,
+                        NULL,
+                        blr);
+
+        if (!NT_STATUS_IS_OK(status)) {
+                DEBUG(0,("push_blocking_lock_request_smb2: "
+                        "failed to add PENDING_LOCK record.\n"));
+                TALLOC_FREE(blr);
+                return false;
+        }
+        state->blr = blr;
+
+        DEBUG(10,("push_blocking_lock_request_smb2: file %s timeout %d\n",
+                fsp_str_dbg(fsp),
+                lock_timeout ));
+
+        recalc_smb2_brl_timeout(sconn);
+
+        /* Ensure we'll receive messages when this is unlocked. */
+        if (!sconn->smb2.locks.blocking_lock_unlock_state) {
+                messaging_register(sconn->msg_ctx, NULL,
+                                MSG_SMB_UNLOCK, received_unlock_msg);
+                sconn->smb2.locks.blocking_lock_unlock_state = true;
+        }
+
+        /* allow this request to be canceled */
+        tevent_req_set_cancel_fn(req, smbd_smb2_lock_cancel);
+
+        return true;
+}
+
+/****************************************************************
+ Remove a pending lock record under lock.
+*****************************************************************/
+
+static void remove_pending_lock(struct smbd_smb2_lock_state *state,
+                        struct blocking_lock_record *blr)
+{
+        int i;
+        struct byte_range_lock *br_lck = brl_get_locks(
+                                state, blr->fsp);
+
+        DEBUG(10, ("remove_pending_lock: BLR = %p\n", blr));
+
+        if (br_lck) {
+                brl_lock_cancel(br_lck,
+                                blr->smblctx,
+                                sconn_server_id(blr->fsp->conn->sconn),
+                                blr->offset,
+                                blr->count,
+                                blr->lock_flav,
+                                blr);
+                TALLOC_FREE(br_lck);
+        }
+
+        /* Remove the locks we already got. */
+
+        for(i = blr->lock_num - 1; i >= 0; i--) {
+                struct smbd_lock_element *e = &state->locks[i];
+
+                do_unlock(blr->fsp->conn->sconn->msg_ctx,
+                        blr->fsp,
+                        e->smblctx,
+                        e->count,
+                        e->offset,
+                        WINDOWS_LOCK);
+        }
+}
+
+/****************************************************************
+ Re-proccess a blocking lock request.
+ This is equivalent to process_lockingX() inside smbd/blocking.c
+*****************************************************************/
+
+static void reprocess_blocked_smb2_lock(struct smbd_smb2_request *smb2req,
+                                struct timeval tv_curr)
+{
+        NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
+        struct blocking_lock_record *blr = NULL;
+        struct smbd_smb2_lock_state *state = NULL;
+        files_struct *fsp = NULL;
+
+        if (!smb2req->subreq) {
+                return;
+        }
+        state = tevent_req_data(smb2req->subreq, struct smbd_smb2_lock_state);
+        if (!state) {
+                return;
+        }
+
+        blr = state->blr;
+        fsp = blr->fsp;
+
+        /* Try and finish off getting all the outstanding locks. */
+
+        for (; blr->lock_num < state->lock_count; blr->lock_num++) {
+                struct byte_range_lock *br_lck = NULL;
+                struct smbd_lock_element *e = &state->locks[blr->lock_num];
+
+                br_lck = do_lock(fsp->conn->sconn->msg_ctx,
+                                fsp,
+                                e->smblctx,
+                                e->count,
+                                e->offset,
+                                e->brltype,
+                                WINDOWS_LOCK,
+                                true,
+                                &status,
+                                &blr->blocking_smblctx,
+                                blr);
+
+                TALLOC_FREE(br_lck);
+
+                if (NT_STATUS_IS_ERR(status)) {
+                        break;
+                }
+        }
+
+        if(blr->lock_num == state->lock_count) {
+                /*
+                 * Success - we got all the locks.
+                 */
+
+                DEBUG(3,("reprocess_blocked_smb2_lock SUCCESS file = %s, "
+                        "fnum=%d num_locks=%d\n",
+                        fsp_str_dbg(fsp),
+                        fsp->fnum,
+                        (int)state->lock_count));
+
+                tevent_req_done(smb2req->subreq);
+                return;
+        }
+
+        if (!NT_STATUS_EQUAL(status,NT_STATUS_LOCK_NOT_GRANTED) &&
+                        !NT_STATUS_EQUAL(status,NT_STATUS_FILE_LOCK_CONFLICT)) {
+                /*
+                 * We have other than a "can't get lock"
+                 * error. Return an error.
+                 */
+                remove_pending_lock(state, blr);
+                tevent_req_nterror(smb2req->subreq, status);
+                return;
+        }
+
+        /*
+         * We couldn't get the locks for this record on the list.
+         * If the time has expired, return a lock error.
+         */
+
+        if (!timeval_is_zero(&blr->expire_time) &&
+                        timeval_compare(&blr->expire_time, &tv_curr) <= 0) {
+                remove_pending_lock(state, blr);
+                tevent_req_nterror(smb2req->subreq, NT_STATUS_LOCK_NOT_GRANTED);
+                return;
+        }
+
+        /*
+         * Still can't get all the locks - keep waiting.
+         */
+
+        DEBUG(10,("reprocess_blocked_smb2_lock: only got %d locks of %d needed "
+                "for file %s, fnum = %d. Still waiting....\n",
+                (int)blr->lock_num,
+                (int)state->lock_count,
+                fsp_str_dbg(fsp),
+                (int)fsp->fnum));
+
+        return;
+
+}
+
+/****************************************************************
+ Attempt to proccess all outstanding blocking locks pending on
+ the request queue.
+*****************************************************************/
+
+void process_blocking_lock_queue_smb2(
+        struct smbd_server_connection *sconn, struct timeval tv_curr)
+{
+        struct smbd_smb2_request *smb2req, *nextreq;
+
+        for (smb2req = sconn->smb2.requests; smb2req; smb2req = nextreq) {
+                const uint8_t *inhdr;
+
+                nextreq = smb2req->next;
+
+                if (smb2req->subreq == NULL) {
+                        /* This message has been processed. */
+                        continue;
+                }
+                if (!tevent_req_is_in_progress(smb2req->subreq)) {
+                        /* This message has been processed. */
+                        continue;
+                }
+
+                inhdr = (const uint8_t *)smb2req->in.vector[smb2req->current_idx].iov_base;
+                if (SVAL(inhdr, SMB2_HDR_OPCODE) == SMB2_OP_LOCK) {
+                        reprocess_blocked_smb2_lock(smb2req, tv_curr);
+                }
+        }
+
+        recalc_smb2_brl_timeout(sconn);
+}
+
+/****************************************************************************
+ Remove any locks on this fd. Called from file_close().
+****************************************************************************/
+
+void cancel_pending_lock_requests_by_fid_smb2(files_struct *fsp,
+                        struct byte_range_lock *br_lck,
+                        enum file_close_type close_type)
+{
+        struct smbd_server_connection *sconn = fsp->conn->sconn;
+        struct smbd_smb2_request *smb2req, *nextreq;
+
+        for (smb2req = sconn->smb2.requests; smb2req; smb2req = nextreq) {
+                struct smbd_smb2_lock_state *state = NULL;
+                files_struct *fsp_curr = NULL;
+                int i = smb2req->current_idx;
+                uint64_t in_file_id_volatile;
+                struct blocking_lock_record *blr = NULL;
+                const uint8_t *inhdr;
+                const uint8_t *inbody;
+
+                nextreq = smb2req->next;
+
+                if (smb2req->subreq == NULL) {
+                        /* This message has been processed. */
+                        continue;
+                }
+                if (!tevent_req_is_in_progress(smb2req->subreq)) {
+                        /* This message has been processed. */
+                        continue;
+                }
+
+                inhdr = (const uint8_t *)smb2req->in.vector[i].iov_base;
+                if (SVAL(inhdr, SMB2_HDR_OPCODE) != SMB2_OP_LOCK) {
+                        /* Not a lock call. */
+                        continue;
+                }
+
+                inbody = (const uint8_t *)smb2req->in.vector[i+1].iov_base;
+                in_file_id_volatile = BVAL(inbody, 0x10);
+
+                state = tevent_req_data(smb2req->subreq,
+                                struct smbd_smb2_lock_state);
+                if (!state) {
+                        /* Strange - is this even possible ? */
+                        continue;
+                }
+
+                fsp_curr = file_fsp(state->smb1req, (uint16_t)in_file_id_volatile);
+                if (fsp_curr == NULL) {
+                        /* Strange - is this even possible ? */
+                        continue;
+                }
+
+                if (fsp_curr != fsp) {
+                        /* It's not our fid */
+                        continue;
+                }
+
+                blr = state->blr;
+
+                /* Remove the entries from the lock db. */
+                brl_lock_cancel(br_lck,
+                                blr->smblctx,
+                                sconn_server_id(sconn),
+                                blr->offset,
+                                blr->count,
+                                blr->lock_flav,
+                                blr);
+
+                /* Finally end the request. */
+                if (close_type == SHUTDOWN_CLOSE) {
+                        tevent_req_done(smb2req->subreq);
+                } else {
+                        tevent_req_nterror(smb2req->subreq,
+                                NT_STATUS_RANGE_NOT_LOCKED);
+                }
+        }
+}