Commit 0cc2ea8c authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'nfsd-5.14' of git://linux-nfs.org/~bfields/linux 

Pull nfsd updates from Bruce Fields:

 - add tracepoints for callbacks and for client creation and destruction

 - cache the mounts used for server-to-server copies

 - expose callback information in /proc/fs/nfsd/clients/*/info

 - don't hold locks unnecessarily while waiting for commits

 - update NLM to use xdr_stream, as we have for NFSv2/v3/v4

* tag 'nfsd-5.14' of git://linux-nfs.org/~bfields/linux: (69 commits)
  nfsd: fix NULL dereference in nfs3svc_encode_getaclres
  NFSD: Prevent a possible oops in the nfs_dirent() tracepoint
  nfsd: remove redundant assignment to pointer 'this'
  nfsd: Reduce contention for the nfsd_file nf_rwsem
  lockd: Update the NLMv4 SHARE results encoder to use struct xdr_stream
  lockd: Update the NLMv4 nlm_res results encoder to use struct xdr_stream
  lockd: Update the NLMv4 TEST results encoder to use struct xdr_stream
  lockd: Update the NLMv4 void results encoder to use struct xdr_stream
  lockd: Update the NLMv4 FREE_ALL arguments decoder to use struct xdr_stream
  lockd: Update the NLMv4 SHARE arguments decoder to use struct xdr_stream
  lockd: Update the NLMv4 SM_NOTIFY arguments decoder to use struct xdr_stream
  lockd: Update the NLMv4 nlm_res arguments decoder to use struct xdr_stream
  lockd: Update the NLMv4 UNLOCK arguments decoder to use struct xdr_stream
  lockd: Update the NLMv4 CANCEL arguments decoder to use struct xdr_stream
  lockd: Update the NLMv4 LOCK arguments decoder to use struct xdr_stream
  lockd: Update the NLMv4 TEST arguments decoder to use struct xdr_stream
  lockd: Update the NLMv4 void arguments decoder to use struct xdr_stream
  lockd: Update the NLMv1 SHARE results encoder to use struct xdr_stream
  lockd: Update the NLMv1 nlm_res results encoder to use struct xdr_stream
  lockd: Update the NLMv1 TEST results encoder to use struct xdr_stream
  ...
parents a931dd33 ab1016d3

fs/lockd/svc.c

+43 −0
Original line number Diff line number Diff line
@@ -766,6 +766,46 @@ static void __exit exit_nlm(void) 
module_init(init_nlm);

module_exit(exit_nlm);



/**

 * nlmsvc_dispatch - Process an NLM Request

 * @rqstp: incoming request

 * @statp: pointer to location of accept_stat field in RPC Reply buffer

 *

 * Return values:

 *  %0: Processing complete; do not send a Reply

 *  %1: Processing complete; send Reply in rqstp->rq_res

 */

static int nlmsvc_dispatch(struct svc_rqst *rqstp, __be32 *statp)

{

	const struct svc_procedure *procp = rqstp->rq_procinfo;

	struct kvec *argv = rqstp->rq_arg.head;

	struct kvec *resv = rqstp->rq_res.head;



	svcxdr_init_decode(rqstp);

	if (!procp->pc_decode(rqstp, argv->iov_base))

		goto out_decode_err;



	*statp = procp->pc_func(rqstp);

	if (*statp == rpc_drop_reply)

		return 0;

	if (*statp != rpc_success)

		return 1;



	svcxdr_init_encode(rqstp);

	if (!procp->pc_encode(rqstp, resv->iov_base + resv->iov_len))

		goto out_encode_err;



	return 1;



out_decode_err:

	*statp = rpc_garbage_args;

	return 1;



out_encode_err:

	*statp = rpc_system_err;

	return 1;

}



/*

 * Define NLM program and procedures

 */
@@ -775,6 +815,7 @@ static const struct svc_version nlmsvc_version1 = { 
	.vs_nproc	= 17,

	.vs_proc	= nlmsvc_procedures,

	.vs_count	= nlmsvc_version1_count,

	.vs_dispatch	= nlmsvc_dispatch,

	.vs_xdrsize	= NLMSVC_XDRSIZE,

};

