[thirdparty/kernel/linux.git] / fs / nfsd / nfs2acl.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Process version 2 NFSACL requests.
 *
 * Copyright (C) 2002-2003 Andreas Gruenbacher <agruen@suse.de>
 */

#include "nfsd.h"
/* FIXME: nfsacl.h is a broken header */
#include <linux/nfsacl.h>
#include <linux/gfp.h>
#include "cache.h"
#include "xdr3.h"
#include "vfs.h"

#define NFSDDBG_FACILITY		NFSDDBG_PROC
#define RETURN_STATUS(st)	{ resp->status = (st); return (st); }

/*
 * NULL call.
 */
static __be32
nfsacld_proc_null(struct svc_rqst *rqstp)
{
	return nfs_ok;
}

/*
 * Get the Access and/or Default ACL of a file.
 */
static __be32 nfsacld_proc_getacl(struct svc_rqst *rqstp)
{
	struct nfsd3_getaclargs *argp = rqstp->rq_argp;
	struct nfsd3_getaclres *resp = rqstp->rq_resp;
	struct posix_acl *acl;
	struct inode *inode;
	svc_fh *fh;
	__be32 nfserr = 0;

	dprintk("nfsd: GETACL(2acl)   %s\n", SVCFH_fmt(&argp->fh));

	fh = fh_copy(&resp->fh, &argp->fh);
	nfserr = fh_verify(rqstp, &resp->fh, 0, NFSD_MAY_NOP);
	if (nfserr)
		RETURN_STATUS(nfserr);

	inode = d_inode(fh->fh_dentry);

	if (argp->mask & ~NFS_ACL_MASK)
		RETURN_STATUS(nfserr_inval);
	resp->mask = argp->mask;

	nfserr = fh_getattr(fh, &resp->stat);
	if (nfserr)
		RETURN_STATUS(nfserr);

	if (resp->mask & (NFS_ACL|NFS_ACLCNT)) {
		acl = get_acl(inode, ACL_TYPE_ACCESS);
		if (acl == NULL) {
			/* Solaris returns the inode's minimum ACL. */
			acl = posix_acl_from_mode(inode->i_mode, GFP_KERNEL);
		}
		if (IS_ERR(acl)) {
			nfserr = nfserrno(PTR_ERR(acl));
			goto fail;
		}
		resp->acl_access = acl;
	}
	if (resp->mask & (NFS_DFACL|NFS_DFACLCNT)) {
		/* Check how Solaris handles requests for the Default ACL
		   of a non-directory! */
		acl = get_acl(inode, ACL_TYPE_DEFAULT);
		if (IS_ERR(acl)) {
			nfserr = nfserrno(PTR_ERR(acl));
			goto fail;
		}
		resp->acl_default = acl;
	}

	/* resp->acl_{access,default} are released in nfssvc_release_getacl. */
	RETURN_STATUS(0);

fail:
	posix_acl_release(resp->acl_access);
	posix_acl_release(resp->acl_default);
	RETURN_STATUS(nfserr);
}

/*
 * Set the Access and/or Default ACL of a file.
 */
static __be32 nfsacld_proc_setacl(struct svc_rqst *rqstp)
{
	struct nfsd3_setaclargs *argp = rqstp->rq_argp;
	struct nfsd_attrstat *resp = rqstp->rq_resp;
	struct inode *inode;
	svc_fh *fh;
	__be32 nfserr = 0;
	int error;

	dprintk("nfsd: SETACL(2acl)   %s\n", SVCFH_fmt(&argp->fh));

	fh = fh_copy(&resp->fh, &argp->fh);
	nfserr = fh_verify(rqstp, &resp->fh, 0, NFSD_MAY_SATTR);
	if (nfserr)
		goto out;

	inode = d_inode(fh->fh_dentry);

	error = fh_want_write(fh);
	if (error)
		goto out_errno;

	fh_lock(fh);

	error = set_posix_acl(inode, ACL_TYPE_ACCESS, argp->acl_access);
	if (error)
		goto out_drop_lock;
	error = set_posix_acl(inode, ACL_TYPE_DEFAULT, argp->acl_default);
	if (error)
		goto out_drop_lock;

	fh_unlock(fh);

	fh_drop_write(fh);

	nfserr = fh_getattr(fh, &resp->stat);

out:
	/* argp->acl_{access,default} may have been allocated in
	   nfssvc_decode_setaclargs. */
	posix_acl_release(argp->acl_access);
	posix_acl_release(argp->acl_default);
	return nfserr;
out_drop_lock:
	fh_unlock(fh);
	fh_drop_write(fh);
out_errno:
	nfserr = nfserrno(error);
	goto out;
}

