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

lockd: 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-40-c6129007ee8d@kernel.org


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

fs/lockd/clnt4xdr.c

+7 −7
Original line number Diff line number Diff line
@@ -243,7 +243,7 @@ static void encode_nlm4_holder(struct xdr_stream *xdr, 
	u64 l_offset, l_len;

	__be32 *p;



	encode_bool(xdr, lock->fl.fl_type == F_RDLCK);

	encode_bool(xdr, lock->fl.c.flc_type == F_RDLCK);

	encode_int32(xdr, lock->svid);

	encode_netobj(xdr, lock->oh.data, lock->oh.len);
@@ -270,7 +270,7 @@ static int decode_nlm4_holder(struct xdr_stream *xdr, struct nlm_res *result) 
		goto out_overflow;

	exclusive = be32_to_cpup(p++);

	lock->svid = be32_to_cpup(p);

	fl->fl_pid = (pid_t)lock->svid;

	fl->c.flc_pid = (pid_t)lock->svid;



	error = decode_netobj(xdr, &lock->oh);

	if (unlikely(error))
@@ -280,8 +280,8 @@ static int decode_nlm4_holder(struct xdr_stream *xdr, struct nlm_res *result) 
	if (unlikely(p == NULL))

		goto out_overflow;



	fl->fl_flags = FL_POSIX;

	fl->fl_type  = exclusive != 0 ? F_WRLCK : F_RDLCK;

	fl->c.flc_flags = FL_POSIX;

	fl->c.flc_type  = exclusive != 0 ? F_WRLCK : F_RDLCK;

	p = xdr_decode_hyper(p, &l_offset);

	xdr_decode_hyper(p, &l_len);

	nlm4svc_set_file_lock_range(fl, l_offset, l_len);
@@ -357,7 +357,7 @@ static void nlm4_xdr_enc_testargs(struct rpc_rqst *req, 
	const struct nlm_lock *lock = &args->lock;



	encode_cookie(xdr, &args->cookie);

	encode_bool(xdr, lock->fl.fl_type == F_WRLCK);

	encode_bool(xdr, lock->fl.c.flc_type == F_WRLCK);

	encode_nlm4_lock(xdr, lock);

}
@@ -380,7 +380,7 @@ static void nlm4_xdr_enc_lockargs(struct rpc_rqst *req, 


	encode_cookie(xdr, &args->cookie);

	encode_bool(xdr, args->block);

	encode_bool(xdr, lock->fl.fl_type == F_WRLCK);

	encode_bool(xdr, lock->fl.c.flc_type == F_WRLCK);

	encode_nlm4_lock(xdr, lock);

	encode_bool(xdr, args->reclaim);

	encode_int32(xdr, args->state);
@@ -403,7 +403,7 @@ static void nlm4_xdr_enc_cancargs(struct rpc_rqst *req, 


	encode_cookie(xdr, &args->cookie);

	encode_bool(xdr, args->block);

	encode_bool(xdr, lock->fl.fl_type == F_WRLCK);

	encode_bool(xdr, lock->fl.c.flc_type == F_WRLCK);

	encode_nlm4_lock(xdr, lock);

}

fs/lockd/clntlock.c

+1 −1
Original line number Diff line number Diff line
@@ -185,7 +185,7 @@ __be32 nlmclnt_grant(const struct sockaddr *addr, const struct nlm_lock *lock) 
			continue;

		if (!rpc_cmp_addr(nlm_addr(block->b_host), addr))

			continue;

		if (nfs_compare_fh(NFS_FH(file_inode(fl_blocked->fl_file)), fh) != 0)

		if (nfs_compare_fh(NFS_FH(file_inode(fl_blocked->c.flc_file)), fh) != 0)

			continue;

		/* Alright, we found a lock. Set the return status

		 * and wake up the caller

fs/lockd/clntproc.c

+33 −29
Original line number Diff line number Diff line
@@ -12,7 +12,6 @@ 
#include <linux/types.h>

#include <linux/errno.h>

#include <linux/fs.h>

#define _NEED_FILE_LOCK_FIELD_MACROS

#include <linux/filelock.h>

#include <linux/nfs_fs.h>

#include <linux/utsname.h>
@@ -134,7 +133,8 @@ static void nlmclnt_setlockargs(struct nlm_rqst *req, struct file_lock *fl) 
	char *nodename = req->a_host->h_rpcclnt->cl_nodename;



	nlmclnt_next_cookie(&argp->cookie);

	memcpy(&lock->fh, NFS_FH(file_inode(fl->fl_file)), sizeof(struct nfs_fh));

	memcpy(&lock->fh, NFS_FH(file_inode(fl->c.flc_file)),

	       sizeof(struct nfs_fh));

	lock->caller  = nodename;

	lock->oh.data = req->a_owner;

	lock->oh.len  = snprintf(req->a_owner, sizeof(req->a_owner), "%u@%s",
@@ -143,7 +143,7 @@ static void nlmclnt_setlockargs(struct nlm_rqst *req, struct file_lock *fl) 
	lock->svid = fl->fl_u.nfs_fl.owner->pid;

	lock->fl.fl_start = fl->fl_start;

	lock->fl.fl_end = fl->fl_end;

	lock->fl.fl_type = fl->fl_type;

	lock->fl.c.flc_type = fl->c.flc_type;

}



static void nlmclnt_release_lockargs(struct nlm_rqst *req)
@@ -183,7 +183,7 @@ int nlmclnt_proc(struct nlm_host *host, int cmd, struct file_lock *fl, void *dat 
	call->a_callback_data = data;



	if (IS_SETLK(cmd) || IS_SETLKW(cmd)) {

		if (fl->fl_type != F_UNLCK) {

		if (fl->c.flc_type != F_UNLCK) {

			call->a_args.block = IS_SETLKW(cmd) ? 1 : 0;

			status = nlmclnt_lock(call, fl);

		} else
@@ -433,13 +433,14 @@ nlmclnt_test(struct nlm_rqst *req, struct file_lock *fl) 
{

	int	status;



	status = nlmclnt_call(nfs_file_cred(fl->fl_file), req, NLMPROC_TEST);

	status = nlmclnt_call(nfs_file_cred(fl->c.flc_file), req,

			      NLMPROC_TEST);

	if (status < 0)

		goto out;



	switch (req->a_res.status) {

		case nlm_granted:

			fl->fl_type = F_UNLCK;

			fl->c.flc_type = F_UNLCK;

			break;

		case nlm_lck_denied:

			/*
@@ -447,8 +448,8 @@ nlmclnt_test(struct nlm_rqst *req, struct file_lock *fl) 
			 */

			fl->fl_start = req->a_res.lock.fl.fl_start;

			fl->fl_end = req->a_res.lock.fl.fl_end;

			fl->fl_type = req->a_res.lock.fl.fl_type;

			fl->fl_pid = -req->a_res.lock.fl.fl_pid;

			fl->c.flc_type = req->a_res.lock.fl.c.flc_type;

			fl->c.flc_pid = -req->a_res.lock.fl.c.flc_pid;

			break;

		default:

			status = nlm_stat_to_errno(req->a_res.status);
@@ -486,14 +487,15 @@ static const struct file_lock_operations nlmclnt_lock_ops = { 
static void nlmclnt_locks_init_private(struct file_lock *fl, struct nlm_host *host)

{

	fl->fl_u.nfs_fl.state = 0;

	fl->fl_u.nfs_fl.owner = nlmclnt_find_lockowner(host, fl->fl_owner);

	fl->fl_u.nfs_fl.owner = nlmclnt_find_lockowner(host,

						       fl->c.flc_owner);

	INIT_LIST_HEAD(&fl->fl_u.nfs_fl.list);

	fl->fl_ops = &nlmclnt_lock_ops;

}



static int do_vfs_lock(struct file_lock *fl)

{

	return locks_lock_file_wait(fl->fl_file, fl);

	return locks_lock_file_wait(fl->c.flc_file, fl);

}



/*
@@ -519,11 +521,11 @@ static int do_vfs_lock(struct file_lock *fl) 
static int

nlmclnt_lock(struct nlm_rqst *req, struct file_lock *fl)

{

	const struct cred *cred = nfs_file_cred(fl->fl_file);

	const struct cred *cred = nfs_file_cred(fl->c.flc_file);

	struct nlm_host	*host = req->a_host;

	struct nlm_res	*resp = &req->a_res;

	struct nlm_wait block;

	unsigned char flags = fl->fl_flags;

	unsigned char flags = fl->c.flc_flags;

	unsigned char type;

	__be32 b_status;

	int status = -ENOLCK;
@@ -532,9 +534,9 @@ nlmclnt_lock(struct nlm_rqst *req, struct file_lock *fl) 
		goto out;

	req->a_args.state = nsm_local_state;



	fl->fl_flags |= FL_ACCESS;

	fl->c.flc_flags |= FL_ACCESS;

	status = do_vfs_lock(fl);

	fl->fl_flags = flags;

	fl->c.flc_flags = flags;

	if (status < 0)

		goto out;
@@ -592,11 +594,11 @@ nlmclnt_lock(struct nlm_rqst *req, struct file_lock *fl) 
			goto again;

		}

		/* Ensure the resulting lock will get added to granted list */

		fl->fl_flags |= FL_SLEEP;

		fl->c.flc_flags |= FL_SLEEP;

		if (do_vfs_lock(fl) < 0)

			printk(KERN_WARNING "%s: VFS is out of sync with lock manager!\n", __func__);

		up_read(&host->h_rwsem);

		fl->fl_flags = flags;

		fl->c.flc_flags = flags;

		status = 0;

	}

	if (status < 0)
@@ -623,13 +625,13 @@ nlmclnt_lock(struct nlm_rqst *req, struct file_lock *fl) 
			   req->a_host->h_addrlen, req->a_res.status);

	dprintk("lockd: lock attempt ended in fatal error.\n"

		"       Attempting to unlock.\n");

	type = fl->fl_type;

	fl->fl_type = F_UNLCK;

	type = fl->c.flc_type;

	fl->c.flc_type = F_UNLCK;

	down_read(&host->h_rwsem);

	do_vfs_lock(fl);

	up_read(&host->h_rwsem);

	fl->fl_type = type;

	fl->fl_flags = flags;

	fl->c.flc_type = type;

	fl->c.flc_flags = flags;

	nlmclnt_async_call(cred, req, NLMPROC_UNLOCK, &nlmclnt_unlock_ops);

	return status;

}
@@ -652,12 +654,14 @@ nlmclnt_reclaim(struct nlm_host *host, struct file_lock *fl, 
	nlmclnt_setlockargs(req, fl);

	req->a_args.reclaim = 1;



	status = nlmclnt_call(nfs_file_cred(fl->fl_file), req, NLMPROC_LOCK);

	status = nlmclnt_call(nfs_file_cred(fl->c.flc_file), req,

			      NLMPROC_LOCK);

	if (status >= 0 && req->a_res.status == nlm_granted)

		return 0;



	printk(KERN_WARNING "lockd: failed to reclaim lock for pid %d "

				"(errno %d, status %d)\n", fl->fl_pid,

				"(errno %d, status %d)\n",

				fl->c.flc_pid,

				status, ntohl(req->a_res.status));



	/*
@@ -684,25 +688,25 @@ nlmclnt_unlock(struct nlm_rqst *req, struct file_lock *fl) 
	struct nlm_host	*host = req->a_host;

	struct nlm_res	*resp = &req->a_res;

	int status;

	unsigned char flags = fl->fl_flags;

	unsigned char flags = fl->c.flc_flags;



	/*

	 * Note: the server is supposed to either grant us the unlock

	 * request, or to deny it with NLM_LCK_DENIED_GRACE_PERIOD. In either

	 * case, we want to unlock.

	 */

	fl->fl_flags |= FL_EXISTS;

	fl->c.flc_flags |= FL_EXISTS;

	down_read(&host->h_rwsem);

	status = do_vfs_lock(fl);

	up_read(&host->h_rwsem);

	fl->fl_flags = flags;

	fl->c.flc_flags = flags;

	if (status == -ENOENT) {

		status = 0;

		goto out;

	}



	refcount_inc(&req->a_count);

	status = nlmclnt_async_call(nfs_file_cred(fl->fl_file), req,

	status = nlmclnt_async_call(nfs_file_cred(fl->c.flc_file), req,

				    NLMPROC_UNLOCK, &nlmclnt_unlock_ops);

	if (status < 0)

		goto out;
@@ -796,7 +800,7 @@ static int nlmclnt_cancel(struct nlm_host *host, int block, struct file_lock *fl 
	req->a_args.block = block;



	refcount_inc(&req->a_count);

	status = nlmclnt_async_call(nfs_file_cred(fl->fl_file), req,

	status = nlmclnt_async_call(nfs_file_cred(fl->c.flc_file), req,

				    NLMPROC_CANCEL, &nlmclnt_cancel_ops);

	if (status == 0 && req->a_res.status == nlm_lck_denied)

		status = -ENOLCK;

fs/lockd/clntxdr.c

+7 −7
Original line number Diff line number Diff line
@@ -238,7 +238,7 @@ static void encode_nlm_holder(struct xdr_stream *xdr, 
	u32 l_offset, l_len;

	__be32 *p;



	encode_bool(xdr, lock->fl.fl_type == F_RDLCK);

	encode_bool(xdr, lock->fl.c.flc_type == F_RDLCK);

	encode_int32(xdr, lock->svid);

	encode_netobj(xdr, lock->oh.data, lock->oh.len);
@@ -265,7 +265,7 @@ static int decode_nlm_holder(struct xdr_stream *xdr, struct nlm_res *result) 
		goto out_overflow;

	exclusive = be32_to_cpup(p++);

	lock->svid = be32_to_cpup(p);

	fl->fl_pid = (pid_t)lock->svid;

	fl->c.flc_pid = (pid_t)lock->svid;



	error = decode_netobj(xdr, &lock->oh);

	if (unlikely(error))
@@ -275,8 +275,8 @@ static int decode_nlm_holder(struct xdr_stream *xdr, struct nlm_res *result) 
	if (unlikely(p == NULL))

		goto out_overflow;



	fl->fl_flags = FL_POSIX;

	fl->fl_type  = exclusive != 0 ? F_WRLCK : F_RDLCK;

	fl->c.flc_flags = FL_POSIX;

	fl->c.flc_type  = exclusive != 0 ? F_WRLCK : F_RDLCK;

	l_offset = be32_to_cpup(p++);

	l_len = be32_to_cpup(p);

	end = l_offset + l_len - 1;
@@ -357,7 +357,7 @@ static void nlm_xdr_enc_testargs(struct rpc_rqst *req, 
	const struct nlm_lock *lock = &args->lock;



	encode_cookie(xdr, &args->cookie);

	encode_bool(xdr, lock->fl.fl_type == F_WRLCK);

	encode_bool(xdr, lock->fl.c.flc_type == F_WRLCK);

	encode_nlm_lock(xdr, lock);

}
@@ -380,7 +380,7 @@ static void nlm_xdr_enc_lockargs(struct rpc_rqst *req, 


	encode_cookie(xdr, &args->cookie);

	encode_bool(xdr, args->block);

	encode_bool(xdr, lock->fl.fl_type == F_WRLCK);

	encode_bool(xdr, lock->fl.c.flc_type == F_WRLCK);

	encode_nlm_lock(xdr, lock);

	encode_bool(xdr, args->reclaim);

	encode_int32(xdr, args->state);
@@ -403,7 +403,7 @@ static void nlm_xdr_enc_cancargs(struct rpc_rqst *req, 


	encode_cookie(xdr, &args->cookie);

	encode_bool(xdr, args->block);

	encode_bool(xdr, lock->fl.fl_type == F_WRLCK);

	encode_bool(xdr, lock->fl.c.flc_type == F_WRLCK);

	encode_nlm_lock(xdr, lock);

}

fs/lockd/svc4proc.c

+5 −5
Original line number Diff line number Diff line
@@ -52,16 +52,16 @@ nlm4svc_retrieve_args(struct svc_rqst *rqstp, struct nlm_args *argp, 
		*filp = file;



		/* Set up the missing parts of the file_lock structure */

		lock->fl.fl_flags = FL_POSIX;

		lock->fl.fl_file  = file->f_file[mode];

		lock->fl.fl_pid = current->tgid;

		lock->fl.c.flc_flags = FL_POSIX;

		lock->fl.c.flc_file  = file->f_file[mode];

		lock->fl.c.flc_pid = current->tgid;

		lock->fl.fl_start = (loff_t)lock->lock_start;

		lock->fl.fl_end = lock->lock_len ?

				   (loff_t)(lock->lock_start + lock->lock_len - 1) :

				   OFFSET_MAX;

		lock->fl.fl_lmops = &nlmsvc_lock_operations;

		nlmsvc_locks_init_private(&lock->fl, host, (pid_t)lock->svid);

		if (!lock->fl.fl_owner) {

		if (!lock->fl.c.flc_owner) {

			/* lockowner allocation has failed */

			nlmsvc_release_host(host);

			return nlm_lck_denied_nolocks;
@@ -106,7 +106,7 @@ __nlm4svc_proc_test(struct svc_rqst *rqstp, struct nlm_res *resp) 
	if ((resp->status = nlm4svc_retrieve_args(rqstp, argp, &host, &file)))

		return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;



	test_owner = argp->lock.fl.fl_owner;

	test_owner = argp->lock.fl.c.flc_owner;

	/* Now check for conflicting locks */

	resp->status = nlmsvc_testlock(rqstp, file, host, &argp->lock, &resp->lock, &resp->cookie);

	if (resp->status == nlm_drop_reply)