static unsigned int nlmsvc_version3_count[24];
@@ -783,6 +824,7 @@ static const struct svc_version nlmsvc_version3 = { 
	.vs_nproc	= 24,

	.vs_proc	= nlmsvc_procedures,

	.vs_count	= nlmsvc_version3_count,

	.vs_dispatch	= nlmsvc_dispatch,

	.vs_xdrsize	= NLMSVC_XDRSIZE,

};

#ifdef CONFIG_LOCKD_V4
@@ -792,6 +834,7 @@ static const struct svc_version nlmsvc_version4 = { 
	.vs_nproc	= 24,

	.vs_proc	= nlmsvc_procedures4,

	.vs_count	= nlmsvc_version4_count,

	.vs_dispatch	= nlmsvc_dispatch,

	.vs_xdrsize	= NLMSVC_XDRSIZE,

};

#endif

fs/lockd/svcxdr.h

0 → 100644
+151 −0
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: GPL-2.0 */

/*

 * Encode/decode NLM basic data types

 *

 * Basic NLMv3 XDR data types are not defined in an IETF standards

 * document.  X/Open has a description of these data types that

 * is useful.  See Chapter 10 of "Protocols for Interworking:

 * XNFS, Version 3W".

 *

 * Basic NLMv4 XDR data types are defined in Appendix II.1.4 of

 * RFC 1813: "NFS Version 3 Protocol Specification".

 *

 * Author: Chuck Lever <chuck.lever@oracle.com>

 *

 * Copyright (c) 2020, Oracle and/or its affiliates.

 */



#ifndef _LOCKD_SVCXDR_H_

#define _LOCKD_SVCXDR_H_



static inline bool

svcxdr_decode_stats(struct xdr_stream *xdr, __be32 *status)

{

	__be32 *p;



	p = xdr_inline_decode(xdr, XDR_UNIT);

	if (!p)

		return false;

	*status = *p;



	return true;

}



static inline bool

svcxdr_encode_stats(struct xdr_stream *xdr, __be32 status)

{

	__be32 *p;



	p = xdr_reserve_space(xdr, XDR_UNIT);

	if (!p)

		return false;

	*p = status;



	return true;

}



static inline bool

svcxdr_decode_string(struct xdr_stream *xdr, char **data, unsigned int *data_len)

{

	__be32 *p;

	u32 len;



	if (xdr_stream_decode_u32(xdr, &len) < 0)

		return false;

	if (len > NLM_MAXSTRLEN)

		return false;

	p = xdr_inline_decode(xdr, len);

	if (!p)

		return false;

	*data_len = len;

	*data = (char *)p;



	return true;

}



/*

 * NLM cookies are defined by specification to be a variable-length

 * XDR opaque no longer than 1024 bytes. However, this implementation

 * limits their length to 32 bytes, and treats zero-length cookies

 * specially.

 */

static inline bool

svcxdr_decode_cookie(struct xdr_stream *xdr, struct nlm_cookie *cookie)

{

	__be32 *p;

	u32 len;



	if (xdr_stream_decode_u32(xdr, &len) < 0)

		return false;

	if (len > NLM_MAXCOOKIELEN)

		return false;

	if (!len)

		goto out_hpux;



	p = xdr_inline_decode(xdr, len);

	if (!p)

		return false;

	cookie->len = len;

	memcpy(cookie->data, p, len);



	return true;



	/* apparently HPUX can return empty cookies */

out_hpux:

	cookie->len = 4;

	memset(cookie->data, 0, 4);

	return true;

}



static inline bool

svcxdr_encode_cookie(struct xdr_stream *xdr, const struct nlm_cookie *cookie)

{

	__be32 *p;



	if (xdr_stream_encode_u32(xdr, cookie->len) < 0)

		return false;

	p = xdr_reserve_space(xdr, cookie->len);

	if (!p)

		return false;

	memcpy(p, cookie->data, cookie->len);



	return true;

}