/*
 * Check file attributes
 */
static __be32 nfsacld_proc_getattr(struct svc_rqst *rqstp)
{
	struct nfsd_fhandle *argp = rqstp->rq_argp;
	struct nfsd_attrstat *resp = rqstp->rq_resp;
	__be32 nfserr;
	dprintk("nfsd: GETATTR  %s\n", SVCFH_fmt(&argp->fh));

	fh_copy(&resp->fh, &argp->fh);
	nfserr = fh_verify(rqstp, &resp->fh, 0, NFSD_MAY_NOP);
	if (nfserr)
		return nfserr;
	nfserr = fh_getattr(&resp->fh, &resp->stat);
	return nfserr;
}

/*
 * Check file access
 */
static __be32 nfsacld_proc_access(struct svc_rqst *rqstp)
{
	struct nfsd3_accessargs *argp = rqstp->rq_argp;
	struct nfsd3_accessres *resp = rqstp->rq_resp;
	__be32 nfserr;

	dprintk("nfsd: ACCESS(2acl)   %s 0x%x\n",
			SVCFH_fmt(&argp->fh),
			argp->access);

	fh_copy(&resp->fh, &argp->fh);
	resp->access = argp->access;
	nfserr = nfsd_access(rqstp, &resp->fh, &resp->access, NULL);
	if (nfserr)
		return nfserr;
	nfserr = fh_getattr(&resp->fh, &resp->stat);
	return nfserr;
}

/*
 * XDR decode functions
 */
static int nfsaclsvc_decode_getaclargs(struct svc_rqst *rqstp, __be32 *p)
{
	struct nfsd3_getaclargs *argp = rqstp->rq_argp;

	p = nfs2svc_decode_fh(p, &argp->fh);
	if (!p)
		return 0;
	argp->mask = ntohl(*p); p++;

	return xdr_argsize_check(rqstp, p);
}


static int nfsaclsvc_decode_setaclargs(struct svc_rqst *rqstp, __be32 *p)
{
	struct nfsd3_setaclargs *argp = rqstp->rq_argp;
	struct kvec *head = rqstp->rq_arg.head;
	unsigned int base;
	int n;

	p = nfs2svc_decode_fh(p, &argp->fh);
	if (!p)
		return 0;
	argp->mask = ntohl(*p++);
	if (argp->mask & ~NFS_ACL_MASK ||
	    !xdr_argsize_check(rqstp, p))
		return 0;

	base = (char *)p - (char *)head->iov_base;
	n = nfsacl_decode(&rqstp->rq_arg, base, NULL,
			  (argp->mask & NFS_ACL) ?
			  &argp->acl_access : NULL);
	if (n > 0)
		n = nfsacl_decode(&rqstp->rq_arg, base + n, NULL,
				  (argp->mask & NFS_DFACL) ?
				  &argp->acl_default : NULL);
	return (n > 0);
}

static int nfsaclsvc_decode_fhandleargs(struct svc_rqst *rqstp, __be32 *p)
{
	struct nfsd_fhandle *argp = rqstp->rq_argp;

	p = nfs2svc_decode_fh(p, &argp->fh);
	if (!p)
		return 0;
	return xdr_argsize_check(rqstp, p);
}

static int nfsaclsvc_decode_accessargs(struct svc_rqst *rqstp, __be32 *p)
{
	struct nfsd3_accessargs *argp = rqstp->rq_argp;

	p = nfs2svc_decode_fh(p, &argp->fh);
	if (!p)
		return 0;
	argp->access = ntohl(*p++);

	return xdr_argsize_check(rqstp, p);
}

/*
 * XDR encode functions
 */

/*
 * There must be an encoding function for void results so svc_process
 * will work properly.
 */
