nfs: adapt to breakup of struct file_lock

Most of the existing APIs have remained the same, but subsystems that
access file_lock fields directly need to reach into struct
file_lock_core now.

Signed-off-by: Jeff Layton <jlayton@kernel.org>
Link: https://lore.kernel.org/r/20240131-flsplit-v3-41-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 ca69850014660f665f98ceb31ceae53d17b17418..d4a42ce0c7e3dfeef19884be272a8ddd449c143f 100644 (file)
--- a/fs/nfs/delegation.c
+++ b/fs/nfs/delegation.c
@@ -157,7 +157,7 @@ static int nfs_delegation_claim_locks(struct nfs4_state *state, const nfs4_state
        spin_lock(&flctx->flc_lock);
 restart:
        for_each_file_lock(fl, list) {
-               if (nfs_file_open_context(fl->fl_file)->state != state)
+               if (nfs_file_open_context(fl->c.flc_file)->state != state)
                        continue;
                spin_unlock(&flctx->flc_lock);
                status = nfs4_lock_delegation_recall(fl, state, stateid);

diff --git a/fs/nfs/file.c b/fs/nfs/file.c
index 0b6691e64d27aeb6f26adc09ea970ca7e08eac6f..407c6e15afe25c4fd5a6dc452f41d55438d7fb24 100644 (file)
--- a/fs/nfs/file.c
+++ b/fs/nfs/file.c
@@ -31,7 +31,6 @@
 #include <linux/swap.h>
 
 #include <linux/uaccess.h>
-#define _NEED_FILE_LOCK_FIELD_MACROS
 #include <linux/filelock.h>
 
 #include "delegation.h"
@@ -721,15 +720,15 @@ do_getlk(struct file *filp, int cmd, struct file_lock *fl, int is_local)
 {
        struct inode *inode = filp->f_mapping->host;
        int status = 0;
-       unsigned int saved_type = fl->fl_type;
+       unsigned int saved_type = fl->c.flc_type;
 
        /* Try local locking first */
        posix_test_lock(filp, fl);
-       if (fl->fl_type != F_UNLCK) {
+       if (fl->c.flc_type != F_UNLCK) {
                /* found a conflict */
                goto out;
        }
-       fl->fl_type = saved_type;
+       fl->c.flc_type = saved_type;
 
        if (NFS_PROTO(inode)->have_delegation(inode, FMODE_READ))
                goto out_noconflict;
@@ -741,7 +740,7 @@ do_getlk(struct file *filp, int cmd, struct file_lock *fl, int is_local)
 out:
        return status;
 out_noconflict:
-       fl->fl_type = F_UNLCK;
+       fl->c.flc_type = F_UNLCK;
        goto out;
 }
 
@@ -766,7 +765,7 @@ do_unlk(struct file *filp, int cmd, struct file_lock *fl, int is_local)
                 *      If we're signalled while cleaning up locks on process exit, we
                 *      still need to complete the unlock.
                 */
-               if (status < 0 && !(fl->fl_flags & FL_CLOSE))
+               if (status < 0 && !(fl->c.flc_flags & FL_CLOSE))
                        return status;
        }
 
@@ -833,12 +832,12 @@ int nfs_lock(struct file *filp, int cmd, struct file_lock *fl)
        int is_local = 0;
 
        dprintk("NFS: lock(%pD2, t=%x, fl=%x, r=%lld:%lld)\n",
-                       filp, fl->fl_type, fl->fl_flags,
+                       filp, fl->c.flc_type, fl->c.flc_flags,
                        (long long)fl->fl_start, (long long)fl->fl_end);
 
        nfs_inc_stats(inode, NFSIOS_VFSLOCK);
 
-       if (fl->fl_flags & FL_RECLAIM)
+       if (fl->c.flc_flags & FL_RECLAIM)
                return -ENOGRACE;
 
        if (NFS_SERVER(inode)->flags & NFS_MOUNT_LOCAL_FCNTL)
@@ -870,9 +869,9 @@ int nfs_flock(struct file *filp, int cmd, struct file_lock *fl)
        int is_local = 0;
 
        dprintk("NFS: flock(%pD2, t=%x, fl=%x)\n",
-                       filp, fl->fl_type, fl->fl_flags);
+                       filp, fl->c.flc_type, fl->c.flc_flags);
 
-       if (!(fl->fl_flags & FL_FLOCK))
+       if (!(fl->c.flc_flags & FL_FLOCK))
                return -ENOLCK;
 
        if (NFS_SERVER(inode)->flags & NFS_MOUNT_LOCAL_FLOCK)

diff --git a/fs/nfs/nfs3proc.c b/fs/nfs/nfs3proc.c
index 2de66e4e8280a801b647dfe10c577e69192e236c..cbbe3f0193b8a34e5a64794248c2b0e4edd63fa0 100644 (file)
--- a/fs/nfs/nfs3proc.c
+++ b/fs/nfs/nfs3proc.c
@@ -963,7 +963,7 @@ nfs3_proc_lock(struct file *filp, int cmd, struct file_lock *fl)
        struct nfs_open_context *ctx = nfs_file_open_context(filp);
        int status;
 
-       if (fl->fl_flags & FL_CLOSE) {
+       if (fl->c.flc_flags & FL_CLOSE) {
                l_ctx = nfs_get_lock_context(ctx);
                if (IS_ERR(l_ctx))
                        l_ctx = NULL;

diff --git a/fs/nfs/nfs4_fs.h b/fs/nfs/nfs4_fs.h
index 752224a48f1c0a2062df4d2198de5237eb249025..581698f1b7b2441025d5421b3b00b4fba42b2ab8 100644 (file)
--- a/fs/nfs/nfs4_fs.h
+++ b/fs/nfs/nfs4_fs.h
@@ -23,7 +23,6 @@
 #define NFS4_MAX_LOOP_ON_RECOVER (10)
 
 #include <linux/seqlock.h>
-#define _NEED_FILE_LOCK_FIELD_MACROS
 #include <linux/filelock.h>
 
 struct idmap;

diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index df54fcd0fa087635c3fcac846c4077ad8d153b34..91dddcd79004c276772f6d20c9a005a3405ab876 100644 (file)
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -6800,7 +6800,7 @@ static int _nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock
        status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
        switch (status) {
                case 0:
-                       request->fl_type = F_UNLCK;
+                       request->c.flc_type = F_UNLCK;
                        break;
                case -NFS4ERR_DENIED:
                        status = 0;
@@ -7018,8 +7018,8 @@ static struct rpc_task *nfs4_do_unlck(struct file_lock *fl,
        /* Ensure this is an unlock - when canceling a lock, the
         * canceled lock is passed in, and it won't be an unlock.
         */
-       fl->fl_type = F_UNLCK;
-       if (fl->fl_flags & FL_CLOSE)
+       fl->c.flc_type = F_UNLCK;
+       if (fl->c.flc_flags & FL_CLOSE)
                set_bit(NFS_CONTEXT_UNLOCK, &ctx->flags);
 
        data = nfs4_alloc_unlockdata(fl, ctx, lsp, seqid);
@@ -7045,11 +7045,11 @@ 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 saved_flags = request->fl_flags;
+       unsigned char saved_flags = request->c.flc_flags;
 
        status = nfs4_set_lock_state(state, request);
        /* Unlock _before_ we do the RPC call */
-       request->fl_flags |= FL_EXISTS;
+       request->c.flc_flags |= FL_EXISTS;
        /* Exclude nfs_delegation_claim_locks() */
        mutex_lock(&sp->so_delegreturn_mutex);
        /* Exclude nfs4_reclaim_open_stateid() - note nesting! */
@@ -7073,14 +7073,16 @@ static int nfs4_proc_unlck(struct nfs4_state *state, int cmd, struct file_lock *
        status = -ENOMEM;
        if (IS_ERR(seqid))
                goto out;
-       task = nfs4_do_unlck(request, nfs_file_open_context(request->fl_file), lsp, seqid);
+       task = nfs4_do_unlck(request,
+                            nfs_file_open_context(request->c.flc_file),
+                            lsp, seqid);
        status = PTR_ERR(task);
        if (IS_ERR(task))
                goto out;
        status = rpc_wait_for_completion_task(task);
        rpc_put_task(task);
 out:
-       request->fl_flags = saved_flags;
+       request->c.flc_flags = saved_flags;
        trace_nfs4_unlock(request, state, F_SETLK, status);
        return status;
 }
@@ -7191,7 +7193,7 @@ static void nfs4_lock_done(struct rpc_task *task, void *calldata)
                renew_lease(NFS_SERVER(d_inode(data->ctx->dentry)),
                                data->timestamp);
                if (data->arg.new_lock && !data->cancelled) {
-                       data->fl.fl_flags &= ~(FL_SLEEP | FL_ACCESS);
+                       data->fl.c.flc_flags &= ~(FL_SLEEP | FL_ACCESS);
                        if (locks_lock_inode_wait(lsp->ls_state->inode, &data->fl) < 0)
                                goto out_restart;
                }
@@ -7292,7 +7294,8 @@ static int _nfs4_do_setlk(struct nfs4_state *state, int cmd, struct file_lock *f
        if (nfs_server_capable(state->inode, NFS_CAP_MOVEABLE))
                task_setup_data.flags |= RPC_TASK_MOVEABLE;
 
-       data = nfs4_alloc_lockdata(fl, nfs_file_open_context(fl->fl_file),
+       data = nfs4_alloc_lockdata(fl,
+                                  nfs_file_open_context(fl->c.flc_file),
                                   fl->fl_u.nfs4_fl.owner, GFP_KERNEL);
        if (data == NULL)
                return -ENOMEM;
@@ -7398,10 +7401,10 @@ 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 flags = request->fl_flags;
+       unsigned char flags = request->c.flc_flags;
        int status;
 
-       request->fl_flags |= FL_ACCESS;
+       request->c.flc_flags |= FL_ACCESS;
        status = locks_lock_inode_wait(state->inode, request);
        if (status < 0)
                goto out;
@@ -7410,7 +7413,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 = flags & ~FL_SLEEP;
+               request->c.flc_flags = flags & ~FL_SLEEP;
                status = locks_lock_inode_wait(state->inode, request);
                up_read(&nfsi->rwsem);
                mutex_unlock(&sp->so_delegreturn_mutex);
@@ -7420,7 +7423,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 = flags;
+       request->c.flc_flags = flags;
        return status;
 }
 
@@ -7571,7 +7574,7 @@ nfs4_proc_lock(struct file *filp, int cmd, struct file_lock *request)
        if (state == NULL)
                return -ENOLCK;
 
-       if ((request->fl_flags & FL_POSIX) &&
+       if ((request->c.flc_flags & FL_POSIX) &&
            !test_bit(NFS_STATE_POSIX_LOCKS, &state->flags))
                return -ENOLCK;
 
@@ -7579,7 +7582,7 @@ nfs4_proc_lock(struct file *filp, int cmd, struct file_lock *request)
         * Don't rely on the VFS having checked the file open mode,
         * since it won't do this for flock() locks.
         */
-       switch (request->fl_type) {
+       switch (request->c.flc_type) {
        case F_RDLCK:
                if (!(filp->f_mode & FMODE_READ))
                        return -EBADF;

diff --git a/fs/nfs/nfs4state.c b/fs/nfs/nfs4state.c
index 16b57735e26a0a56b620ac01b7d85775446e86c7..8cfabdbda33694912652eeb736126c673bdb745a 100644 (file)
--- a/fs/nfs/nfs4state.c
+++ b/fs/nfs/nfs4state.c
@@ -980,7 +980,7 @@ int nfs4_set_lock_state(struct nfs4_state *state, struct file_lock *fl)
 
        if (fl->fl_ops != NULL)
                return 0;
-       lsp = nfs4_get_lock_state(state, fl->fl_owner);
+       lsp = nfs4_get_lock_state(state, fl->c.flc_owner);
        if (lsp == NULL)
                return -ENOMEM;
        fl->fl_u.nfs4_fl.owner = lsp;
@@ -1530,7 +1530,7 @@ static int nfs4_reclaim_locks(struct nfs4_state *state, const struct nfs4_state_
        spin_lock(&flctx->flc_lock);
 restart:
        for_each_file_lock(fl, list) {
-               if (nfs_file_open_context(fl->fl_file)->state != state)
+               if (nfs_file_open_context(fl->c.flc_file)->state != state)
                        continue;
                spin_unlock(&flctx->flc_lock);
                status = ops->recover_lock(state, fl);

diff --git a/fs/nfs/nfs4trace.h b/fs/nfs/nfs4trace.h
index d27919d7241d389b257939c26cc134d4ff1be76f..fd7cb15b08b27628f205cdb4284b9035a7d3172a 100644 (file)
--- a/fs/nfs/nfs4trace.h
+++ b/fs/nfs/nfs4trace.h
@@ -699,7 +699,7 @@ DECLARE_EVENT_CLASS(nfs4_lock_event,
 
                        __entry->error = error < 0 ? -error : 0;
                        __entry->cmd = cmd;
-                       __entry->type = request->fl_type;
+                       __entry->type = request->c.flc_type;
                        __entry->start = request->fl_start;
                        __entry->end = request->fl_end;
                        __entry->dev = inode->i_sb->s_dev;
@@ -771,7 +771,7 @@ TRACE_EVENT(nfs4_set_lock,
 
                        __entry->error = error < 0 ? -error : 0;
                        __entry->cmd = cmd;
-                       __entry->type = request->fl_type;
+                       __entry->type = request->c.flc_type;
                        __entry->start = request->fl_start;
                        __entry->end = request->fl_end;
                        __entry->dev = inode->i_sb->s_dev;

diff --git a/fs/nfs/nfs4xdr.c b/fs/nfs/nfs4xdr.c
index 6e309db5afe44cfc1c13800621b5dc3cb507802c..1416099dfcd159a9cb4a0ffb21dbd826ad940a07 100644 (file)
--- a/fs/nfs/nfs4xdr.c
+++ b/fs/nfs/nfs4xdr.c
@@ -5052,10 +5052,10 @@ static int decode_lock_denied (struct xdr_stream *xdr, struct file_lock *fl)
                fl->fl_end = fl->fl_start + (loff_t)length - 1;
                if (length == ~(uint64_t)0)
                        fl->fl_end = OFFSET_MAX;
-               fl->fl_type = F_WRLCK;
+               fl->c.flc_type = F_WRLCK;
                if (type & 1)
-                       fl->fl_type = F_RDLCK;
-               fl->fl_pid = 0;
+                       fl->c.flc_type = F_RDLCK;
+               fl->c.flc_pid = 0;
        }
        p = xdr_decode_hyper(p, &clientid); /* read 8 bytes */
        namelen = be32_to_cpup(p); /* read 4 bytes */  /* have read all 32 bytes now */

diff --git a/fs/nfs/write.c b/fs/nfs/write.c
index 13f2e10167ac1881c0321c842aee0a6ad2a7cabe..84bb852645728b3edf427c5ac1020e38f329f325 100644 (file)
--- a/fs/nfs/write.c
+++ b/fs/nfs/write.c
@@ -25,7 +25,6 @@
 #include <linux/freezer.h>
 #include <linux/wait.h>
 #include <linux/iversion.h>
-#define _NEED_FILE_LOCK_FIELD_MACROS
 #include <linux/filelock.h>
 
 #include <linux/uaccess.h>
@@ -1336,12 +1335,12 @@ static int nfs_can_extend_write(struct file *file, struct folio *folio,
        spin_lock(&flctx->flc_lock);
        if (!list_empty(&flctx->flc_posix)) {
                fl = list_first_entry(&flctx->flc_posix, struct file_lock,
-                                       fl_list);
+                                       c.flc_list);
                if (is_whole_file_wrlock(fl))
                        ret = 1;
        } else if (!list_empty(&flctx->flc_flock)) {
                fl = list_first_entry(&flctx->flc_flock, struct file_lock,
-                                       fl_list);
+                                       c.flc_list);
                if (lock_is_write(fl))
                        ret = 1;
        }