static inline bool

svcxdr_decode_owner(struct xdr_stream *xdr, struct xdr_netobj *obj)

{

	__be32 *p;

	u32 len;



	if (xdr_stream_decode_u32(xdr, &len) < 0)

		return false;

	if (len > XDR_MAX_NETOBJ)

		return false;

	p = xdr_inline_decode(xdr, len);

	if (!p)

		return false;

	obj->len = len;

	obj->data = (u8 *)p;



	return true;

}



static inline bool

svcxdr_encode_owner(struct xdr_stream *xdr, const struct xdr_netobj *obj)

{

	unsigned int quadlen = XDR_QUADLEN(obj->len);

	__be32 *p;



	if (xdr_stream_encode_u32(xdr, obj->len) < 0)

		return false;

	p = xdr_reserve_space(xdr, obj->len);

	if (!p)

		return false;

	p[quadlen - 1] = 0;	/* XDR pad */

	memcpy(p, obj->data, obj->len);



	return true;

}



#endif /* _LOCKD_SVCXDR_H_ */

fs/lockd/xdr.c

+207 −195
Original line number Diff line number Diff line
@@ -19,7 +19,7 @@ 


#include <uapi/linux/nfs2.h>



#define NLMDBG_FACILITY		NLMDBG_XDR

#include "svcxdr.h"





static inline loff_t
@@ -42,311 +42,323 @@ loff_t_to_s32(loff_t offset) 
}



/*

 * XDR functions for basic NLM types

 * NLM file handles are defined by specification to be a variable-length

 * XDR opaque no longer than 1024 bytes. However, this implementation

 * constrains their length to exactly the length of an NFSv2 file

 * handle.

 */

static __be32 *nlm_decode_cookie(__be32 *p, struct nlm_cookie *c)

static bool

svcxdr_decode_fhandle(struct xdr_stream *xdr, struct nfs_fh *fh)

{

	unsigned int	len;



	len = ntohl(*p++);

	

	if(len==0)

	{

		c->len=4;

		memset(c->data, 0, 4);	/* hockeypux brain damage */

	}

	else if(len<=NLM_MAXCOOKIELEN)

	{

		c->len=len;

		memcpy(c->data, p, len);

		p+=XDR_QUADLEN(len);

	}

	else 

	{

		dprintk("lockd: bad cookie size %d (only cookies under "

			"%d bytes are supported.)\n",

				len, NLM_MAXCOOKIELEN);

		return NULL;

	}

	return p;

}



static inline __be32 *

nlm_encode_cookie(__be32 *p, struct nlm_cookie *c)

{

	*p++ = htonl(c->len);

	memcpy(p, c->data, c->len);

	p+=XDR_QUADLEN(c->len);

	return p;

}



static __be32 *

nlm_decode_fh(__be32 *p, struct nfs_fh *f)

{

	unsigned int	len;



	if ((len = ntohl(*p++)) != NFS2_FHSIZE) {

		dprintk("lockd: bad fhandle size %d (should be %d)\n",

			len, NFS2_FHSIZE);

		return NULL;

	}

	f->size = NFS2_FHSIZE;

	memset(f->data, 0, sizeof(f->data));

	memcpy(f->data, p, NFS2_FHSIZE);

	return p + XDR_QUADLEN(NFS2_FHSIZE);

}



/*

 * Encode and decode owner handle

 */

static inline __be32 *

nlm_decode_oh(__be32 *p, struct xdr_netobj *oh)

{

	return xdr_decode_netobj(p, oh);

}



static inline __be32 *

nlm_encode_oh(__be32 *p, struct xdr_netobj *oh)