static int nfsaclsvc_encode_voidres(struct svc_rqst *rqstp, __be32 *p)
{
	return xdr_ressize_check(rqstp, p);
}

/* GETACL */
static int nfsaclsvc_encode_getaclres(struct svc_rqst *rqstp, __be32 *p)
{
	struct nfsd3_getaclres *resp = rqstp->rq_resp;
	struct dentry *dentry = resp->fh.fh_dentry;
	struct inode *inode;
	struct kvec *head = rqstp->rq_res.head;
	unsigned int base;
	int n;
	int w;

	/*
	 * Since this is version 2, the check for nfserr in
	 * nfsd_dispatch actually ensures the following cannot happen.
	 * However, it seems fragile to depend on that.
	 */
	if (dentry == NULL || d_really_is_negative(dentry))
		return 0;
	inode = d_inode(dentry);

	p = nfs2svc_encode_fattr(rqstp, p, &resp->fh, &resp->stat);
	*p++ = htonl(resp->mask);
	if (!xdr_ressize_check(rqstp, p))
		return 0;
	base = (char *)p - (char *)head->iov_base;

	rqstp->rq_res.page_len = w = nfsacl_size(
		(resp->mask & NFS_ACL)   ? resp->acl_access  : NULL,
		(resp->mask & NFS_DFACL) ? resp->acl_default : NULL);
	while (w > 0) {
		if (!*(rqstp->rq_next_page++))
			return 0;
		w -= PAGE_SIZE;
	}

	n = nfsacl_encode(&rqstp->rq_res, base, inode,
			  resp->acl_access,
			  resp->mask & NFS_ACL, 0);
	if (n > 0)
		n = nfsacl_encode(&rqstp->rq_res, base + n, inode,
				  resp->acl_default,
				  resp->mask & NFS_DFACL,
				  NFS_ACL_DEFAULT);
	return (n > 0);
}

static int nfsaclsvc_encode_attrstatres(struct svc_rqst *rqstp, __be32 *p)
{
	struct nfsd_attrstat *resp = rqstp->rq_resp;

	p = nfs2svc_encode_fattr(rqstp, p, &resp->fh, &resp->stat);
	return xdr_ressize_check(rqstp, p);
}

/* ACCESS */
static int nfsaclsvc_encode_accessres(struct svc_rqst *rqstp, __be32 *p)
{
	struct nfsd3_accessres *resp = rqstp->rq_resp;

	p = nfs2svc_encode_fattr(rqstp, p, &resp->fh, &resp->stat);
	*p++ = htonl(resp->access);
	return xdr_ressize_check(rqstp, p);
}

/*
 * XDR release functions
 */
static void nfsaclsvc_release_getacl(struct svc_rqst *rqstp)
{
	struct nfsd3_getaclres *resp = rqstp->rq_resp;

	fh_put(&resp->fh);
	posix_acl_release(resp->acl_access);
	posix_acl_release(resp->acl_default);
}

static void nfsaclsvc_release_attrstat(struct svc_rqst *rqstp)
{
	struct nfsd_attrstat *resp = rqstp->rq_resp;

	fh_put(&resp->fh);
}

static void nfsaclsvc_release_access(struct svc_rqst *rqstp)
{
	struct nfsd3_accessres *resp = rqstp->rq_resp;

	fh_put(&resp->fh);
}

#define nfsaclsvc_decode_voidargs	NULL
#define nfsaclsvc_release_void		NULL
#define nfsd3_fhandleargs	nfsd_fhandle
#define nfsd3_attrstatres	nfsd_attrstat
#define nfsd3_voidres		nfsd3_voidargs
struct nfsd3_voidargs { int dummy; };

