smbd: use share_mode_do_locked_brl()

author Ralph Boehme <slow@samba.org>

Wed, 29 Jan 2025 05:13:44 +0000 (06:13 +0100)

committer Jule Anger <janger@samba.org>

Thu, 17 Apr 2025 11:31:14 +0000 (11:31 +0000)
author Ralph Boehme <slow@samba.org>
Wed, 29 Jan 2025 05:13:44 +0000 (06:13 +0100)
committer Jule Anger <janger@samba.org>
Thu, 17 Apr 2025 11:31:14 +0000 (11:31 +0000)
diff --git a/source3/locking/locking.c b/source3/locking/locking.c

index e81b3ca95be843556c5d28fd9babc45ddb6101c3..79ea220984f3169e92a308d847ffe9e6c6aa146a 100644 (file)
--- a/source3/locking/locking.c
+++ b/source3/locking/locking.c
@@ -242,52 +242,7 @@ static void decrement_current_lock_count(files_struct *fsp,
   Utility function called by locking requests.
  ****************************************************************************/
  
-struct do_lock_state {
-       struct files_struct *fsp;
-       TALLOC_CTX *req_mem_ctx;
-       const struct GUID *req_guid;
-       uint64_t smblctx;
-       uint64_t count;
-       uint64_t offset;
-       enum brl_type lock_type;
-       enum brl_flavour lock_flav;
-
-       struct server_id blocker_pid;
-       uint64_t blocker_smblctx;
-       NTSTATUS status;
-};
-
-static void do_lock_fn(
-       struct share_mode_lock *lck,
-       void *private_data)
-{
-       struct do_lock_state *state = private_data;
-       struct byte_range_lock *br_lck = NULL;
-
-       br_lck = brl_get_locks_for_locking(talloc_tos(),
-                                          state->fsp,
-                                          state->req_mem_ctx,
-                                          state->req_guid);
-       if (br_lck == NULL) {
-               state->status = NT_STATUS_NO_MEMORY;
-               return;
-       }
-
-       state->status = brl_lock(
-               br_lck,
-               state->smblctx,
-               messaging_server_id(state->fsp->conn->sconn->msg_ctx),
-               state->offset,
-               state->count,
-               state->lock_type,
-               state->lock_flav,
-               &state->blocker_pid,
-               &state->blocker_smblctx);
-
-       TALLOC_FREE(br_lck);
-}
-
-NTSTATUS do_lock(files_struct *fsp,
+NTSTATUS do_lock(struct byte_range_lock *br_lck,
                  TALLOC_CTX *req_mem_ctx,
                  const struct GUID *req_guid,
                  uint64_t smblctx,
@@ -298,22 +253,13 @@ NTSTATUS do_lock(files_struct *fsp,
                  struct server_id *pblocker_pid,
                  uint64_t *psmblctx)
  {
-       struct do_lock_state state = {
-               .fsp = fsp,
-               .req_mem_ctx = req_mem_ctx,
-               .req_guid = req_guid,
-               .smblctx = smblctx,
-               .count = count,
-               .offset = offset,
-               .lock_type = lock_type,
-               .lock_flav = lock_flav,
-       };
+       files_struct *fsp = brl_fsp(br_lck);
+       struct server_id blocker_pid;
+       uint64_t blocker_smblctx;
         NTSTATUS status;
  
-       /* silently return ok on print files as we don't do locking there */
-       if (fsp->print_file) {
-               return NT_STATUS_OK;
-       }
+       SMB_ASSERT(req_mem_ctx != NULL);
+       SMB_ASSERT(req_guid != NULL);
  
         if (!fsp->fsp_flags.can_lock) {
                 if (fsp->fsp_flags.is_directory) {
@@ -337,25 +283,27 @@ NTSTATUS do_lock(files_struct *fsp,
                   fsp_fnum_dbg(fsp),
                   fsp_str_dbg(fsp));
  
-       status = share_mode_do_locked_vfs_allowed(fsp->file_id,
-                                                 do_lock_fn,
-                                                 &state);
-       if (!NT_STATUS_IS_OK(status)) {
-               DBG_DEBUG("share_mode_do_locked returned %s\n",
-                         nt_errstr(status));
-               return status;
-       }
-       if (!NT_STATUS_IS_OK(state.status)) {
-               DBG_DEBUG("do_lock_fn returned %s\n",
-                         nt_errstr(state.status));
+       brl_req_set(br_lck, req_mem_ctx, req_guid);
+       status = brl_lock(br_lck,
+                         smblctx,
+                         messaging_server_id(fsp->conn->sconn->msg_ctx),
+                         offset,
+                         count,
+                         lock_type,
+                         lock_flav,
+                         &blocker_pid,
+                         &blocker_smblctx);
+       brl_req_set(br_lck, NULL, NULL);
+        if (!NT_STATUS_IS_OK(status)) {
+               DBG_DEBUG("brl_lock failed: %s\n", nt_errstr(status));
                 if (psmblctx != NULL) {
-                       *psmblctx = state.blocker_smblctx;
+                       *psmblctx = blocker_smblctx;
                 }
                 if (pblocker_pid != NULL) {
-                       *pblocker_pid = state.blocker_pid;
+                       *pblocker_pid = blocker_pid;
                 }
-               return state.status;
-       }
+               return status;
+        }
  
         increment_current_lock_count(fsp, lock_flav);
  
@@ -366,14 +314,14 @@ NTSTATUS do_lock(files_struct *fsp,
   Utility function called by unlocking requests.
  ****************************************************************************/
  
-NTSTATUS do_unlock(files_struct *fsp,
+NTSTATUS do_unlock(struct byte_range_lock *br_lck,
                    uint64_t smblctx,
                    uint64_t count,
                    uint64_t offset,
                    enum brl_flavour lock_flav)
  {
+       files_struct *fsp = brl_fsp(br_lck);
         bool ok = False;
-       struct byte_range_lock *br_lck = NULL;
  
         if (!fsp->fsp_flags.can_lock) {
                 return fsp->fsp_flags.is_directory ?
@@ -392,11 +340,6 @@ NTSTATUS do_unlock(files_struct *fsp,
                   fsp_fnum_dbg(fsp),
                   fsp_str_dbg(fsp));
  
-       br_lck = brl_get_locks(talloc_tos(), fsp);
-       if (!br_lck) {
-               return NT_STATUS_NO_MEMORY;
-       }
-
         ok = brl_unlock(br_lck,
                         smblctx,
                         messaging_server_id(fsp->conn->sconn->msg_ctx),
@@ -404,8 +347,6 @@ NTSTATUS do_unlock(files_struct *fsp,
                         count,
                         lock_flav);
  
-       TALLOC_FREE(br_lck);
-
         if (!ok) {
                 DEBUG(10,("do_unlock: returning ERRlock.\n" ));
                 return NT_STATUS_RANGE_NOT_LOCKED;
diff --git a/source3/locking/proto.h b/source3/locking/proto.h

index 8285aa9f1370b04acffa4f3bdcb22b5926ca888e..967ed7641bf628fc064aa2f6bbd3d7a0be821f81 100644 (file)
--- a/source3/locking/proto.h
+++ b/source3/locking/proto.h
@@ -120,7 +120,7 @@ NTSTATUS query_lock(files_struct *fsp,
                         uint64_t *poffset,
                         enum brl_type *plock_type,
                         enum brl_flavour lock_flav);
-NTSTATUS do_lock(files_struct *fsp,
+NTSTATUS do_lock(struct byte_range_lock *br_lck,
                  TALLOC_CTX *req_mem_ctx,
                  const struct GUID *req_guid,
                  uint64_t smblctx,
@@ -130,7 +130,7 @@ NTSTATUS do_lock(files_struct *fsp,
                  enum brl_flavour lock_flav,
                  struct server_id *pblocker_pid,
                  uint64_t *psmblctx);
-NTSTATUS do_unlock(files_struct *fsp,
+NTSTATUS do_unlock(struct byte_range_lock *br_lck,
                    uint64_t smblctx,
                    uint64_t count,
                    uint64_t offset,
diff --git a/source3/modules/vfs_fruit.c b/source3/modules/vfs_fruit.c

index 09d171bef8a6a98e1dab37b919f8e2593c95d18a..ba744e52a961cf3ef599465f229f3b6381a77b63 100644 (file)
--- a/source3/modules/vfs_fruit.c
+++ b/source3/modules/vfs_fruit.c
@@ -618,11 +618,21 @@ static bool test_netatalk_lock(files_struct *fsp, off_t in_offset)
         return false;
  }
  
-static NTSTATUS fruit_check_access(vfs_handle_struct *handle,
-                                  files_struct *fsp,
-                                  uint32_t access_mask,
-                                  uint32_t share_mode)
+struct check_access_state {
+       NTSTATUS status;
+       files_struct *fsp;
+       uint32_t access_mask;
+       uint32_t share_mode;
+};
+
+static void fruit_check_access(struct share_mode_lock *lck,
+                              struct byte_range_lock *br_lck,
+                              void *private_data)
  {
+       struct check_access_state *state = private_data;
+       files_struct *fsp = state->fsp;
+       uint32_t access_mask = state->access_mask;
+       uint32_t share_mode = state->share_mode;
         NTSTATUS status = NT_STATUS_OK;
         off_t off;
         bool share_for_read = (share_mode & FILE_SHARE_READ);
@@ -636,6 +646,14 @@ static NTSTATUS fruit_check_access(vfs_handle_struct *handle,
         /* FIXME: hardcoded data fork, add resource fork */
         enum apple_fork fork_type = APPLE_FORK_DATA;
  
+       /*
+        * The caller has checked fsp->fsp_flags.can_lock and lp_locking so
+        * br_lck has to be there!
+        */
+       SMB_ASSERT(br_lck != NULL);
+
+       state->status = NT_STATUS_OK;
+
         DBG_DEBUG("%s, am: %s/%s, sm: 0x%x\n",
                   fsp_str_dbg(fsp),
                   access_mask & FILE_READ_DATA ? "READ" :"-",
@@ -643,7 +661,7 @@ static NTSTATUS fruit_check_access(vfs_handle_struct *handle,
                   share_mode);
  
         if (fsp_get_io_fd(fsp) == -1) {
-               return NT_STATUS_OK;
+               return;
         }
  
         /* Read NetATalk opens and deny modes on the file. */
@@ -666,22 +684,26 @@ static NTSTATUS fruit_check_access(vfs_handle_struct *handle,
         /* If there are any conflicts - sharing violation. */
         if ((access_mask & FILE_READ_DATA) &&
                         netatalk_already_open_with_deny_read) {
-               return NT_STATUS_SHARING_VIOLATION;
+               state->status = NT_STATUS_SHARING_VIOLATION;
+               return;
         }
  
         if (!share_for_read &&
                         netatalk_already_open_for_reading) {
-               return NT_STATUS_SHARING_VIOLATION;
+               state->status = NT_STATUS_SHARING_VIOLATION;
+               return;
         }
  
         if ((access_mask & FILE_WRITE_DATA) &&
                         netatalk_already_open_with_deny_write) {
-               return NT_STATUS_SHARING_VIOLATION;
+               state->status = NT_STATUS_SHARING_VIOLATION;
+               return;
         }
  
         if (!share_for_write &&
                         netatalk_already_open_for_writing) {
-               return NT_STATUS_SHARING_VIOLATION;
+               state->status = NT_STATUS_SHARING_VIOLATION;
+               return;
         }
  
         if (!(access_mask & FILE_READ_DATA)) {
@@ -689,15 +711,16 @@ static NTSTATUS fruit_check_access(vfs_handle_struct *handle,
                  * Nothing we can do here, we need read access
                  * to set locks.
                  */
-               return NT_STATUS_OK;
+               return;
         }
  
         /* Set NetAtalk locks matching our access */
         if (access_mask & FILE_READ_DATA) {
                 off = access_to_netatalk_brl(fork_type, FILE_READ_DATA);
                 req_guid.time_hi_and_version = __LINE__;
+
                 status = do_lock(
-                       fsp,
+                       br_lck,
                         talloc_tos(),
                         &req_guid,
                         fsp->op->global->open_persistent_id,
@@ -707,17 +730,18 @@ static NTSTATUS fruit_check_access(vfs_handle_struct *handle,
                         POSIX_LOCK,
                         NULL,
                         NULL);
-
                 if (!NT_STATUS_IS_OK(status))  {
-                       return status;
+                       state->status = status;
+                       return;
                 }
         }
  
         if (!share_for_read) {
                 off = denymode_to_netatalk_brl(fork_type, DENY_READ);
                 req_guid.time_hi_and_version = __LINE__;
+
                 status = do_lock(
-                       fsp,
+                       br_lck,
                         talloc_tos(),
                         &req_guid,
                         fsp->op->global->open_persistent_id,
@@ -727,17 +751,18 @@ static NTSTATUS fruit_check_access(vfs_handle_struct *handle,
                         POSIX_LOCK,
                         NULL,
                         NULL);
-
                 if (!NT_STATUS_IS_OK(status)) {
-                       return status;
+                       state->status = status;
+                       return;
                 }
         }
  
         if (access_mask & FILE_WRITE_DATA) {
                 off = access_to_netatalk_brl(fork_type, FILE_WRITE_DATA);
                 req_guid.time_hi_and_version = __LINE__;
+
                 status = do_lock(
-                       fsp,
+                       br_lck,
                         talloc_tos(),
                         &req_guid,
                         fsp->op->global->open_persistent_id,
@@ -747,17 +772,18 @@ static NTSTATUS fruit_check_access(vfs_handle_struct *handle,
                         POSIX_LOCK,
                         NULL,
                         NULL);
-
                 if (!NT_STATUS_IS_OK(status)) {
-                       return status;
+                       state->status = status;
+                       return;
                 }
         }
  
         if (!share_for_write) {
                 off = denymode_to_netatalk_brl(fork_type, DENY_WRITE);
                 req_guid.time_hi_and_version = __LINE__;
+
                 status = do_lock(
-                       fsp,
+                       br_lck,
                         talloc_tos(),
                         &req_guid,
                         fsp->op->global->open_persistent_id,
@@ -767,13 +793,11 @@ static NTSTATUS fruit_check_access(vfs_handle_struct *handle,
                         POSIX_LOCK,
                         NULL,
                         NULL);
-
                 if (!NT_STATUS_IS_OK(status)) {
-                       return status;
+                       state->status = status;
+                       return;
                 }
         }
-
-       return NT_STATUS_OK;
  }
  
  static NTSTATUS check_aapl(vfs_handle_struct *handle,
@@ -4373,16 +4397,27 @@ static NTSTATUS fruit_create_file(vfs_handle_struct *handle,
         }
  
         if ((config->locking == FRUIT_LOCKING_NETATALK) &&
+           lp_locking(fsp->conn->params) &&
+           fsp->fsp_flags.can_lock &&
             (fsp->op != NULL) &&
             !fsp->fsp_flags.is_pathref)
         {
-               status = fruit_check_access(
-                       handle, *result,
-                       access_mask,
-                       share_access);
+               struct check_access_state state = (struct check_access_state) {
+                       .fsp = fsp,
+                       .access_mask = access_mask,
+                       .share_mode = share_access,
+               };
+
+               status = share_mode_do_locked_brl(fsp,
+                                                 fruit_check_access,
+                                                 &state);
                 if (!NT_STATUS_IS_OK(status)) {
                         goto fail;
                 }
+               if (!NT_STATUS_IS_OK(state.status)) {
+                       status = state.status;
+                       goto fail;
+               }
         }
  
         return status;
diff --git a/source3/smbd/blocking.c b/source3/smbd/blocking.c

index 806d24927abdb584fc63935247a562f215ec0c68..61ba7cedf17e82e50d4b5920855ccc2bfeb0afa5 100644 (file)
--- a/source3/smbd/blocking.c
+++ b/source3/smbd/blocking.c
@@ -29,31 +29,27 @@
  #undef DBGC_CLASS
  #define DBGC_CLASS DBGC_LOCKING
  
-NTSTATUS smbd_do_locks_try(
-       struct files_struct *fsp,
-       uint16_t num_locks,
-       struct smbd_lock_element *locks,
-       uint16_t *blocker_idx,
-       struct server_id *blocking_pid,
-       uint64_t *blocking_smblctx)
+NTSTATUS smbd_do_locks_try(struct byte_range_lock *br_lck,
+                          struct smbd_do_locks_state *state)
  {
-       NTSTATUS status = NT_STATUS_OK;
+       bool unlock_ok;
         uint16_t i;
+       NTSTATUS status = NT_STATUS_OK;
  
-       for (i=0; i<num_locks; i++) {
-               struct smbd_lock_element *e = &locks[i];
+       for (i = 0; i < state->num_locks; i++) {
+               struct smbd_lock_element *e = &state->locks[i];
  
                 status = do_lock(
-                       fsp,
-                       locks, /* req_mem_ctx */
+                       br_lck,
+                       state->locks, /* req_mem_ctx */
                         &e->req_guid,
                         e->smblctx,
                         e->count,
                         e->offset,
                         e->brltype,
                         e->lock_flav,
-                       blocking_pid,
-                       blocking_smblctx);
+                       &state->blocking_pid,
+                       &state->blocking_smblctx);
                 if (!NT_STATUS_IS_OK(status)) {
                         break;
                 }
@@ -63,18 +59,35 @@ NTSTATUS smbd_do_locks_try(
                 return NT_STATUS_OK;
         }
  
-       *blocker_idx = i;
+       state->blocker_idx = i;
+       unlock_ok = true;
  
         /*
          * Undo the locks we successfully got
          */
         for (i = i-1; i != UINT16_MAX; i--) {
-               struct smbd_lock_element *e = &locks[i];
-               do_unlock(fsp,
-                         e->smblctx,
-                         e->count,
-                         e->offset,
-                         e->lock_flav);
+               struct smbd_lock_element *e = &state->locks[i];
+               NTSTATUS ulstatus;
+
+               ulstatus = do_unlock(br_lck,
+                                    e->smblctx,
+                                    e->count,
+                                    e->offset,
+                                    e->lock_flav);
+               if (!NT_STATUS_IS_OK(ulstatus)) {
+                       DBG_DEBUG("Failed to undo lock flavour %s lock "
+                                 "type %s start=%"PRIu64" len=%"PRIu64" "
+                                 "requested for file [%s]\n",
+                                 lock_flav_name(e->lock_flav),
+                                 lock_type_name(e->brltype),
+                                 e->offset,
+                                 e->count,
+                                 fsp_str_dbg(brl_fsp(br_lck)));
+                       unlock_ok = false;
+               }
+       }
+       if (unlock_ok) {
+               brl_set_modified(br_lck, false);
         }
  
         return status;
@@ -118,13 +131,6 @@ static void smbd_smb1_do_locks_try(struct tevent_req *req);
  static void smbd_smb1_do_locks_retry(struct tevent_req *subreq);
  static void smbd_smb1_blocked_locks_cleanup(
         struct tevent_req *req, enum tevent_req_state req_state);
-static NTSTATUS smbd_smb1_do_locks_check(
-       struct files_struct *fsp,
-       uint16_t num_locks,
-       struct smbd_lock_element *locks,
-       uint16_t *blocker_idx,
-       struct server_id *blocking_pid,
-       uint64_t *blocking_smblctx);
  
  static void smbd_smb1_do_locks_setup_timeout(
         struct smbd_smb1_do_locks_state *state,
@@ -378,18 +384,35 @@ static NTSTATUS smbd_smb1_do_locks_check_blocked(
         return NT_STATUS_OK;
  }
  
-static NTSTATUS smbd_smb1_do_locks_check(
-       struct files_struct *fsp,
-       uint16_t num_locks,
-       struct smbd_lock_element *locks,
-       uint16_t *blocker_idx,
-       struct server_id *blocking_pid,
-       uint64_t *blocking_smblctx)
+static void smbd_smb1_do_locks_try_fn(struct share_mode_lock *lck,
+                                     struct byte_range_lock *br_lck,
+                                     void *private_data)
  {
+       struct tevent_req *req = talloc_get_type_abort(
+               private_data, struct tevent_req);
+       struct smbd_smb1_do_locks_state *state = tevent_req_data(
+               req, struct smbd_smb1_do_locks_state);
+       struct smbd_do_locks_state brl_state;
+       struct files_struct *fsp = state->fsp;
         struct tevent_req **blocked = fsp->blocked_smb1_lock_reqs;
         size_t num_blocked = talloc_array_length(blocked);
-       NTSTATUS status;
+       struct timeval endtime = { 0 };
+       struct tevent_req *subreq = NULL;
         size_t bi;
+       NTSTATUS status;
+       bool ok;
+       bool expired;
+
+       /*
+        * The caller has checked fsp->fsp_flags.can_lock and lp_locking so
+        * br_lck has to be there!
+        */
+       SMB_ASSERT(br_lck != NULL);
+
+       brl_state = (struct smbd_do_locks_state) {
+               .num_locks = state->num_locks,
+               .locks = state->locks,
+       };
  
         /*
          * We check the pending/blocked requests
@@ -404,8 +427,8 @@ static NTSTATUS smbd_smb1_do_locks_check(
                         tevent_req_data(blocked[bi],
                         struct smbd_smb1_do_locks_state);
  
-               if (blocked_state->locks == locks) {
-                       SMB_ASSERT(blocked_state->num_locks == num_locks);
+               if (blocked_state->locks == state->locks) {
+                       SMB_ASSERT(blocked_state->num_locks == state->num_locks);
  
                         /*
                          * We found ourself...
@@ -416,61 +439,24 @@ static NTSTATUS smbd_smb1_do_locks_check(
                 status = smbd_smb1_do_locks_check_blocked(
                                 blocked_state->num_locks,
                                 blocked_state->locks,
-                               num_locks,
-                               locks,
-                               blocker_idx,
-                               blocking_smblctx);
+                               state->num_locks,
+                               state->locks,
+                               &brl_state.blocker_idx,
+                               &brl_state.blocking_smblctx);
                 if (!NT_STATUS_IS_OK(status)) {
-                       *blocking_pid = messaging_server_id(
-                                       fsp->conn->sconn->msg_ctx);
-                       return status;
+                       brl_state.blocking_pid = messaging_server_id(
+                               fsp->conn->sconn->msg_ctx);
+                       goto check_retry;
                 }
         }
  
-       status = smbd_do_locks_try(
-               fsp,
-               num_locks,
-               locks,
-               blocker_idx,
-               blocking_pid,
-               blocking_smblctx);
-       if (!NT_STATUS_IS_OK(status)) {
-               return status;
-       }
-
-       return NT_STATUS_OK;
-}
-
-static void smbd_smb1_do_locks_try(struct tevent_req *req)
-{
-       struct smbd_smb1_do_locks_state *state = tevent_req_data(
-               req, struct smbd_smb1_do_locks_state);
-       struct files_struct *fsp = state->fsp;
-       struct share_mode_lock *lck;
-       struct timeval endtime = { 0 };
-       struct server_id blocking_pid = { 0 };
-       uint64_t blocking_smblctx = 0;
-       struct tevent_req *subreq = NULL;
-       NTSTATUS status;
-       bool ok;
-       bool expired;
-
-       lck = get_existing_share_mode_lock(state, fsp->file_id);
-       if (tevent_req_nomem(lck, req)) {
-               DBG_DEBUG("Could not get share mode lock\n");
-               return;
-       }
-
-       status = smbd_smb1_do_locks_check(
-               fsp,
-               state->num_locks,
-               state->locks,
-               &state->blocker,
-               &blocking_pid,
-               &blocking_smblctx);
+       status = smbd_do_locks_try(br_lck, &brl_state);
         if (NT_STATUS_IS_OK(status)) {
                 goto done;
         }
+
+       state->blocker = brl_state.blocker_idx;
+
         if (NT_STATUS_EQUAL(status, NT_STATUS_RETRY)) {
                 /*
                  * We got NT_STATUS_RETRY,
@@ -494,8 +480,8 @@ static void smbd_smb1_do_locks_try(struct tevent_req *req)
                  * locking.tdb may cause retries.
                  */
  
-               if (blocking_smblctx != UINT64_MAX) {
-                       SMB_ASSERT(blocking_smblctx == 0);
+               if (brl_state.blocking_smblctx != UINT64_MAX) {
+                       SMB_ASSERT(brl_state.blocking_smblctx == 0);
                         goto setup_retry;
                 }
  
@@ -516,6 +502,8 @@ static void smbd_smb1_do_locks_try(struct tevent_req *req)
                 endtime = timeval_current_ofs_msec(state->retry_msecs);
                 goto setup_retry;
         }
+
+check_retry:
         if (!ERROR_WAS_LOCK_DENIED(status)) {
                 goto done;
         }
@@ -529,7 +517,7 @@ static void smbd_smb1_do_locks_try(struct tevent_req *req)
         smbd_smb1_do_locks_setup_timeout(state, &state->locks[state->blocker]);
         DBG_DEBUG("timeout=%"PRIu32", blocking_smblctx=%"PRIu64"\n",
                   state->timeout,
-                 blocking_smblctx);
+                 brl_state.blocking_smblctx);
  
         /*
          * The client specified timeout expired
@@ -554,7 +542,7 @@ static void smbd_smb1_do_locks_try(struct tevent_req *req)
  
         endtime = state->endtime;
  
-       if (blocking_smblctx == UINT64_MAX) {
+       if (brl_state.blocking_smblctx == UINT64_MAX) {
                 struct timeval tmp;
  
                 smbd_smb1_do_locks_update_polling_msecs(state);
@@ -568,11 +556,11 @@ static void smbd_smb1_do_locks_try(struct tevent_req *req)
  
  setup_retry:
         subreq = share_mode_watch_send(
-               state, state->ev, &state->fsp->file_id, blocking_pid);
+               state, state->ev, &state->fsp->file_id, brl_state.blocking_pid);
         if (tevent_req_nomem(subreq, req)) {
+               status = NT_STATUS_NO_MEMORY;
                 goto done;
         }
-       TALLOC_FREE(lck);
         tevent_req_set_callback(subreq, smbd_smb1_do_locks_retry, req);
  
         if (timeval_is_zero(&endtime)) {
@@ -586,10 +574,38 @@ setup_retry:
         }
         return;
  done:
-       TALLOC_FREE(lck);
         smbd_smb1_brl_finish_by_req(req, status);
  }
  
+static void smbd_smb1_do_locks_try(struct tevent_req *req)
+{
+       struct smbd_smb1_do_locks_state *state = tevent_req_data(
+               req, struct smbd_smb1_do_locks_state);
+       NTSTATUS status;
+
+       if (!state->fsp->fsp_flags.can_lock) {
+               if (state->fsp->fsp_flags.is_directory) {
+                       return smbd_smb1_brl_finish_by_req(req,
+                                       NT_STATUS_INVALID_DEVICE_REQUEST);
+               }
+               return smbd_smb1_brl_finish_by_req(req,
+                                                  NT_STATUS_INVALID_HANDLE);
+       }
+
+       if (!lp_locking(state->fsp->conn->params)) {
+               return smbd_smb1_brl_finish_by_req(req, NT_STATUS_OK);
+       }
+
+       status = share_mode_do_locked_brl(state->fsp,
+                                         smbd_smb1_do_locks_try_fn,
+                                         req);
+       if (!NT_STATUS_IS_OK(status)) {
+               smbd_smb1_brl_finish_by_req(req, status);
+               return;
+       }
+       return;
+}
+
  static void smbd_smb1_do_locks_retry(struct tevent_req *subreq)
  {
         struct tevent_req *req = tevent_req_callback_data(
diff --git a/source3/smbd/proto.h b/source3/smbd/proto.h

index f53b6a7bbfb3492034ec6fa1d529025617819cb6..b5704aeefff1bff9aaa7c72aea0c536a1b755000 100644 (file)
--- a/source3/smbd/proto.h
+++ b/source3/smbd/proto.h
@@ -87,13 +87,18 @@ ssize_t pwrite_fsync_recv(struct tevent_req *req, int *perr);
  
  /* The following definitions come from smbd/blocking.c  */
  
-NTSTATUS smbd_do_locks_try(
-       struct files_struct *fsp,
-       uint16_t num_locks,
-       struct smbd_lock_element *locks,
-       uint16_t *blocker_idx,
-       struct server_id *blocking_pid,
-       uint64_t *blocking_smblctx);
+struct smbd_do_locks_state {
+       uint16_t num_locks;
+       struct smbd_lock_element *locks;
+       NTSTATUS status;
+       uint16_t blocker_idx;
+       struct server_id blocking_pid;
+       uint64_t blocking_smblctx;
+};
+
+NTSTATUS smbd_do_locks_try(struct byte_range_lock *br_lck,
+                          struct smbd_do_locks_state *state);
+
  struct tevent_req *smbd_smb1_do_locks_send(
         TALLOC_CTX *mem_ctx,
         struct tevent_context *ev,
diff --git a/source3/smbd/smb2_lock.c b/source3/smbd/smb2_lock.c

index b90fbb1dfcbf0495aeb754c9640eb6749952db48..8591b2fbd2c5f19e7c5f9e8cce7c009e7e3a8840 100644 (file)
--- a/source3/smbd/smb2_lock.c
+++ b/source3/smbd/smb2_lock.c
@@ -569,33 +569,32 @@ static void smbd_smb2_lock_update_polling_msecs(
         state->polling_msecs += v_min;
  }
  
-static void smbd_smb2_lock_try(struct tevent_req *req)
+static void smbd_do_locks_try_fn(struct share_mode_lock *lck,
+                                struct byte_range_lock *br_lck,
+                                void *private_data)
  {
+       struct tevent_req *req = talloc_get_type_abort(
+               private_data, struct tevent_req);
         struct smbd_smb2_lock_state *state = tevent_req_data(
                 req, struct smbd_smb2_lock_state);
-       struct share_mode_lock *lck = NULL;
-       uint16_t blocker_idx;
-       struct server_id blocking_pid = { 0 };
-       uint64_t blocking_smblctx;
-       NTSTATUS status;
+       struct smbd_do_locks_state brl_state;
         struct tevent_req *subreq = NULL;
         struct timeval endtime = { 0 };
+       NTSTATUS status;
  
-       lck = get_existing_share_mode_lock(
-               talloc_tos(), state->fsp->file_id);
-       if (tevent_req_nomem(lck, req)) {
-               return;
-       }
+       /*
+        * The caller has checked fsp->fsp_flags.can_lock and lp_locking so
+        * br_lck has to be there!
+        */
+       SMB_ASSERT(br_lck != NULL);
  
-       status = smbd_do_locks_try(
-               state->fsp,
-               state->lock_count,
-               state->locks,
-               &blocker_idx,
-               &blocking_pid,
-               &blocking_smblctx);
+       brl_state = (struct smbd_do_locks_state) {
+               .num_locks = state->lock_count,
+               .locks = state->locks,
+       };
+
+       status = smbd_do_locks_try(br_lck, &brl_state);
         if (NT_STATUS_IS_OK(status)) {
-               TALLOC_FREE(lck);
                 tevent_req_done(req);
                 return;
         }
@@ -622,8 +621,8 @@ static void smbd_smb2_lock_try(struct tevent_req *req)
                  * locking.tdb may cause retries.
                  */
  
-               if (blocking_smblctx != UINT64_MAX) {
-                       SMB_ASSERT(blocking_smblctx == 0);
+               if (brl_state.blocking_smblctx != UINT64_MAX) {
+                       SMB_ASSERT(brl_state.blocking_smblctx == 0);
                         goto setup_retry;
                 }
  
@@ -658,7 +657,6 @@ static void smbd_smb2_lock_try(struct tevent_req *req)
                 status = NT_STATUS_LOCK_NOT_GRANTED;
         }
         if (!NT_STATUS_EQUAL(status, NT_STATUS_LOCK_NOT_GRANTED)) {
-               TALLOC_FREE(lck);
                 tevent_req_nterror(req, status);
                 return;
         }
@@ -670,12 +668,11 @@ static void smbd_smb2_lock_try(struct tevent_req *req)
         state->retry_msecs = 0;
  
         if (!state->blocking) {
-               TALLOC_FREE(lck);
                 tevent_req_nterror(req, status);
                 return;
         }
  
-       if (blocking_smblctx == UINT64_MAX) {
+       if (brl_state.blocking_smblctx == UINT64_MAX) {
                 smbd_smb2_lock_update_polling_msecs(state);
  
                 DBG_DEBUG("Blocked on a posix lock. Retry in %"PRIu32" msecs\n",
@@ -688,8 +685,7 @@ setup_retry:
         DBG_DEBUG("Watching share mode lock\n");
  
         subreq = share_mode_watch_send(
-               state, state->ev, &state->fsp->file_id, blocking_pid);
-       TALLOC_FREE(lck);
+               state, state->ev, &state->fsp->file_id, brl_state.blocking_pid);
         if (tevent_req_nomem(subreq, req)) {
                 return;
         }
@@ -708,6 +704,35 @@ setup_retry:
         }
  }
  
+static void smbd_smb2_lock_try(struct tevent_req *req)
+{
+       struct smbd_smb2_lock_state *state = tevent_req_data(
+               req, struct smbd_smb2_lock_state);
+       NTSTATUS status;
+
+       if (!state->fsp->fsp_flags.can_lock) {
+               if (state->fsp->fsp_flags.is_directory) {
+                       tevent_req_nterror(req,
+                                          NT_STATUS_INVALID_DEVICE_REQUEST);
+                       return;
+               }
+               tevent_req_nterror(req, NT_STATUS_INVALID_HANDLE);
+               return;
+       }
+
+       if (!lp_locking(state->fsp->conn->params)) {
+               return tevent_req_done(req);
+       }
+
+       status = share_mode_do_locked_brl(state->fsp,
+                                         smbd_do_locks_try_fn,
+                                         req);
+       if (!NT_STATUS_IS_OK(status)) {
+               tevent_req_nterror(req, status);
+               return;
+       }
+}
+
  static void smbd_smb2_lock_retry(struct tevent_req *subreq)
  {
         struct tevent_req *req = tevent_req_callback_data(
diff --git a/source3/smbd/smb2_reply.c b/source3/smbd/smb2_reply.c

index 794b5ddf66b9ee7ad15b7af097597e9326e23b7b..d3220978db323461f6eac93c180d5b58d46cc079 100644 (file)
--- a/source3/smbd/smb2_reply.c
+++ b/source3/smbd/smb2_reply.c
@@ -2131,23 +2131,22 @@ uint64_t get_lock_offset(const uint8_t *data, int data_offset,
         return offset;
  }
  
-struct smbd_do_unlocking_state {
-       struct files_struct *fsp;
-       uint16_t num_ulocks;
-       struct smbd_lock_element *ulocks;
-       NTSTATUS status;
-};
-
-static void smbd_do_unlocking_fn(
-       struct share_mode_lock *lck,
-       void *private_data)
+static void smbd_do_unlocking_fn(struct share_mode_lock *lck,
+                                struct byte_range_lock *br_lck,
+                                void *private_data)
  {
-       struct smbd_do_unlocking_state *state = private_data;
-       struct files_struct *fsp = state->fsp;
+       struct smbd_do_locks_state *state = private_data;
+       struct files_struct *fsp = brl_fsp(br_lck);
         uint16_t i;
  
-       for (i = 0; i < state->num_ulocks; i++) {
-               struct smbd_lock_element *e = &state->ulocks[i];
+       /*
+        * The caller has checked fsp->fsp_flags.can_lock and lp_locking so
+        * br_lck has to be there!
+        */
+       SMB_ASSERT(br_lck != NULL);
+
+       for (i = 0; i < state->num_locks; i++) {
+               struct smbd_lock_element *e = &state->locks[i];
  
                 DBG_DEBUG("unlock start=%"PRIu64", len=%"PRIu64" for "
                           "pid %"PRIu64", file %s\n",
@@ -2163,7 +2162,7 @@ static void smbd_do_unlocking_fn(
                 }
  
                 state->status = do_unlock(
-                       fsp, e->smblctx, e->count, e->offset, e->lock_flav);
+                       br_lck, e->smblctx, e->count, e->offset, e->lock_flav);
  
                 DBG_DEBUG("do_unlock returned %s\n",
                           nt_errstr(state->status));
@@ -2181,20 +2180,30 @@ NTSTATUS smbd_do_unlocking(struct smb_request *req,
                            uint16_t num_ulocks,
                            struct smbd_lock_element *ulocks)
  {
-       struct smbd_do_unlocking_state state = {
-               .fsp = fsp,
-               .num_ulocks = num_ulocks,
-               .ulocks = ulocks,
+       struct smbd_do_locks_state state = {
+               .num_locks = num_ulocks,
+               .locks = ulocks,
         };
         NTSTATUS status;
  
         DBG_NOTICE("%s num_ulocks=%"PRIu16"\n", fsp_fnum_dbg(fsp), num_ulocks);
  
-       status = share_mode_do_locked_vfs_allowed(
-               fsp->file_id, smbd_do_unlocking_fn, &state);
+       if (!fsp->fsp_flags.can_lock) {
+               if (fsp->fsp_flags.is_directory) {
+                       return NT_STATUS_INVALID_DEVICE_REQUEST;
+               }
+               return NT_STATUS_INVALID_HANDLE;
+       }
+
+       if (!lp_locking(fsp->conn->params)) {
+               return NT_STATUS_OK;
+       }
  
+       status = share_mode_do_locked_brl(fsp,
+                                         smbd_do_unlocking_fn,
+                                         &state);
         if (!NT_STATUS_IS_OK(status)) {
-               DBG_DEBUG("share_mode_do_locked_vfs_allowed failed: %s\n",
+               DBG_DEBUG("share_mode_do_locked_brl failed: %s\n",
                           nt_errstr(status));
                 return status;
         }
author	Ralph Boehme <slow@samba.org>
	Wed, 29 Jan 2025 05:13:44 +0000 (06:13 +0100)
committer	Jule Anger <janger@samba.org>
	Thu, 17 Apr 2025 11:31:14 +0000 (11:31 +0000)
source3/locking/locking.c		patch \| blob \| blame \| history
source3/locking/proto.h		patch \| blob \| blame \| history
source3/modules/vfs_fruit.c		patch \| blob \| blame \| history
source3/smbd/blocking.c		patch \| blob \| blame \| history
source3/smbd/proto.h		patch \| blob \| blame \| history
source3/smbd/smb2_lock.c		patch \| blob \| blame \| history
source3/smbd/smb2_reply.c		patch \| blob \| blame \| history