{

	return xdr_encode_netobj(p, oh);

	__be32 *p;

	u32 len;



	if (xdr_stream_decode_u32(xdr, &len) < 0)

		return false;

	if (len != NFS2_FHSIZE)

		return false;



	p = xdr_inline_decode(xdr, len);

	if (!p)

		return false;

	fh->size = NFS2_FHSIZE;

	memcpy(fh->data, p, len);

	memset(fh->data + NFS2_FHSIZE, 0, sizeof(fh->data) - NFS2_FHSIZE);



	return true;

}



static __be32 *

nlm_decode_lock(__be32 *p, struct nlm_lock *lock)

static bool

svcxdr_decode_lock(struct xdr_stream *xdr, struct nlm_lock *lock)

{

	struct file_lock *fl = &lock->fl;

	s32 start, len, end;



	if (!(p = xdr_decode_string_inplace(p, &lock->caller,

					    &lock->len,

					    NLM_MAXSTRLEN))

	 || !(p = nlm_decode_fh(p, &lock->fh))

	 || !(p = nlm_decode_oh(p, &lock->oh)))

		return NULL;

	lock->svid  = ntohl(*p++);

	if (!svcxdr_decode_string(xdr, &lock->caller, &lock->len))

		return false;

	if (!svcxdr_decode_fhandle(xdr, &lock->fh))

		return false;

	if (!svcxdr_decode_owner(xdr, &lock->oh))

		return false;

	if (xdr_stream_decode_u32(xdr, &lock->svid) < 0)

		return false;

	if (xdr_stream_decode_u32(xdr, &start) < 0)

		return false;

	if (xdr_stream_decode_u32(xdr, &len) < 0)

		return false;



	locks_init_lock(fl);

	fl->fl_flags = FL_POSIX;

	fl->fl_type  = F_RDLCK;		/* as good as anything else */

	start = ntohl(*p++);

	len = ntohl(*p++);

	fl->fl_type  = F_RDLCK;

	end = start + len - 1;



	fl->fl_start = s32_to_loff_t(start);



	if (len == 0 || end < 0)

		fl->fl_end = OFFSET_MAX;

	else

		fl->fl_end = s32_to_loff_t(end);

	return p;



	return true;

}



/*

 * Encode result of a TEST/TEST_MSG call

 */

static __be32 *

nlm_encode_testres(__be32 *p, struct nlm_res *resp)

static bool

svcxdr_encode_holder(struct xdr_stream *xdr, const struct nlm_lock *lock)