#define PROC(name, argt, rest, relt, cache, respsize)			\
{									\
	.pc_func	= nfsacld_proc_##name,				\
	.pc_decode	= nfsaclsvc_decode_##argt##args,		\
	.pc_encode	= nfsaclsvc_encode_##rest##res,			\
	.pc_release	= nfsaclsvc_release_##relt,	\
	.pc_argsize	= sizeof(struct nfsd3_##argt##args),		\
	.pc_ressize	= sizeof(struct nfsd3_##rest##res),		\
	.pc_cachetype	= cache,					\
	.pc_xdrressize	= respsize,					\
}

#define ST 1		/* status*/
#define AT 21		/* attributes */
#define pAT (1+AT)	/* post attributes - conditional */
#define ACL (1+NFS_ACL_MAX_ENTRIES*3)  /* Access Control List */

static const struct svc_procedure nfsd_acl_procedures2[] = {
  PROC(null,	void,		void,		void,	  RC_NOCACHE, ST),
  PROC(getacl,	getacl,		getacl,		getacl,	  RC_NOCACHE, ST+1+2*(1+ACL)),
  PROC(setacl,	setacl,		attrstat,	attrstat, RC_NOCACHE, ST+AT),
  PROC(getattr, fhandle,	attrstat,	attrstat, RC_NOCACHE, ST+AT),
  PROC(access,	access,		access,		access,   RC_NOCACHE, ST+AT+1),
};

static unsigned int nfsd_acl_count2[ARRAY_SIZE(nfsd_acl_procedures2)];
const struct svc_version nfsd_acl_version2 = {
	.vs_vers	= 2,
	.vs_nproc	= 5,
	.vs_proc	= nfsd_acl_procedures2,
	.vs_count	= nfsd_acl_count2,
	.vs_dispatch	= nfsd_dispatch,
	.vs_xdrsize	= NFS3_SVC_XDRSIZE,
};
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
a257cdd0	2	/*
a257cdd0 AG	3	* Process version 2 NFSACL requests.
	4	*
	5	* Copyright (C) 2002-2003 Andreas Gruenbacher <agruen@suse.de>
	6	*/
	7
9a74af21 BH	8	#include "nfsd.h"
9a74af21 BH	9	/* FIXME: nfsacl.h is a broken header */
a257cdd0	10	#include <linux/nfsacl.h>
5a0e3ad6	11	#include <linux/gfp.h>
9a74af21 BH	12	#include "cache.h"
9a74af21 BH	13	#include "xdr3.h"
0a3adade	14	#include "vfs.h"
a257cdd0 AG	15
	16	#define NFSDDBG_FACILITY NFSDDBG_PROC
	17	#define RETURN_STATUS(st) { resp->status = (st); return (st); }
	18
	19	/*
	20	* NULL call.
	21	*/
7111c66e	22	static __be32
a6beb732	23	nfsacld_proc_null(struct svc_rqst *rqstp)
a257cdd0 AG	24	{
	25	return nfs_ok;
	26	}
	27
	28	/*
	29	* Get the Access and/or Default ACL of a file.
	30	*/
a6beb732	31	static __be32 nfsacld_proc_getacl(struct svc_rqst *rqstp)
a257cdd0	32	{
a6beb732 CH	33	struct nfsd3_getaclargs *argp = rqstp->rq_argp;
a6beb732 CH	34	struct nfsd3_getaclres *resp = rqstp->rq_resp;
a257cdd0	35	struct posix_acl *acl;
4ac7249e CH	36	struct inode *inode;
4ac7249e CH	37	svc_fh *fh;
c4d987ba	38	__be32 nfserr = 0;
a257cdd0 AG	39
	40	dprintk("nfsd: GETACL(2acl) %s\n", SVCFH_fmt(&argp->fh));
	41
	42	fh = fh_copy(&resp->fh, &argp->fh);
8837abca MS	43	nfserr = fh_verify(rqstp, &resp->fh, 0, NFSD_MAY_NOP);
8837abca MS	44	if (nfserr)
ac8587dc	45	RETURN_STATUS(nfserr);
a257cdd0	46
2b0143b5	47	inode = d_inode(fh->fh_dentry);
4ac7249e	48
7b8f4586	49	if (argp->mask & ~NFS_ACL_MASK)
a257cdd0 AG	50	RETURN_STATUS(nfserr_inval);
	51	resp->mask = argp->mask;
	52
4f4a4fad BF	53	nfserr = fh_getattr(fh, &resp->stat);
4f4a4fad BF	54	if (nfserr)
7b8f4586	55	RETURN_STATUS(nfserr);
4f4a4fad	56
a257cdd0	57	if (resp->mask & (NFS_ACL\|NFS_ACLCNT)) {
4ac7249e	58	acl = get_acl(inode, ACL_TYPE_ACCESS);
a257cdd0 AG	59	if (acl == NULL) {
a257cdd0 AG	60	/* Solaris returns the inode's minimum ACL. */
a257cdd0 AG	61	acl = posix_acl_from_mode(inode->i_mode, GFP_KERNEL);
a257cdd0 AG	62	}
35e634b8 KM	63	if (IS_ERR(acl)) {
	64	nfserr = nfserrno(PTR_ERR(acl));
	65	goto fail;
	66	}
a257cdd0 AG	67	resp->acl_access = acl;
	68	}
	69	if (resp->mask & (NFS_DFACL\|NFS_DFACLCNT)) {
	70	/* Check how Solaris handles requests for the Default ACL
	71	of a non-directory! */
4ac7249e	72	acl = get_acl(inode, ACL_TYPE_DEFAULT);
a257cdd0	73	if (IS_ERR(acl)) {
4ac7249e CH	74	nfserr = nfserrno(PTR_ERR(acl));
4ac7249e CH	75	goto fail;
a257cdd0 AG	76	}
	77	resp->acl_default = acl;
	78	}
	79
	80	/* resp->acl_{access,default} are released in nfssvc_release_getacl. */
	81	RETURN_STATUS(0);
	82
	83	fail:
	84	posix_acl_release(resp->acl_access);
	85	posix_acl_release(resp->acl_default);
	86	RETURN_STATUS(nfserr);
	87	}
	88
	89	/*
	90	* Set the Access and/or Default ACL of a file.
	91	*/
a6beb732	92	static __be32 nfsacld_proc_setacl(struct svc_rqst *rqstp)
a257cdd0	93	{
a6beb732 CH	94	struct nfsd3_setaclargs *argp = rqstp->rq_argp;
a6beb732 CH	95	struct nfsd_attrstat *resp = rqstp->rq_resp;
4ac7249e	96	struct inode *inode;
a257cdd0	97	svc_fh *fh;
c4d987ba	98	__be32 nfserr = 0;
4ac7249e	99	int error;
a257cdd0 AG	100
	101	dprintk("nfsd: SETACL(2acl) %s\n", SVCFH_fmt(&argp->fh));
	102
	103	fh = fh_copy(&resp->fh, &argp->fh);
8837abca	104	nfserr = fh_verify(rqstp, &resp->fh, 0, NFSD_MAY_SATTR);
4ac7249e CH	105	if (nfserr)
4ac7249e CH	106	goto out;
a257cdd0	107
2b0143b5	108	inode = d_inode(fh->fh_dentry);
a257cdd0	109
4ac7249e CH	110	error = fh_want_write(fh);
	111	if (error)
	112	goto out_errno;
	113
99965378 BH	114	fh_lock(fh);
	115
	116	error = set_posix_acl(inode, ACL_TYPE_ACCESS, argp->acl_access);
4ac7249e	117	if (error)
99965378 BH	118	goto out_drop_lock;
99965378 BH	119	error = set_posix_acl(inode, ACL_TYPE_DEFAULT, argp->acl_default);
4ac7249e	120	if (error)
99965378 BH	121	goto out_drop_lock;
	122
	123	fh_unlock(fh);
4ac7249e CH	124
	125	fh_drop_write(fh);
	126
	127	nfserr = fh_getattr(fh, &resp->stat);
	128
	129	out:
a257cdd0 AG	130	/* argp->acl_{access,default} may have been allocated in
	131	nfssvc_decode_setaclargs. */
	132	posix_acl_release(argp->acl_access);
	133	posix_acl_release(argp->acl_default);
	134	return nfserr;
99965378 BH	135	out_drop_lock:
99965378 BH	136	fh_unlock(fh);
4ac7249e CH	137	fh_drop_write(fh);
	138	out_errno:
	139	nfserr = nfserrno(error);
	140	goto out;
a257cdd0 AG	141	}
	142
	143	/*
	144	* Check file attributes
	145	*/
a6beb732	146	static __be32 nfsacld_proc_getattr(struct svc_rqst *rqstp)
a257cdd0	147	{
a6beb732 CH	148	struct nfsd_fhandle *argp = rqstp->rq_argp;
a6beb732 CH	149	struct nfsd_attrstat *resp = rqstp->rq_resp;
4f4a4fad	150	__be32 nfserr;
a257cdd0 AG	151	dprintk("nfsd: GETATTR %s\n", SVCFH_fmt(&argp->fh));
	152
	153	fh_copy(&resp->fh, &argp->fh);
4f4a4fad BF	154	nfserr = fh_verify(rqstp, &resp->fh, 0, NFSD_MAY_NOP);
	155	if (nfserr)
	156	return nfserr;
	157	nfserr = fh_getattr(&resp->fh, &resp->stat);
	158	return nfserr;
a257cdd0 AG	159	}
	160
	161	/*
	162	* Check file access
	163	*/
a6beb732	164	static __be32 nfsacld_proc_access(struct svc_rqst *rqstp)
a257cdd0	165	{
a6beb732 CH	166	struct nfsd3_accessargs *argp = rqstp->rq_argp;
a6beb732 CH	167	struct nfsd3_accessres *resp = rqstp->rq_resp;
c4d987ba	168	__be32 nfserr;
a257cdd0 AG	169
	170	dprintk("nfsd: ACCESS(2acl) %s 0x%x\n",
	171	SVCFH_fmt(&argp->fh),
	172	argp->access);
	173
	174	fh_copy(&resp->fh, &argp->fh);
	175	resp->access = argp->access;
	176	nfserr = nfsd_access(rqstp, &resp->fh, &resp->access, NULL);
4f4a4fad BF	177	if (nfserr)
	178	return nfserr;
	179	nfserr = fh_getattr(&resp->fh, &resp->stat);
a257cdd0 AG	180	return nfserr;
	181	}
	182
	183	/*
	184	* XDR decode functions
	185	*/
026fec7e	186	static int nfsaclsvc_decode_getaclargs(struct svc_rqst rqstp, __be32 p)
a257cdd0	187	{
026fec7e CH	188	struct nfsd3_getaclargs *argp = rqstp->rq_argp;
026fec7e CH	189
d40aa337 BT	190	p = nfs2svc_decode_fh(p, &argp->fh);
d40aa337 BT	191	if (!p)
a257cdd0 AG	192	return 0;
	193	argp->mask = ntohl(*p); p++;
	194
	195	return xdr_argsize_check(rqstp, p);
	196	}
	197
	198
026fec7e	199	static int nfsaclsvc_decode_setaclargs(struct svc_rqst rqstp, __be32 p)
a257cdd0	200	{
026fec7e	201	struct nfsd3_setaclargs *argp = rqstp->rq_argp;
a257cdd0 AG	202	struct kvec *head = rqstp->rq_arg.head;
	203	unsigned int base;
	204	int n;
	205
d40aa337 BT	206	p = nfs2svc_decode_fh(p, &argp->fh);
d40aa337 BT	207	if (!p)
a257cdd0 AG	208	return 0;
a257cdd0 AG	209	argp->mask = ntohl(*p++);
7b8f4586	210	if (argp->mask & ~NFS_ACL_MASK \|\|
a257cdd0 AG	211	!xdr_argsize_check(rqstp, p))
	212	return 0;
	213
	214	base = (char )p - (char )head->iov_base;
	215	n = nfsacl_decode(&rqstp->rq_arg, base, NULL,
	216	(argp->mask & NFS_ACL) ?
	217	&argp->acl_access : NULL);
	218	if (n > 0)
	219	n = nfsacl_decode(&rqstp->rq_arg, base + n, NULL,
	220	(argp->mask & NFS_DFACL) ?
	221	&argp->acl_default : NULL);
	222	return (n > 0);
	223	}
	224
026fec7e	225	static int nfsaclsvc_decode_fhandleargs(struct svc_rqst rqstp, __be32 p)
a257cdd0	226	{
026fec7e CH	227	struct nfsd_fhandle *argp = rqstp->rq_argp;
026fec7e CH	228
d40aa337 BT	229	p = nfs2svc_decode_fh(p, &argp->fh);
d40aa337 BT	230	if (!p)
a257cdd0 AG	231	return 0;
	232	return xdr_argsize_check(rqstp, p);
	233	}
	234
026fec7e	235	static int nfsaclsvc_decode_accessargs(struct svc_rqst rqstp, __be32 p)
a257cdd0	236	{
026fec7e CH	237	struct nfsd3_accessargs *argp = rqstp->rq_argp;
026fec7e CH	238
d40aa337 BT	239	p = nfs2svc_decode_fh(p, &argp->fh);
d40aa337 BT	240	if (!p)
a257cdd0 AG	241	return 0;
	242	argp->access = ntohl(*p++);
	243
	244	return xdr_argsize_check(rqstp, p);
	245	}
	246
	247	/*
	248	* XDR encode functions
	249	*/
	250
1b7e0403 PS	251	/*
	252	* There must be an encoding function for void results so svc_process
	253	* will work properly.
	254	*/
63f8de37	255	static int nfsaclsvc_encode_voidres(struct svc_rqst rqstp, __be32 p)
1b7e0403 PS	256	{
	257	return xdr_ressize_check(rqstp, p);
	258	}
	259
a257cdd0	260	/* GETACL */
63f8de37	261	static int nfsaclsvc_encode_getaclres(struct svc_rqst rqstp, __be32 p)
a257cdd0	262	{
63f8de37	263	struct nfsd3_getaclres *resp = rqstp->rq_resp;
a257cdd0	264	struct dentry *dentry = resp->fh.fh_dentry;
aefa89d1	265	struct inode *inode;
a257cdd0 AG	266	struct kvec *head = rqstp->rq_res.head;
	267	unsigned int base;
	268	int n;
cb65a5ba	269	int w;
a257cdd0	270
aefa89d1 P	271	/*
	272	* Since this is version 2, the check for nfserr in
	273	* nfsd_dispatch actually ensures the following cannot happen.
	274	* However, it seems fragile to depend on that.
	275	*/
2b0143b5	276	if (dentry == NULL \|\| d_really_is_negative(dentry))
a257cdd0	277	return 0;
2b0143b5	278	inode = d_inode(dentry);
a257cdd0	279
4f4a4fad	280	p = nfs2svc_encode_fattr(rqstp, p, &resp->fh, &resp->stat);
a257cdd0 AG	281	*p++ = htonl(resp->mask);
	282	if (!xdr_ressize_check(rqstp, p))
	283	return 0;
	284	base = (char )p - (char )head->iov_base;
	285
cb65a5ba JJ	286	rqstp->rq_res.page_len = w = nfsacl_size(
	287	(resp->mask & NFS_ACL) ? resp->acl_access : NULL,
	288	(resp->mask & NFS_DFACL) ? resp->acl_default : NULL);
a257cdd0	289	while (w > 0) {
afc59400	290	if (!*(rqstp->rq_next_page++))
a257cdd0 AG	291	return 0;
	292	w -= PAGE_SIZE;
	293	}
	294
	295	n = nfsacl_encode(&rqstp->rq_res, base, inode,
	296	resp->acl_access,
	297	resp->mask & NFS_ACL, 0);
	298	if (n > 0)
	299	n = nfsacl_encode(&rqstp->rq_res, base + n, inode,
	300	resp->acl_default,
	301	resp->mask & NFS_DFACL,
	302	NFS_ACL_DEFAULT);
7b8f4586	303	return (n > 0);
a257cdd0 AG	304	}
a257cdd0 AG	305
63f8de37	306	static int nfsaclsvc_encode_attrstatres(struct svc_rqst rqstp, __be32 p)
a257cdd0	307	{
63f8de37 CH	308	struct nfsd_attrstat *resp = rqstp->rq_resp;
63f8de37 CH	309
4f4a4fad	310	p = nfs2svc_encode_fattr(rqstp, p, &resp->fh, &resp->stat);
a257cdd0 AG	311	return xdr_ressize_check(rqstp, p);
	312	}
	313
	314	/* ACCESS */
63f8de37	315	static int nfsaclsvc_encode_accessres(struct svc_rqst rqstp, __be32 p)
a257cdd0	316	{
63f8de37 CH	317	struct nfsd3_accessres *resp = rqstp->rq_resp;
63f8de37 CH	318
4f4a4fad	319	p = nfs2svc_encode_fattr(rqstp, p, &resp->fh, &resp->stat);
a257cdd0 AG	320	*p++ = htonl(resp->access);
	321	return xdr_ressize_check(rqstp, p);
	322	}
	323
	324	/*
	325	* XDR release functions
	326	*/
8537488b	327	static void nfsaclsvc_release_getacl(struct svc_rqst *rqstp)
a257cdd0	328	{
8537488b CH	329	struct nfsd3_getaclres *resp = rqstp->rq_resp;
8537488b CH	330
a257cdd0 AG	331	fh_put(&resp->fh);
	332	posix_acl_release(resp->acl_access);
	333	posix_acl_release(resp->acl_default);
a257cdd0 AG	334	}
a257cdd0 AG	335
8537488b	336	static void nfsaclsvc_release_attrstat(struct svc_rqst *rqstp)
a257cdd0	337	{
8537488b CH	338	struct nfsd_attrstat *resp = rqstp->rq_resp;
8537488b CH	339
a257cdd0	340	fh_put(&resp->fh);
a257cdd0 AG	341	}
a257cdd0 AG	342
8537488b	343	static void nfsaclsvc_release_access(struct svc_rqst *rqstp)
c9ce2283	344	{
8537488b CH	345	struct nfsd3_accessres *resp = rqstp->rq_resp;
	346
	347	fh_put(&resp->fh);
c9ce2283 GB	348	}
c9ce2283 GB	349
a257cdd0	350	#define nfsaclsvc_decode_voidargs NULL
a257cdd0 AG	351	#define nfsaclsvc_release_void NULL
	352	#define nfsd3_fhandleargs nfsd_fhandle
	353	#define nfsd3_attrstatres nfsd_attrstat
	354	#define nfsd3_voidres nfsd3_voidargs
	355	struct nfsd3_voidargs { int dummy; };
	356
f7235b6b CH	357	#define PROC(name, argt, rest, relt, cache, respsize) \
f7235b6b CH	358	{ \
a6beb732	359	.pc_func = nfsacld_proc_##name, \
026fec7e	360	.pc_decode = nfsaclsvc_decode_##argt##args, \
63f8de37	361	.pc_encode = nfsaclsvc_encode_##rest##res, \
8537488b	362	.pc_release = nfsaclsvc_release_##relt, \
f7235b6b CH	363	.pc_argsize = sizeof(struct nfsd3_##argt##args), \
	364	.pc_ressize = sizeof(struct nfsd3_##rest##res), \
	365	.pc_cachetype = cache, \
	366	.pc_xdrressize = respsize, \
	367	}
a257cdd0 AG	368
	369	#define ST 1 /* status*/
	370	#define AT 21 /* attributes */
	371	#define pAT (1+AT) /* post attributes - conditional */
	372	#define ACL (1+NFS_ACL_MAX_ENTRIES3) / Access Control List */
	373
860bda29	374	static const struct svc_procedure nfsd_acl_procedures2[] = {
a257cdd0 AG	375	PROC(null, void, void, void, RC_NOCACHE, ST),
a257cdd0 AG	376	PROC(getacl, getacl, getacl, getacl, RC_NOCACHE, ST+1+2*(1+ACL)),
c9ce2283 GB	377	PROC(setacl, setacl, attrstat, attrstat, RC_NOCACHE, ST+AT),
	378	PROC(getattr, fhandle, attrstat, attrstat, RC_NOCACHE, ST+AT),
	379	PROC(access, access, access, access, RC_NOCACHE, ST+AT+1),
a257cdd0 AG	380	};
a257cdd0 AG	381
7fd38af9	382	static unsigned int nfsd_acl_count2[ARRAY_SIZE(nfsd_acl_procedures2)];
e9679189 CH	383	const struct svc_version nfsd_acl_version2 = {
	384	.vs_vers = 2,
	385	.vs_nproc = 5,
	386	.vs_proc = nfsd_acl_procedures2,
	387	.vs_count = nfsd_acl_count2,
	388	.vs_dispatch = nfsd_dispatch,
	389	.vs_xdrsize = NFS3_SVC_XDRSIZE,
a257cdd0	390	};