nfs: convert to using new filelock helpers

Convert to using the new file locking helper functions. Also, in later
patches we're going to introduce some temporary macros with names that
clash with the variable name in nfs4_proc_unlck. Rename it.

Signed-off-by: Jeff Layton <jlayton@kernel.org>
Link: https://lore.kernel.org/r/20240131-flsplit-v3-11-c6129007ee8d@kernel.org
Reviewed-by: NeilBrown <neilb@suse.de>
Signed-off-by: Christian Brauner <brauner@kernel.org>

diff --git a/fs/nfs/delegation.c b/fs/nfs/delegation.c
index fa1a14def45cea2fc485b598831becc9e7497992..ca69850014660f665f98ceb31ceae53d17b17418 100644 (file)
--- a/fs/nfs/delegation.c
+++ b/fs/nfs/delegation.c
@@ -156,7 +156,7 @@ static int nfs_delegation_claim_locks(struct nfs4_state *state, const nfs4_state
        list = &flctx->flc_posix;
        spin_lock(&flctx->flc_lock);
 restart:
-       list_for_each_entry(fl, list, fl_list) {
+       for_each_file_lock(fl, list) {
                if (nfs_file_open_context(fl->fl_file)->state != state)
                        continue;
                spin_unlock(&flctx->flc_lock);

diff --git a/fs/nfs/file.c b/fs/nfs/file.c
index 8577ccf621f5be6c72f6954a49867e03be9cd87a..1a7a76d6055bb1011972a09dffad7f8c901a6229 100644 (file)
--- a/fs/nfs/file.c
+++ b/fs/nfs/file.c
@@ -851,7 +851,7 @@ int nfs_lock(struct file *filp, int cmd, struct file_lock *fl)
 
        if (IS_GETLK(cmd))
                ret = do_getlk(filp, cmd, fl, is_local);
-       else if (fl->fl_type == F_UNLCK)
+       else if (lock_is_unlock(fl))
                ret = do_unlk(filp, cmd, fl, is_local);
        else
                ret = do_setlk(filp, cmd, fl, is_local);
@@ -878,7 +878,7 @@ int nfs_flock(struct file *filp, int cmd, struct file_lock *fl)
                is_local = 1;
 
        /* We're simulating flock() locks using posix locks on the server */
-       if (fl->fl_type == F_UNLCK)
+       if (lock_is_unlock(fl))
                return do_unlk(filp, cmd, fl, is_local);
        return do_setlk(filp, cmd, fl, is_local);
 }

diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index 23819a756508573efbcc61ecc0f529a7ad178e2a..df54fcd0fa087635c3fcac846c4077ad8d153b34 100644 (file)
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -7045,7 +7045,7 @@ static int nfs4_proc_unlck(struct nfs4_state *state, int cmd, struct file_lock *
        struct rpc_task *task;
        struct nfs_seqid *(*alloc_seqid)(struct nfs_seqid_counter *, gfp_t);
        int status = 0;
-       unsigned char fl_flags = request->fl_flags;
+       unsigned char saved_flags = request->fl_flags;
 
        status = nfs4_set_lock_state(state, request);
        /* Unlock _before_ we do the RPC call */
@@ -7080,7 +7080,7 @@ static int nfs4_proc_unlck(struct nfs4_state *state, int cmd, struct file_lock *
        status = rpc_wait_for_completion_task(task);
        rpc_put_task(task);
 out:
-       request->fl_flags = fl_flags;
+       request->fl_flags = saved_flags;
        trace_nfs4_unlock(request, state, F_SETLK, status);
        return status;
 }
@@ -7398,7 +7398,7 @@ static int _nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock
 {
        struct nfs_inode *nfsi = NFS_I(state->inode);
        struct nfs4_state_owner *sp = state->owner;
-       unsigned char fl_flags = request->fl_flags;
+       unsigned char flags = request->fl_flags;
        int status;
 
        request->fl_flags |= FL_ACCESS;
@@ -7410,7 +7410,7 @@ static int _nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock
        if (test_bit(NFS_DELEGATED_STATE, &state->flags)) {
                /* Yes: cache locks! */
                /* ...but avoid races with delegation recall... */
-               request->fl_flags = fl_flags & ~FL_SLEEP;
+               request->fl_flags = flags & ~FL_SLEEP;
                status = locks_lock_inode_wait(state->inode, request);
                up_read(&nfsi->rwsem);
                mutex_unlock(&sp->so_delegreturn_mutex);
@@ -7420,7 +7420,7 @@ static int _nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock
        mutex_unlock(&sp->so_delegreturn_mutex);
        status = _nfs4_do_setlk(state, cmd, request, NFS_LOCK_NEW);
 out:
-       request->fl_flags = fl_flags;
+       request->fl_flags = flags;
        return status;
 }
 
@@ -7562,7 +7562,7 @@ nfs4_proc_lock(struct file *filp, int cmd, struct file_lock *request)
        if (!(IS_SETLK(cmd) || IS_SETLKW(cmd)))
                return -EINVAL;
 
-       if (request->fl_type == F_UNLCK) {
+       if (lock_is_unlock(request)) {
                if (state != NULL)
                        return nfs4_proc_unlck(state, cmd, request);
                return 0;

diff --git a/fs/nfs/nfs4state.c b/fs/nfs/nfs4state.c
index 9a5d911a7edc77cae53cac45aa43f196b32caf20..16b57735e26a0a56b620ac01b7d85775446e86c7 100644 (file)
--- a/fs/nfs/nfs4state.c
+++ b/fs/nfs/nfs4state.c
@@ -847,15 +847,15 @@ void nfs4_close_sync(struct nfs4_state *state, fmode_t fmode)
  */
 static struct nfs4_lock_state *
 __nfs4_find_lock_state(struct nfs4_state *state,
-                      fl_owner_t fl_owner, fl_owner_t fl_owner2)
+                      fl_owner_t owner, fl_owner_t owner2)
 {
        struct nfs4_lock_state *pos, *ret = NULL;
        list_for_each_entry(pos, &state->lock_states, ls_locks) {
-               if (pos->ls_owner == fl_owner) {
+               if (pos->ls_owner == owner) {
                        ret = pos;
                        break;
                }
-               if (pos->ls_owner == fl_owner2)
+               if (pos->ls_owner == owner2)
                        ret = pos;
        }
        if (ret)
@@ -868,7 +868,7 @@ __nfs4_find_lock_state(struct nfs4_state *state,
  * exists, return an uninitialized one.
  *
  */
-static struct nfs4_lock_state *nfs4_alloc_lock_state(struct nfs4_state *state, fl_owner_t fl_owner)
+static struct nfs4_lock_state *nfs4_alloc_lock_state(struct nfs4_state *state, fl_owner_t owner)
 {
        struct nfs4_lock_state *lsp;
        struct nfs_server *server = state->owner->so_server;
@@ -879,7 +879,7 @@ static struct nfs4_lock_state *nfs4_alloc_lock_state(struct nfs4_state *state, f
        nfs4_init_seqid_counter(&lsp->ls_seqid);
        refcount_set(&lsp->ls_count, 1);
        lsp->ls_state = state;
-       lsp->ls_owner = fl_owner;
+       lsp->ls_owner = owner;
        lsp->ls_seqid.owner_id = ida_alloc(&server->lockowner_id, GFP_KERNEL_ACCOUNT);
        if (lsp->ls_seqid.owner_id < 0)
                goto out_free;
@@ -993,7 +993,7 @@ static int nfs4_copy_lock_stateid(nfs4_stateid *dst,
                const struct nfs_lock_context *l_ctx)
 {
        struct nfs4_lock_state *lsp;
-       fl_owner_t fl_owner, fl_flock_owner;
+       fl_owner_t owner, fl_flock_owner;
        int ret = -ENOENT;
 
        if (l_ctx == NULL)
@@ -1002,11 +1002,11 @@ static int nfs4_copy_lock_stateid(nfs4_stateid *dst,
        if (test_bit(LK_STATE_IN_USE, &state->flags) == 0)
                goto out;
 
-       fl_owner = l_ctx->lockowner;
+       owner = l_ctx->lockowner;
        fl_flock_owner = l_ctx->open_context->flock_owner;
 
        spin_lock(&state->state_lock);
-       lsp = __nfs4_find_lock_state(state, fl_owner, fl_flock_owner);
+       lsp = __nfs4_find_lock_state(state, owner, fl_flock_owner);
        if (lsp && test_bit(NFS_LOCK_LOST, &lsp->ls_flags))
                ret = -EIO;
        else if (lsp != NULL && test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags) != 0) {
@@ -1529,7 +1529,7 @@ static int nfs4_reclaim_locks(struct nfs4_state *state, const struct nfs4_state_
        down_write(&nfsi->rwsem);
        spin_lock(&flctx->flc_lock);
 restart:
-       list_for_each_entry(fl, list, fl_list) {
+       for_each_file_lock(fl, list) {
                if (nfs_file_open_context(fl->fl_file)->state != state)
                        continue;
                spin_unlock(&flctx->flc_lock);

diff --git a/fs/nfs/nfs4xdr.c b/fs/nfs/nfs4xdr.c
index 69406e60f391e274c83a215bdbd72fc36c8ad78e..6e309db5afe44cfc1c13800621b5dc3cb507802c 100644 (file)
--- a/fs/nfs/nfs4xdr.c
+++ b/fs/nfs/nfs4xdr.c
@@ -1305,7 +1305,7 @@ static void encode_link(struct xdr_stream *xdr, const struct qstr *name, struct
 
 static inline int nfs4_lock_type(struct file_lock *fl, int block)
 {
-       if (fl->fl_type == F_RDLCK)
+       if (lock_is_read(fl))
                return block ? NFS4_READW_LT : NFS4_READ_LT;
        return block ? NFS4_WRITEW_LT : NFS4_WRITE_LT;
 }

diff --git a/fs/nfs/write.c b/fs/nfs/write.c
index bb79d3a886ae83d15395371ec735b7d0e6075bae..d16f2b9d1765e026b1b7f63d3909bcde6003e274 100644 (file)
--- a/fs/nfs/write.c
+++ b/fs/nfs/write.c
@@ -1301,7 +1301,7 @@ static bool
 is_whole_file_wrlock(struct file_lock *fl)
 {
        return fl->fl_start == 0 && fl->fl_end == OFFSET_MAX &&
-                       fl->fl_type == F_WRLCK;
+                       lock_is_write(fl);
 }
 
 /* If we know the page is up to date, and we're not using byte range locks (or
@@ -1341,7 +1341,7 @@ static int nfs_can_extend_write(struct file *file, struct folio *folio,
        } else if (!list_empty(&flctx->flc_flock)) {
                fl = list_first_entry(&flctx->flc_flock, struct file_lock,
                                        fl_list);
-               if (fl->fl_type == F_WRLCK)
+               if (lock_is_write(fl))
                        ret = 1;
        }
        spin_unlock(&flctx->flc_lock);