Unverified Commit dd1fac6a authored by Jeff Layton's avatar Jeff Layton Committed by Christian Brauner
Browse files

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: default avatarJeff Layton <jlayton@kernel.org>
Link: https://lore.kernel.org/r/20240131-flsplit-v3-41-c6129007ee8d@kernel.org


Reviewed-by: default avatarNeilBrown <neilb@suse.de>
Signed-off-by: default avatarChristian Brauner <brauner@kernel.org>
parent eb8ed7c6

fs/nfs/delegation.c

+1 −1
Original line number Diff line number Diff line
@@ -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);

fs/nfs/file.c

+9 −10
Original line number Diff line number Diff line
@@ -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)

fs/nfs/nfs3proc.c

+1 −1
Original line number Diff line number Diff line
@@ -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;

fs/nfs/nfs4_fs.h

+0 −1
Original line number Diff line number Diff line
@@ -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;

fs/nfs/nfs4proc.c

+18 −15
Original line number Diff line number Diff line
@@ -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;