{

	const struct file_lock *fl = &lock->fl;

	s32 start, len;



	if (!(p = nlm_encode_cookie(p, &resp->cookie)))

		return NULL;

	*p++ = resp->status;



	if (resp->status == nlm_lck_denied) {

		struct file_lock	*fl = &resp->lock.fl;



		*p++ = (fl->fl_type == F_RDLCK)? xdr_zero : xdr_one;

		*p++ = htonl(resp->lock.svid);



		/* Encode owner handle. */

		if (!(p = xdr_encode_netobj(p, &resp->lock.oh)))

			return NULL;



	/* exclusive */

	if (xdr_stream_encode_bool(xdr, fl->fl_type != F_RDLCK) < 0)

		return false;

	if (xdr_stream_encode_u32(xdr, lock->svid) < 0)

		return false;

	if (!svcxdr_encode_owner(xdr, &lock->oh))

		return false;

	start = loff_t_to_s32(fl->fl_start);

	if (fl->fl_end == OFFSET_MAX)

		len = 0;

	else

		len = loff_t_to_s32(fl->fl_end - fl->fl_start + 1);

	if (xdr_stream_encode_u32(xdr, start) < 0)

		return false;

	if (xdr_stream_encode_u32(xdr, len) < 0)

		return false;



	return true;

}



		*p++ = htonl(start);

		*p++ = htonl(len);

static bool

svcxdr_encode_testrply(struct xdr_stream *xdr, const struct nlm_res *resp)

{

	if (!svcxdr_encode_stats(xdr, resp->status))

		return false;

	switch (resp->status) {

	case nlm_lck_denied:

		if (!svcxdr_encode_holder(xdr, &resp->lock))

			return false;

	}



	return p;

	return true;

}





/*

 * First, the server side XDR functions

 * Decode Call arguments

 */



int

nlmsvc_decode_void(struct svc_rqst *rqstp, __be32 *p)

{

	return 1;

}



int

nlmsvc_decode_testargs(struct svc_rqst *rqstp, __be32 *p)

{

	struct xdr_stream *xdr = &rqstp->rq_arg_stream;

	struct nlm_args *argp = rqstp->rq_argp;

	u32 exclusive;



	if (!(p = nlm_decode_cookie(p, &argp->cookie)))

	if (!svcxdr_decode_cookie(xdr, &argp->cookie))

		return 0;



	exclusive = ntohl(*p++);

	if (!(p = nlm_decode_lock(p, &argp->lock)))

	if (xdr_stream_decode_bool(xdr, &exclusive) < 0)

		return 0;

	if (!svcxdr_decode_lock(xdr, &argp->lock))

		return 0;

	if (exclusive)

		argp->lock.fl.fl_type = F_WRLCK;



	return xdr_argsize_check(rqstp, p);

}



int

nlmsvc_encode_testres(struct svc_rqst *rqstp, __be32 *p)

{

	struct nlm_res *resp = rqstp->rq_resp;



	if (!(p = nlm_encode_testres(p, resp)))

		return 0;

	return xdr_ressize_check(rqstp, p);

	return 1;

}



int

nlmsvc_decode_lockargs(struct svc_rqst *rqstp, __be32 *p)

{

	struct xdr_stream *xdr = &rqstp->rq_arg_stream;

	struct nlm_args *argp = rqstp->rq_argp;

	u32 exclusive;



	if (!(p = nlm_decode_cookie(p, &argp->cookie)))

	if (!svcxdr_decode_cookie(xdr, &argp->cookie))

		return 0;

	if (xdr_stream_decode_bool(xdr, &argp->block) < 0)

		return 0;

	argp->block  = ntohl(*p++);

	exclusive    = ntohl(*p++);

	if (!(p = nlm_decode_lock(p, &argp->lock)))

	if (xdr_stream_decode_bool(xdr, &exclusive) < 0)

		return 0;

	if (!svcxdr_decode_lock(xdr, &argp->lock))

		return 0;

	if (exclusive)

		argp->lock.fl.fl_type = F_WRLCK;

	argp->reclaim = ntohl(*p++);

	argp->state   = ntohl(*p++);

	if (xdr_stream_decode_bool(xdr, &argp->reclaim) < 0)

		return 0;

	if (xdr_stream_decode_u32(xdr, &argp->state) < 0)

		return 0;

	argp->monitor = 1;		/* monitor client by default */



	return xdr_argsize_check(rqstp, p);

	return 1;

}



int

nlmsvc_decode_cancargs(struct svc_rqst *rqstp, __be32 *p)

{

	struct xdr_stream *xdr = &rqstp->rq_arg_stream;

	struct nlm_args *argp = rqstp->rq_argp;

	u32 exclusive;



	if (!(p = nlm_decode_cookie(p, &argp->cookie)))

	if (!svcxdr_decode_cookie(xdr, &argp->cookie))

		return 0;

	if (xdr_stream_decode_bool(xdr, &argp->block) < 0)

		return 0;

	argp->block = ntohl(*p++);

	exclusive = ntohl(*p++);

	if (!(p = nlm_decode_lock(p, &argp->lock)))

	if (xdr_stream_decode_bool(xdr, &exclusive) < 0)

		return 0;

	if (!svcxdr_decode_lock(xdr, &argp->lock))

		return 0;

	if (exclusive)

		argp->lock.fl.fl_type = F_WRLCK;

	return xdr_argsize_check(rqstp, p);



	return 1;

}



int

nlmsvc_decode_unlockargs(struct svc_rqst *rqstp, __be32 *p)

{

	struct xdr_stream *xdr = &rqstp->rq_arg_stream;

	struct nlm_args *argp = rqstp->rq_argp;



	if (!(p = nlm_decode_cookie(p, &argp->cookie))

	 || !(p = nlm_decode_lock(p, &argp->lock)))

	if (!svcxdr_decode_cookie(xdr, &argp->cookie))

		return 0;

	if (!svcxdr_decode_lock(xdr, &argp->lock))

		return 0;

	argp->lock.fl.fl_type = F_UNLCK;

	return xdr_argsize_check(rqstp, p);



	return 1;

}



int

nlmsvc_decode_shareargs(struct svc_rqst *rqstp, __be32 *p)

nlmsvc_decode_res(struct svc_rqst *rqstp, __be32 *p)

{

	struct nlm_args *argp = rqstp->rq_argp;

	struct nlm_lock	*lock = &argp->lock;



	memset(lock, 0, sizeof(*lock));

	locks_init_lock(&lock->fl);

	lock->svid = ~(u32) 0;

	struct xdr_stream *xdr = &rqstp->rq_arg_stream;

	struct nlm_res *resp = rqstp->rq_argp;



	if (!(p = nlm_decode_cookie(p, &argp->cookie))

	 || !(p = xdr_decode_string_inplace(p, &lock->caller,

					    &lock->len, NLM_MAXSTRLEN))

	 || !(p = nlm_decode_fh(p, &lock->fh))

	 || !(p = nlm_decode_oh(p, &lock->oh)))

	if (!svcxdr_decode_cookie(xdr, &resp->cookie))

		return 0;

	if (!svcxdr_decode_stats(xdr, &resp->status))

		return 0;

	argp->fsm_mode = ntohl(*p++);

	argp->fsm_access = ntohl(*p++);

	return xdr_argsize_check(rqstp, p);



	return 1;

}



int

nlmsvc_encode_shareres(struct svc_rqst *rqstp, __be32 *p)

nlmsvc_decode_reboot(struct svc_rqst *rqstp, __be32 *p)

{

	struct nlm_res *resp = rqstp->rq_resp;

	struct xdr_stream *xdr = &rqstp->rq_arg_stream;

	struct nlm_reboot *argp = rqstp->rq_argp;

	u32 len;



	if (!(p = nlm_encode_cookie(p, &resp->cookie)))

	if (xdr_stream_decode_u32(xdr, &len) < 0)

		return 0;

	if (len > SM_MAXSTRLEN)

		return 0;

	p = xdr_inline_decode(xdr, len);

	if (!p)

		return 0;

	argp->len = len;

	argp->mon = (char *)p;

	if (xdr_stream_decode_u32(xdr, &argp->state) < 0)

		return 0;

	*p++ = resp->status;

	*p++ = xdr_zero;		/* sequence argument */

	return xdr_ressize_check(rqstp, p);

	p = xdr_inline_decode(xdr, SM_PRIV_SIZE);

	if (!p)

		return 0;

	memcpy(&argp->priv.data, p, sizeof(argp->priv.data));



	return 1;

}



int

nlmsvc_encode_res(struct svc_rqst *rqstp, __be32 *p)

nlmsvc_decode_shareargs(struct svc_rqst *rqstp, __be32 *p)

{

	struct nlm_res *resp = rqstp->rq_resp;

	struct xdr_stream *xdr = &rqstp->rq_arg_stream;

	struct nlm_args *argp = rqstp->rq_argp;

	struct nlm_lock	*lock = &argp->lock;



	if (!(p = nlm_encode_cookie(p, &resp->cookie)))

	memset(lock, 0, sizeof(*lock));

	locks_init_lock(&lock->fl);

	lock->svid = ~(u32)0;



	if (!svcxdr_decode_cookie(xdr, &argp->cookie))

		return 0;

	if (!svcxdr_decode_string(xdr, &lock->caller, &lock->len))

		return 0;

	if (!svcxdr_decode_fhandle(xdr, &lock->fh))

		return 0;

	if (!svcxdr_decode_owner(xdr, &lock->oh))

		return 0;

	/* XXX: Range checks are missing in the original code */

	if (xdr_stream_decode_u32(xdr, &argp->fsm_mode) < 0)

		return 0;

	*p++ = resp->status;

	return xdr_ressize_check(rqstp, p);

	if (xdr_stream_decode_u32(xdr, &argp->fsm_access) < 0)

		return 0;



	return 1;

}



int

nlmsvc_decode_notify(struct svc_rqst *rqstp, __be32 *p)

{

	struct xdr_stream *xdr = &rqstp->rq_arg_stream;

	struct nlm_args *argp = rqstp->rq_argp;

	struct nlm_lock	*lock = &argp->lock;



	if (!(p = xdr_decode_string_inplace(p, &lock->caller,

					    &lock->len, NLM_MAXSTRLEN)))

	if (!svcxdr_decode_string(xdr, &lock->caller, &lock->len))

		return 0;

	argp->state = ntohl(*p++);

	return xdr_argsize_check(rqstp, p);

	if (xdr_stream_decode_u32(xdr, &argp->state) < 0)

		return 0;



	return 1;

}





/*

 * Encode Reply results

 */



int

nlmsvc_decode_reboot(struct svc_rqst *rqstp, __be32 *p)

nlmsvc_encode_void(struct svc_rqst *rqstp, __be32 *p)

{

	struct nlm_reboot *argp = rqstp->rq_argp;



	if (!(p = xdr_decode_string_inplace(p, &argp->mon, &argp->len, SM_MAXSTRLEN)))

		return 0;

	argp->state = ntohl(*p++);

	memcpy(&argp->priv.data, p, sizeof(argp->priv.data));

	p += XDR_QUADLEN(SM_PRIV_SIZE);

	return xdr_argsize_check(rqstp, p);

	return 1;

}



int

nlmsvc_decode_res(struct svc_rqst *rqstp, __be32 *p)

nlmsvc_encode_testres(struct svc_rqst *rqstp, __be32 *p)

{

	struct nlm_res *resp = rqstp->rq_argp;

	struct xdr_stream *xdr = &rqstp->rq_res_stream;

	struct nlm_res *resp = rqstp->rq_resp;



	if (!(p = nlm_decode_cookie(p, &resp->cookie)))

		return 0;

	resp->status = *p++;

	return xdr_argsize_check(rqstp, p);

	return svcxdr_encode_cookie(xdr, &resp->cookie) &&

		svcxdr_encode_testrply(xdr, resp);

}



int

nlmsvc_decode_void(struct svc_rqst *rqstp, __be32 *p)

nlmsvc_encode_res(struct svc_rqst *rqstp, __be32 *p)

{

	return xdr_argsize_check(rqstp, p);

	struct xdr_stream *xdr = &rqstp->rq_res_stream;

	struct nlm_res *resp = rqstp->rq_resp;



	return svcxdr_encode_cookie(xdr, &resp->cookie) &&

		svcxdr_encode_stats(xdr, resp->status);

}



int

nlmsvc_encode_void(struct svc_rqst *rqstp, __be32 *p)

nlmsvc_encode_shareres(struct svc_rqst *rqstp, __be32 *p)

{

	return xdr_ressize_check(rqstp, p);

	struct xdr_stream *xdr = &rqstp->rq_res_stream;

	struct nlm_res *resp = rqstp->rq_resp;



	if (!svcxdr_encode_cookie(xdr, &resp->cookie))

		return 0;

	if (!svcxdr_encode_stats(xdr, resp->status))

		return 0;

	/* sequence */

	if (xdr_stream_encode_u32(xdr, 0) < 0)

		return 0;



	return 1;

}

fs/lockd/xdr4.c

+208 −195

File changed.

Preview size limit exceeded, changes collapsed.

fs/nfs_common/grace.c

+1 −0
Original line number Diff line number Diff line
@@ -82,6 +82,7 @@ __state_in_grace(struct net *net, bool open) 


/**

 * locks_in_grace

 * @net: network namespace

 *

 * Lock managers call this function to determine when it is OK for them

 * to answer ordinary lock requests, and when they should accept only